diff --git a/Examples/Sample.py b/Examples/Sample.py
deleted file mode 100644
index 891b764..0000000
--- a/Examples/Sample.py
+++ /dev/null
@@ -1,165 +0,0 @@
-from __future__ import (absolute_import, division, print_function)
-
-__author__ = 'stephanie'
-
-#import matplotlib.pyplot as plt
-
-
-
-
-from odm2api.ODMconnection import dbconnection
-from odm2api.ODM2.services.readService import *
-from odm2api.ODM2.services import CreateODM2
-# Create a connection to the ODM2 database
-# ----------------------------------------
-
-
-#connect to database
-# createconnection (dbtype, servername, dbname, username, password)
-# session_factory = dbconnection.createConnection('connection type: sqlite|mysql|mssql|postgresql', '/your/path/to/db/goes/here', 2.0)#sqlite
-
-
-# session_factory = dbconnection.createConnection('postgresql', 'localhost', 'odm2', 'ODM', 'odm')
-# session_factory = dbconnection.createConnection('mysql', 'localhost', 'odm2', 'ODM', 'odm')#mysql
-session_factory= dbconnection.createConnection('mssql', "(local)", "ODM2", "ODM", "odm")#win MSSQL
-# session_factory= dbconnection.createConnection('mssql', "arroyoodm2", "", "ODM", "odm")#mac/linux MSSQL
-# session_factory = dbconnection.createConnection('sqlite', 'path/to/ODM2.sqlite', 2.0)
-
-
-
-
-#_session = session_factory.getSession()
-read = ReadODM2(session_factory)
-create = CreateODM2(session_factory)
-
-
-# Run some basic sample queries.
-# ------------------------------
-# Get all of the variables from the database and print their names to the console
-allVars = read.getVariables()
-print ("\n-------- Information about Variables ---------")
-for x in allVars:
-    print(x.VariableCode + ": " + x.VariableNameCV)
-
-
-
-# Get all of the people from the database
-allPeople = read.getPeople()
-print ("\n-------- Information about People ---------")
-for x in allPeople:
-    print(x.PersonFirstName + " " + x.PersonLastName)
-
-try:
-    print("\n-------- Information about an Affiliation ---------")
-    allaff = read.getAffiliations()
-    for x in allaff:
-        print(x.PersonObj.PersonFirstName + ": " + str(x.OrganizationID))
-except Exception as e:
-    print("Unable to demo getAllAffiliations", e)
-
-# Get all of the SamplingFeatures from the database that are Sites
-try:
-    print ("\n-------- Information about Sites ---------")
-    siteFeatures = read.getSamplingFeatures(type= 'site')
-
-    # siteFeatures = read.getSamplingFeatures(type='Site')
-    numSites = len(siteFeatures)
-    print ("Successful query")
-    for x in siteFeatures:
-        print(x.SamplingFeatureCode + ": " + x.SamplingFeatureTypeCV )
-except Exception as e:
-    print("Unable to demo getSamplingFeaturesByType", e)
-
-
-# Now get the SamplingFeature object for a SamplingFeature code
-try:
-    sf = read.getSamplingFeatures(codes=['USU-LBR-Mendon'])[0]
-    print(sf)
-    print("\n-------- Information about an individual SamplingFeature ---------")
-    print("The following are some of the attributes of a SamplingFeature retrieved using getSamplingFeatureByCode(): \n")
-    print("SamplingFeatureCode: " + sf.SamplingFeatureCode)
-    print("SamplingFeatureName: " + sf.SamplingFeatureName)
-    print("SamplingFeatureDescription: %s" % sf.SamplingFeatureDescription)
-    print("SamplingFeatureGeotypeCV: %s" % sf.SamplingFeatureGeotypeCV)
-    print("SamplingFeatureGeometry: %s" % sf.FeatureGeometry)
-    print("Elevation_m: %s" % str(sf.Elevation_m))
-except Exception as e:
-    print("Unable to demo getSamplingFeatureByCode: ", e)
-
-#add sampling feature
-print("\n------------ Create Sampling Feature --------- \n")
-try:
-    # from odm2api.ODM2.models import SamplingFeatures
-    session = session_factory.getSession()
-    newsf = Sites(FeatureGeometryWKT = "POINT(-111.946 41.718)", Elevation_m=100, ElevationDatumCV=sf.ElevationDatumCV,
-    SamplingFeatureCode= "TestSF",SamplingFeatureDescription = "this is a test in sample.py",
-    SamplingFeatureGeotypeCV= "Point", SamplingFeatureTypeCV=sf.SamplingFeatureTypeCV,SamplingFeatureUUID= sf.SamplingFeatureUUID+"2",
-    SiteTypeCV="cave", Latitude= "100", Longitude= "-100", SpatialReferenceID= 0)
-
-    c=create.createSamplingFeature(newsf)
-    #session.commit()
-    print("new sampling feature added to database", c)
-
-except Exception as e :
-    print("error adding a sampling feature: " + str(e))
-
-
-# Drill down and get objects linked by foreign keys
-print("\n------------ Foreign Key Example --------- \n",)
-try:
-    # Call getResults, but return only the first result
-    firstResult = read.getResults()[0]
-    print("The FeatureAction object for the Result is: ", firstResult.FeatureActionObj)
-    print("The Action object for the Result is: ", firstResult.FeatureActionObj.ActionObj)
-    print ("\nThe following are some of the attributes for the Action that created the Result: \n" +
-           "ActionTypeCV: " + firstResult.FeatureActionObj.ActionObj.ActionTypeCV + "\n" +
-           "ActionDescription: " + firstResult.FeatureActionObj.ActionObj.ActionDescription + "\n" +
-           "BeginDateTime: " + str(firstResult.FeatureActionObj.ActionObj.BeginDateTime) + "\n" +
-           "EndDateTime: " + str(firstResult.FeatureActionObj.ActionObj.EndDateTime) + "\n" +
-           "MethodName: " + firstResult.FeatureActionObj.ActionObj.MethodObj.MethodName + "\n" +
-           "MethodDescription: " + firstResult.FeatureActionObj.ActionObj.MethodObj.MethodDescription)
-except Exception as e:
-    print("Unable to demo Foreign Key Example: ", e)
-
-
-# Now get a particular Result using a ResultID
-print("\n------- Example of Retrieving Attributes of a Result -------")
-try:
-    tsResult = read.getResults(ids = [1])[0]
-    print (
-        "The following are some of the attributes for the TimeSeriesResult retrieved using getResults(ids=[1]): \n" +
-        "ResultTypeCV: " + tsResult.ResultTypeCV + "\n" +
-        # Get the ProcessingLevel from the TimeSeriesResult's ProcessingLevel object
-        "ProcessingLevel: " + tsResult.ProcessingLevelObj.Definition + "\n" +
-        "SampledMedium: " + tsResult.SampledMediumCV + "\n" +
-        # Get the variable information from the TimeSeriesResult's Variable object
-        "Variable: " + tsResult.VariableObj.VariableCode + ": " + tsResult.VariableObj.VariableNameCV + "\n"
-                               #"AggregationStatistic: " + tsResult.AggregationStatisticCV + "\n" +
-
-        # Get the site information by drilling down
-        "SamplingFeature: " + tsResult.FeatureActionObj.SamplingFeatureObj.SamplingFeatureCode + " - " +
-        tsResult.FeatureActionObj.SamplingFeatureObj.SamplingFeatureName)
-except Exception as e:
-    print("Unable to demo Example of retrieving Attributes of a time Series Result: ", e)
-
-# Get the values for a particular TimeSeriesResult
-print("\n-------- Example of Retrieving Time Series Result Values ---------")
-
-tsValues = read.getResultValues(resultids = [1])  # Return type is a pandas datafram
-
-# Print a few Time Series Values to the console
-# tsValues.set_index('ValueDateTime', inplace=True)
-try:
-    print(tsValues.head())
-except Exception as e:
-    print(e)
-
-# Plot the time series
-
-try:
-    plt.figure()
-    ax=tsValues.plot(x='ValueDateTime', y='DataValue')
-
-    plt.show()
-except Exception as e:
-    print("Unable to demo plotting of tsValues: ", e)
diff --git a/Examples/TimeSeries_RetrieveVisualize.ipynb b/Examples/TimeSeries_RetrieveVisualize.ipynb
new file mode 100644
index 0000000..aa2551c
--- /dev/null
+++ b/Examples/TimeSeries_RetrieveVisualize.ipynb
@@ -0,0 +1,705 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# ODM2 API: Retrieve, manipulate and visualize ODM2 time series data"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This example shows how to use the ODM2 Python API (`odm2api`) to connect to an ODM2 database, retrieve data, and analyze and visualize the data. The [database (USU_LittleBearRiver_timeseriesresults_ODM2.sqlite)](https://github.com/ODM2/ODM2PythonAPI/blob/master/Examples/data/USU_LittleBearRiver_timeseriesresults_ODM2.sqlite) contains [\"timeSeriesCoverage\"-type results](http://vocabulary.odm2.org/resulttype/timeSeriesCoverage/).\n",
+    "\n",
+    "This example uses SQLite for the database because it doesn't require a server. However, the ODM2 Python API demonstrated here can alse be used with ODM2 databases implemented in MySQL, PostgreSQL or Microsoft SQL Server.\n",
+    "\n",
+    "More details on the ODM2 Python API and its source code and latest development can be found at https://github.com/ODM2/ODM2PythonAPI\n",
+    "\n",
+    "[Emilio Mayorga](https://github.com/emiliom/). Last updated 2018-10-7."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Adapted from notebook https://big-cz.github.io/notebook_data_demo/notebooks/2017-06-24-odm2api_sample_fromsqlite/, based on earlier code and an ODM2 database from [Jeff Horsburgh's group](http://jeffh.usu.edu) at Utah State University."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%matplotlib inline\n",
+    "\n",
+    "import os\n",
+    "\n",
+    "import matplotlib as mpl\n",
+    "import matplotlib.pyplot as plt\n",
+    "import pandas as pd\n",
+    "\n",
+    "import odm2api\n",
+    "from odm2api.ODMconnection import dbconnection\n",
+    "import odm2api.services.readService as odm2rs"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "u'0.23.4'"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "pd.__version__"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**odm2api version used** to run this notebook:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "u'0.7.1'"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "odm2api.__version__"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Connect to the ODM2 SQLite Database\n",
+    "\n",
+    "This example uses an ODM2 SQLite database file loaded with a sensor-based, high-frequency temperature time series from a site in the [Little Bear River, in Logan, Utah, from Utah State University](http://littlebearriver.usu.edu/). The [database (USU_LittleBearRiver_timeseriesresults_ODM2.sqlite)](https://github.com/ODM2/ODM2PythonAPI/blob/master/Examples/data/USU_LittleBearRiver_timeseriesresults_ODM2.sqlite) contains [\"timeSeriesCoverage\"-type results](http://vocabulary.odm2.org/resulttype/timeSeriesCoverage/).\n",
+    "\n",
+    "The example database is located in the `data` sub-directory."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Assign directory paths and SQLite file name\n",
+    "dbname_sqlite = \"USU_LittleBearRiver_timeseriesresults_ODM2.sqlite\"\n",
+    "\n",
+    "sqlite_pth = os.path.join(\"data\", dbname_sqlite)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Database connection successful!\n"
+     ]
+    }
+   ],
+   "source": [
+    "try:\n",
+    "    session_factory = dbconnection.createConnection('sqlite', sqlite_pth)\n",
+    "    read = odm2rs.ReadODM2(session_factory)\n",
+    "    print(\"Database connection successful!\")\n",
+    "except Exception as e:\n",
+    "    print(\"Unable to establish connection to the database: \", e)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Run Some Basic Queries on the ODM2 Database\n",
+    "\n",
+    "This section shows some examples of how to use the API to run both simple and more advanced queries on the ODM2 database, as well as how to examine the query output in convenient ways thanks to Python tools. The notebook [WaterQualityMeasurements_RetrieveVisualize.ipynb](https://github.com/ODM2/ODM2PythonAPI/blob/master/Examples/WaterQualityMeasurements_RetrieveVisualize.ipynb) includes more extensive examples of `odm2api`-based querying and examinations of the information that is returned.\n",
+    "\n",
+    "Simple query functions like **getVariables( )** return objects similar to the entities in ODM2, and individual attributes can then be retrieved from the objects returned. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "USU36: Temperature\n"
+     ]
+    }
+   ],
+   "source": [
+    "allVars = read.getVariables()\n",
+    "\n",
+    "for x in allVars:\n",
+    "    print('{}: {}'.format(x.VariableCode, x.VariableNameCV))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### SamplingFeatures\n",
+    "Request all sampling features, then examine them. Only one sampling feature is present, with `SamplingFeatureTypeCV` type `Site`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "1"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "sf_lst = read.getSamplingFeatures()\n",
+    "len(sf_lst)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'ElevationDatumCV': u'NGVD29',\n",
+       " 'Elevation_m': 1345.0,\n",
+       " 'FeatureGeometryWKT': u'POINT (-111.946402 41.718473)',\n",
+       " 'SamplingFeatureCode': u'USU-LBR-Mendon',\n",
+       " 'SamplingFeatureDescription': None,\n",
+       " 'SamplingFeatureGeotypeCV': u'Point',\n",
+       " 'SamplingFeatureID': 1,\n",
+       " 'SamplingFeatureName': u'Little Bear River at Mendon Road near Mendon, Utah',\n",
+       " 'SamplingFeatureTypeCV': u'Site',\n",
+       " 'SamplingFeatureUUID': u'6c74a4bd-e1d4-11e5-95b8-f45c8999816f',\n",
+       " '_sa_instance_state': <sqlalchemy.orm.state.InstanceState at 0x7fc8bc53a690>}"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "vars(sf_lst[0])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "USU-LBR-Mendon: Little Bear River at Mendon Road near Mendon, Utah\n"
+     ]
+    }
+   ],
+   "source": [
+    "print('{}: {}'.format(sf_lst[0].SamplingFeatureCode, sf_lst[0].SamplingFeatureName))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Results and Actions"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "You can also drill down and get objects linked by foreign keys. The API returns related objects in a nested hierarchy so they can be interrogated in an object oriented way. So, if I use the **getResults( )** function to return a Result from the database (e.g., a \"Time Series\" Result), I also get the associated Action that created that Result (e.g., an \"Observation\" Action)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "1"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# What's the total number of results in the database?\n",
+    "len(read.getResults())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "The ResultID for the Result is: 1\n",
+      "('The FeatureAction object for the Result is: ', <FeatureActions({'FeatureActionID': 1, 'SamplingFeatureID': 1, 'ActionID': 1})>)\n",
+      "('The Action object for the Result is: ', <Actions({'MethodID': 1, 'ActionDescription': u'An observation action that generated a time series result.', 'ActionFileLink': None, 'EndDateTime': datetime.datetime(2009, 1, 16, 12, 30), 'BeginDateTime': datetime.datetime(2007, 8, 16, 16, 30), 'BeginDateTimeUTCOffset': -7, 'ActionTypeCV': u'Observation', 'ActionID': 1, 'EndDateTimeUTCOffset': -7})>)\n",
+      "\n",
+      "The following are some of the attributes for the Action that created the Result: \n",
+      "ActionTypeCV: Observation\n",
+      "ActionDescription: An observation action that generated a time series result.\n",
+      "BeginDateTime: 2007-08-16 16:30:00\n",
+      "EndDateTime: 2009-01-16 12:30:00\n",
+      "MethodName: Quality Control Level 1 Data Series created from raw QC Level 0 data using ODM Tools.\n",
+      "MethodDescription: Quality Control Level 1 Data Series created from raw QC Level 0 data using ODM Tools.\n"
+     ]
+    }
+   ],
+   "source": [
+    "try:\n",
+    "    # Call getResults, but return only the first Result\n",
+    "    firstResult = read.getResults()[0]\n",
+    "    frfa = firstResult.FeatureActionObj\n",
+    "    frfaa = firstResult.FeatureActionObj.ActionObj\n",
+    "    print(\"The ResultID for the Result is: {}\".format(firstResult.ResultID))\n",
+    "    print(\"The FeatureAction object for the Result is: \", frfa)\n",
+    "    print(\"The Action object for the Result is: \", frfaa)\n",
+    "    \n",
+    "    # Print some Action attributes in a more human readable form\n",
+    "    print(\"\\nThe following are some of the attributes for the Action that created the Result: \")\n",
+    "    print(\"ActionTypeCV: {}\".format(frfaa.ActionTypeCV))\n",
+    "    print(\"ActionDescription: {}\".format(frfaa.ActionDescription))\n",
+    "    print(\"BeginDateTime: {}\".format(frfaa.BeginDateTime))\n",
+    "    print(\"EndDateTime: {}\".format(frfaa.EndDateTime))\n",
+    "    print(\"MethodName: {}\".format(frfaa.MethodObj.MethodName))\n",
+    "    print(\"MethodDescription: {}\".format(frfaa.MethodObj.MethodDescription))\n",
+    "except Exception as e:\n",
+    "    print(\"Unable to demo Foreign Key Example: {}\".format(e))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Retrieve Attributes of a Time Series Result using a ResultID\n",
+    "Use the ResultID (1) from the above result to issue a filtered query."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(odm2api.models.TimeSeriesResults,\n",
+       " {'FeatureActionID': 1,\n",
+       "  'FeatureActionObj': <FeatureActions({'FeatureActionID': 1, 'SamplingFeatureID': 1, 'ActionID': 1})>,\n",
+       "  'ProcessingLevelID': 1,\n",
+       "  'ResultDateTime': datetime.datetime(2016, 3, 3, 23, 43, 37, 369446),\n",
+       "  'ResultDateTimeUTCOffset': -7,\n",
+       "  'ResultID': 1,\n",
+       "  'ResultTypeCV': u'Time series coverage',\n",
+       "  'ResultUUID': u'6c769102-e1d4-11e5-8d14-f45c8999816f',\n",
+       "  'SampledMediumCV': u'Surface Water',\n",
+       "  'StatusCV': u'Unknown',\n",
+       "  'TaxonomicClassifierID': None,\n",
+       "  'UnitsID': 96,\n",
+       "  'ValidDateTime': None,\n",
+       "  'ValidDateTimeUTCOffset': None,\n",
+       "  'ValueCount': 24206,\n",
+       "  'VariableID': 1,\n",
+       "  '_sa_instance_state': <sqlalchemy.orm.state.InstanceState at 0x7fc8bc4d6d90>})"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Filering on a single ResultID will invariably return a single result; \n",
+    "# so, get the single element in the returned list\n",
+    "tsResult = read.getResults(ids=[1])[0]\n",
+    "\n",
+    "# Examine the object type and content\n",
+    "type(tsResult), vars(tsResult)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Get a Result and its Attributes\n",
+    "\n",
+    "Because all of the objects are returned in a nested form, if you retrieve a result, you can interrogate it to get all of its related attributes. When a Result object is returned, it includes objects that contain information about Variable, Units, ProcessingLevel, and the related Action that created that Result."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "------- Example of Retrieving Attributes of a Result -------\n",
+      "The following are some of the attributes for the Result retrieved: \n",
+      "ResultID: 1\n",
+      "ResultTypeCV: Time series coverage\n",
+      "ValueCount: 24206\n",
+      "ProcessingLevel: Quality controlled data\n",
+      "SampledMedium: Surface Water\n",
+      "Variable: USU36: Temperature\n",
+      "AggregationStatisticCV: Average\n",
+      "Units: degree celsius\n",
+      "SamplingFeatureID: 1\n",
+      "SamplingFeatureCode: USU-LBR-Mendon\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"------- Example of Retrieving Attributes of a Result -------\")\n",
+    "try:\n",
+    "    firstResult = read.getResults()[0]\n",
+    "    frfa = firstResult.FeatureActionObj\n",
+    "    print(\"The following are some of the attributes for the Result retrieved: \")\n",
+    "    print(\"ResultID: {}\".format(firstResult.ResultID))\n",
+    "    print(\"ResultTypeCV: {}\".format(firstResult.ResultTypeCV))\n",
+    "    print(\"ValueCount: {}\".format(firstResult.ValueCount))\n",
+    "    print(\"ProcessingLevel: {}\".format(firstResult.ProcessingLevelObj.Definition))\n",
+    "    print(\"SampledMedium: {}\".format(firstResult.SampledMediumCV))\n",
+    "    print(\"Variable: {}: {}\".format(firstResult.VariableObj.VariableCode, \n",
+    "                                    firstResult.VariableObj.VariableNameCV))\n",
+    "    print(\"AggregationStatisticCV: {}\".format(firstResult.AggregationStatisticCV))\n",
+    "    print(\"Units: {}\".format(firstResult.UnitsObj.UnitsName))\n",
+    "    print(\"SamplingFeatureID: {}\".format(frfa.SamplingFeatureObj.SamplingFeatureID))\n",
+    "    print(\"SamplingFeatureCode: {}\".format(frfa.SamplingFeatureObj.SamplingFeatureCode))\n",
+    "except Exception as e:\n",
+    "    print(\"Unable to demo example of retrieving Attributes of a Result: {}\".format(e))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "-----------------------------------------\n",
+    "\n",
+    "## Retrieve Time Series Result Values for a given Result\n",
+    "\n",
+    "The database contains a single time series result (a time series of water temperature sensor data at a single site). Let's use the **getResults( )** function to retrieve the time series values for this result by passing in the ResultID. We set the index to `ValueDateTime` for convenience."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>ValueID</th>\n",
+       "      <th>ResultID</th>\n",
+       "      <th>DataValue</th>\n",
+       "      <th>ValueDateTimeUTCOffset</th>\n",
+       "      <th>CensorCodeCV</th>\n",
+       "      <th>QualityCodeCV</th>\n",
+       "      <th>TimeAggregationInterval</th>\n",
+       "      <th>TimeAggregationIntervalUnitsID</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>ValueDateTime</th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>2007-08-16 16:30:00</th>\n",
+       "      <td>1</td>\n",
+       "      <td>1</td>\n",
+       "      <td>22.20000</td>\n",
+       "      <td>-7</td>\n",
+       "      <td>nc</td>\n",
+       "      <td>Unknown</td>\n",
+       "      <td>30.0</td>\n",
+       "      <td>102</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2007-08-16 17:00:00</th>\n",
+       "      <td>2</td>\n",
+       "      <td>1</td>\n",
+       "      <td>22.19833</td>\n",
+       "      <td>-7</td>\n",
+       "      <td>nc</td>\n",
+       "      <td>Unknown</td>\n",
+       "      <td>30.0</td>\n",
+       "      <td>102</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2007-08-16 17:30:00</th>\n",
+       "      <td>3</td>\n",
+       "      <td>1</td>\n",
+       "      <td>22.18500</td>\n",
+       "      <td>-7</td>\n",
+       "      <td>nc</td>\n",
+       "      <td>Unknown</td>\n",
+       "      <td>30.0</td>\n",
+       "      <td>102</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2007-08-16 18:00:00</th>\n",
+       "      <td>4</td>\n",
+       "      <td>1</td>\n",
+       "      <td>22.03833</td>\n",
+       "      <td>-7</td>\n",
+       "      <td>nc</td>\n",
+       "      <td>Unknown</td>\n",
+       "      <td>30.0</td>\n",
+       "      <td>102</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2007-08-16 18:30:00</th>\n",
+       "      <td>5</td>\n",
+       "      <td>1</td>\n",
+       "      <td>21.88167</td>\n",
+       "      <td>-7</td>\n",
+       "      <td>nc</td>\n",
+       "      <td>Unknown</td>\n",
+       "      <td>30.0</td>\n",
+       "      <td>102</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                     ValueID  ResultID  DataValue  ValueDateTimeUTCOffset  \\\n",
+       "ValueDateTime                                                               \n",
+       "2007-08-16 16:30:00        1         1   22.20000                      -7   \n",
+       "2007-08-16 17:00:00        2         1   22.19833                      -7   \n",
+       "2007-08-16 17:30:00        3         1   22.18500                      -7   \n",
+       "2007-08-16 18:00:00        4         1   22.03833                      -7   \n",
+       "2007-08-16 18:30:00        5         1   21.88167                      -7   \n",
+       "\n",
+       "                    CensorCodeCV QualityCodeCV  TimeAggregationInterval  \\\n",
+       "ValueDateTime                                                             \n",
+       "2007-08-16 16:30:00           nc       Unknown                     30.0   \n",
+       "2007-08-16 17:00:00           nc       Unknown                     30.0   \n",
+       "2007-08-16 17:30:00           nc       Unknown                     30.0   \n",
+       "2007-08-16 18:00:00           nc       Unknown                     30.0   \n",
+       "2007-08-16 18:30:00           nc       Unknown                     30.0   \n",
+       "\n",
+       "                     TimeAggregationIntervalUnitsID  \n",
+       "ValueDateTime                                        \n",
+       "2007-08-16 16:30:00                             102  \n",
+       "2007-08-16 17:00:00                             102  \n",
+       "2007-08-16 17:30:00                             102  \n",
+       "2007-08-16 18:00:00                             102  \n",
+       "2007-08-16 18:30:00                             102  "
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Get the values for a particular TimeSeriesResult; a Pandas Dataframe is returned\n",
+    "tsValues = read.getResultValues(resultids=[1], lowercols=False)\n",
+    "tsValues.loc[:, 'ValueDateTime'] = pd.to_datetime(tsValues['ValueDateTime'])\n",
+    "tsValues.set_index('ValueDateTime', inplace=True)\n",
+    "tsValues.sort_index(inplace=True)\n",
+    "\n",
+    "tsValues.head()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**10/5/2018. NOTE CURRENT ISSUE REGARDING `ValueDateTime` RETURNED BY `read.getResultValues`.** There seems to be an unexpected behavior with the data type returned for `ValueDateTime` for SQLite databases. It should be a datetime, but it's currently a string. This is [being investigated](https://github.com/ODM2/ODM2PythonAPI/issues/158). For now, we are converting to a datetime manually, above, via the statement:\n",
+    "```python\n",
+    "resultValues.loc[:, 'ValueDateTime'] = pd.to_datetime(resultValues['ValueDateTime'])\n",
+    "```\n",
+    "This problem is present in `odm2api` version 0.7.1, but was not present in Nov. 2017"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Now plot the time series\n",
+    "First as a very quick and easy plot using the Pandas Dataframe `plot` method with default settings. Then with fancier matplotlib customizations of the axes and figure size."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.axes._subplots.AxesSubplot at 0x7fc8bbb5af10>"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "tsValues['DataValue'].plot()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 864x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, ax = plt.subplots(figsize=(12, 4))\n",
+    "tsValues['DataValue'].plot(ax=ax)\n",
+    "\n",
+    "ax.set_ylabel('{} ({})'.format(\n",
+    "    tsResult.VariableObj.VariableNameCV, tsResult.UnitsObj.UnitsAbbreviation))\n",
+    "ax.set_xlabel('')\n",
+    "\n",
+    "ax.xaxis.set_minor_locator(mpl.dates.MonthLocator())\n",
+    "ax.xaxis.set_minor_formatter(mpl.dates.DateFormatter('%b'))\n",
+    "ax.xaxis.set_major_locator(mpl.dates.YearLocator())\n",
+    "ax.xaxis.set_major_formatter(mpl.dates.DateFormatter('\\n%Y'))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python [conda env:odm2client_20180915]",
+   "language": "python",
+   "name": "conda-env-odm2client_20180915-py"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 2
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython2",
+   "version": "2.7.15"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/Examples/WaterQualityMeasurements_RetrieveVisualize.ipynb b/Examples/WaterQualityMeasurements_RetrieveVisualize.ipynb
index 11d5db7..ffa20b2 100644
--- a/Examples/WaterQualityMeasurements_RetrieveVisualize.ipynb
+++ b/Examples/WaterQualityMeasurements_RetrieveVisualize.ipynb
@@ -11,20 +11,20 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "This example shows how to connect to an ODM2 database using the ODM2 Python API, retrieve data, and use it for analysis or visualization. The [database (iUTAHGAMUT_waterquality_measurementresults_ODM2.sqlite)](https://github.com/ODM2/ODM2PythonAPI/blob/master/Examples/data/iUTAHGAMUT_waterquality_measurementresults_ODM2.sqlite) contains [\"measurement\"-type results](http://vocabulary.odm2.org/resulttype/measurement/).\n",
+    "This example shows how to use the ODM2 Python API (`odm2api`) to connect to an ODM2 database, retrieve data, and analyze and visualize the data. The [database (iUTAHGAMUT_waterquality_measurementresults_ODM2.sqlite)](https://github.com/ODM2/ODM2PythonAPI/blob/master/Examples/data/iUTAHGAMUT_waterquality_measurementresults_ODM2.sqlite) contains [\"measurement\"-type results](http://vocabulary.odm2.org/resulttype/measurement/).\n",
     "\n",
-    "This example uses SQLite for the database because it doesn't require a server. However, the ODM2 Python API demonstrated here can alse be used with ODM2 databases implemented in MySQL, PostgresSQL or Microsoft SQL Server.\n",
+    "This example uses SQLite for the database because it doesn't require a server. However, the ODM2 Python API demonstrated here can alse be used with ODM2 databases implemented in MySQL, PostgreSQL or Microsoft SQL Server.\n",
     "\n",
-    "More details on the ODM2 Python API and its source code and latest development can be found at: https://github.com/ODM2/ODM2PythonAPI\n",
+    "More details on the ODM2 Python API and its source code and latest development can be found at https://github.com/ODM2/ODM2PythonAPI\n",
     "\n",
-    "[Emilio Mayorga](https://github.com/emiliom/). Last udpated 9/23/2018."
+    "[Emilio Mayorga](https://github.com/emiliom/). Last updated 2018-10-7."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Adapted from notebook https://github.com/BiG-CZ/wshp2017_tutorial_content/blob/master/notebooks/ODM2_Example3.ipynb"
+    "Adapted from notebook https://github.com/BiG-CZ/wshp2017_tutorial_content/blob/master/notebooks/ODM2_Example3.ipynb, based in part on earlier code and an ODM2 database from [Jeff Horsburgh's group](http://jeffh.usu.edu) at Utah State University."
    ]
   },
   {
@@ -35,9 +35,7 @@
    "source": [
     "%matplotlib inline\n",
     "\n",
-    "import sys\n",
     "import os\n",
-    "import sqlite3\n",
     "\n",
     "import matplotlib.pyplot as plt\n",
     "from shapely.geometry import Point\n",
@@ -103,9 +101,9 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Make a Connection to the ODM2 SQLite Database\n",
+    "## Connect to the ODM2 SQLite Database\n",
     "\n",
-    "This example uses an ODM2 SQLite database loaded with water quality sample data from multiple monitoring sites in the [iUTAH](https://iutahepscor.org/) Gradients Along Mountain to Urban Transitions ([GAMUT](http://data.iutahepscor.org/mdf/Data/Gamut_Network/)) water quality monitoring network. Water quality samples have been collected and analyzed for nitrogen, phosphorus, total coliform, E-coli, and some water isotopes. The [database (iUTAHGAMUT_waterquality_measurementresults_ODM2.sqlite)](https://github.com/ODM2/ODM2PythonAPI/blob/master/Examples/data/iUTAHGAMUT_waterquality_measurementresults_ODM2.sqlite) contains [\"measurement\"-type results](http://vocabulary.odm2.org/resulttype/measurement/).\n",
+    "This example uses an ODM2 SQLite database file loaded with water quality sample data from multiple monitoring sites in the [iUTAH](https://iutahepscor.org/) Gradients Along Mountain to Urban Transitions ([GAMUT](http://data.iutahepscor.org/mdf/Data/Gamut_Network/)) water quality monitoring network. Water quality samples have been collected and analyzed for nitrogen, phosphorus, total coliform, E-coli, and some water isotopes. The [database (iUTAHGAMUT_waterquality_measurementresults_ODM2.sqlite)](https://github.com/ODM2/ODM2PythonAPI/blob/master/Examples/data/iUTAHGAMUT_waterquality_measurementresults_ODM2.sqlite) contains [\"measurement\"-type results](http://vocabulary.odm2.org/resulttype/measurement/).\n",
     "\n",
     "The example database is located in the `data` sub-directory."
    ]
@@ -137,7 +135,7 @@
    ],
    "source": [
     "try:\n",
-    "    session_factory = dbconnection.createConnection('sqlite', sqlite_pth, 2.0)\n",
+    "    session_factory = dbconnection.createConnection('sqlite', sqlite_pth)\n",
     "    read = odm2rs.ReadODM2(session_factory)\n",
     "    print(\"Database connection successful!\")\n",
     "except Exception as e:\n",
@@ -150,7 +148,7 @@
    "source": [
     "## Run Some Basic Queries on the ODM2 Database\n",
     "\n",
-    "This section shows some example of how to use the API to run both simple and more advanced queries on the ODM2 database, as well as how to examine the query output in convenient ways thanks to Python tools.\n",
+    "This section shows some examples of how to use the API to run both simple and more advanced queries on the ODM2 database, as well as how to examine the query output in convenient ways thanks to Python tools.\n",
     "\n",
     "Simple query functions like **getVariables( )** return objects similar to the entities in ODM2, and individual attributes can then be retrieved from the objects returned. "
    ]
@@ -364,7 +362,8 @@
     "# into a Pandas DataFrame to make it easy to view and manipulate\n",
     "allVars = read.getVariables()\n",
     "\n",
-    "variables_df = pd.DataFrame.from_records([vars(variable) for variable in allVars], index='VariableID')\n",
+    "variables_df = pd.DataFrame.from_records([vars(variable) for variable in allVars], \n",
+    "                                         index='VariableID')\n",
     "variables_df.head(10)"
    ]
   },
@@ -507,7 +506,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Since we know this is a *geospatial* dataset (Sites, which have latitude and longitude), we can use more specialized (spatialized?) Python tools like `GeoPandas` (geospatially enabled Pandas) and `Folium` interactive maps."
+    "Since we know this is a *geospatial* dataset (Sites, which have latitude and longitude), we can use more specialized Python tools like `GeoPandas` (geospatially enabled Pandas) and `Folium` interactive maps."
    ]
   },
   {
@@ -889,10 +888,10 @@
     {
      "data": {
       "text/html": [
-       "<div style=\"width:100%;\"><div style=\"position:relative;width:100%;height:0;padding-bottom:60%;\"><iframe src=\"data:text/html;charset=utf-8;base64,<!DOCTYPE html>
<head>    
    <meta http-equiv="content-type" content="text/html; charset=UTF-8" />
    <script>L_PREFER_CANVAS=false; L_NO_TOUCH=false; L_DISABLE_3D=false;</script>
    <script src="https://cdn.jsdelivr.net/npm/leaflet@1.2.0/dist/leaflet.js"></script>
    <script src="https://ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min.js"></script>
    <script src="https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/js/bootstrap.min.js"></script>
    <script src="https://cdnjs.cloudflare.com/ajax/libs/Leaflet.awesome-markers/2.0.2/leaflet.awesome-markers.js"></script>
    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/leaflet@1.2.0/dist/leaflet.css"/>
    <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/css/bootstrap.min.css"/>
    <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/css/bootstrap-theme.min.css"/>
    <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/font-awesome/4.6.3/css/font-awesome.min.css"/>
    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/Leaflet.awesome-markers/2.0.2/leaflet.awesome-markers.css"/>
    <link rel="stylesheet" href="https://rawgit.com/python-visualization/folium/master/folium/templates/leaflet.awesome.rotate.css"/>
    <style>html, body {width: 100%;height: 100%;margin: 0;padding: 0;}</style>
    <style>#map {position:absolute;top:0;bottom:0;right:0;left:0;}</style>
    
    <style>#map_b35ffcc7078f42a08f5a681896960d23 {
        position: relative;
        width: 100.0%;
        height: 100.0%;
        left: 0.0%;
        top: 0.0%;
        }
    </style>
    <script src="https://cdnjs.cloudflare.com/ajax/libs/leaflet.markercluster/1.1.0/leaflet.markercluster.js"></script>
    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/leaflet.markercluster/1.1.0/MarkerCluster.css"/>
    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/leaflet.markercluster/1.1.0/MarkerCluster.Default.css"/>
</head>
<body>    
    
    <div class="folium-map" id="map_b35ffcc7078f42a08f5a681896960d23" ></div>
</body>
<script>    
    
    
        var bounds = null;
    

    var map_b35ffcc7078f42a08f5a681896960d23 = L.map(
        'map_b35ffcc7078f42a08f5a681896960d23', {
        center: [40.7628298932, -111.834746072],
        zoom: 11,
        maxBounds: bounds,
        layers: [],
        worldCopyJump: false,
        crs: L.CRS.EPSG3857,
        zoomControl: true,
        });

    
    
    var tile_layer_c655ed8292264f7ab537f65ddc2a2d6e = L.tileLayer(
        'https://cartodb-basemaps-{s}.global.ssl.fastly.net/light_all/{z}/{x}/{y}.png',
        {
        "attribution": null, 
        "detectRetina": false, 
        "maxNativeZoom": 18, 
        "maxZoom": 18, 
        "minZoom": 0, 
        "noWrap": false, 
        "subdomains": "abc"
}).addTo(map_b35ffcc7078f42a08f5a681896960d23);
    
            var marker_cluster_560afe8fd2cb4a17b4f42befa9884869 = L.markerClusterGroup({});
            map_b35ffcc7078f42a08f5a681896960d23.addLayer(marker_cluster_560afe8fd2cb4a17b4f42befa9884869);
            
    
        var marker_9bf72ec5b3d148b2b0e83d13e7c57052 = L.marker(
            [40.745078, -111.854449],
            {
                icon: new L.Icon.Default()
                }
            ).addTo(marker_cluster_560afe8fd2cb4a17b4f42befa9884869);
        
    

                var icon_2cc015f8806a4c1385a5b964fa29b5a3 = L.AwesomeMarkers.icon({
                    icon: 'info-sign',
                    iconColor: 'white',
                    markerColor: 'green',
                    prefix: 'glyphicon',
                    extraClasses: 'fa-rotate-0'
                    });
                marker_9bf72ec5b3d148b2b0e83d13e7c57052.setIcon(icon_2cc015f8806a4c1385a5b964fa29b5a3);
            
    
            var popup_1fc539d9d4264c909c996405741d40d4 = L.popup({maxWidth: '300'
            
            });

            
                var html_fadd9be482e24a2f858a27b64d394d50 = $('<div id="html_fadd9be482e24a2f858a27b64d394d50" style="width: 100.0%; height: 100.0%;">RB_1300E (Stream): Red Butte Creek at 1300E (downstream of spring)</div>')[0];
                popup_1fc539d9d4264c909c996405741d40d4.setContent(html_fadd9be482e24a2f858a27b64d394d50);
            

            marker_9bf72ec5b3d148b2b0e83d13e7c57052.bindPopup(popup_1fc539d9d4264c909c996405741d40d4)
            ;

            
        
    
        var marker_e9db7da034ef4353b3b5daf409ace83e = L.marker(
            [40.745106, -111.854389],
            {
                icon: new L.Icon.Default()
                }
            ).addTo(marker_cluster_560afe8fd2cb4a17b4f42befa9884869);
        
    

                var icon_2f614c2d0b5249269c37cd943c096e34 = L.AwesomeMarkers.icon({
                    icon: 'info-sign',
                    iconColor: 'white',
                    markerColor: 'red',
                    prefix: 'glyphicon',
                    extraClasses: 'fa-rotate-0'
                    });
                marker_e9db7da034ef4353b3b5daf409ace83e.setIcon(icon_2f614c2d0b5249269c37cd943c096e34);
            
    
            var popup_df04fc317081489c80d9f7d6b5e2b9f9 = L.popup({maxWidth: '300'
            
            });

            
                var html_d7c5f981206e4681940efaa4b8f0aabd = $('<div id="html_d7c5f981206e4681940efaa4b8f0aabd" style="width: 100.0%; height: 100.0%;">RB_1300ESpring (Spring): Spring that enters Red Butte Creek at 1300E</div>')[0];
                popup_df04fc317081489c80d9f7d6b5e2b9f9.setContent(html_d7c5f981206e4681940efaa4b8f0aabd);
            

            marker_e9db7da034ef4353b3b5daf409ace83e.bindPopup(popup_df04fc317081489c80d9f7d6b5e2b9f9)
            ;

            
        
    
        var marker_3d8c0b6cd7fa4c84a0ab5c2b641d7c86 = L.marker(
            [40.741583, -111.917667],
            {
                icon: new L.Icon.Default()
                }
            ).addTo(marker_cluster_560afe8fd2cb4a17b4f42befa9884869);
        
    

                var icon_f7792e9d13ab47a89ecf8a43633e43fe = L.AwesomeMarkers.icon({
                    icon: 'info-sign',
                    iconColor: 'white',
                    markerColor: 'green',
                    prefix: 'glyphicon',
                    extraClasses: 'fa-rotate-0'
                    });
                marker_3d8c0b6cd7fa4c84a0ab5c2b641d7c86.setIcon(icon_f7792e9d13ab47a89ecf8a43633e43fe);
            
    
            var popup_48aa2e2bcbaf414bb036251dbc04abee = L.popup({maxWidth: '300'
            
            });

            
                var html_b7bcb8975aa4412b8ffa27a39cf2a9b2 = $('<div id="html_b7bcb8975aa4412b8ffa27a39cf2a9b2" style="width: 100.0%; height: 100.0%;">RB_900W_BA (Stream): Red Butte Creek terminus at Jordan River at 1300 South (pipe entering river)</div>')[0];
                popup_48aa2e2bcbaf414bb036251dbc04abee.setContent(html_b7bcb8975aa4412b8ffa27a39cf2a9b2);
            

            marker_3d8c0b6cd7fa4c84a0ab5c2b641d7c86.bindPopup(popup_48aa2e2bcbaf414bb036251dbc04abee)
            ;

            
        
    
        var marker_d638dbbb88df48f1ad7a313e94db9eea = L.marker(
            [40.766134, -111.82653],
            {
                icon: new L.Icon.Default()
                }
            ).addTo(marker_cluster_560afe8fd2cb4a17b4f42befa9884869);
        
    

                var icon_f599e0ecb9484eadac8cf030c7bc317b = L.AwesomeMarkers.icon({
                    icon: 'info-sign',
                    iconColor: 'white',
                    markerColor: 'green',
                    prefix: 'glyphicon',
                    extraClasses: 'fa-rotate-0'
                    });
                marker_d638dbbb88df48f1ad7a313e94db9eea.setIcon(icon_f599e0ecb9484eadac8cf030c7bc317b);
            
    
            var popup_8b89ddbfdaa34db7a73e224b9850f77c = L.popup({maxWidth: '300'
            
            });

            
                var html_31c1fdac81ba492faa805125d1be9b07 = $('<div id="html_31c1fdac81ba492faa805125d1be9b07" style="width: 100.0%; height: 100.0%;">RB_Amphitheater (Stream): Red Butte Creek below Red Butte Garden Amphitheater</div>')[0];
                popup_8b89ddbfdaa34db7a73e224b9850f77c.setContent(html_31c1fdac81ba492faa805125d1be9b07);
            

            marker_d638dbbb88df48f1ad7a313e94db9eea.bindPopup(popup_8b89ddbfdaa34db7a73e224b9850f77c)
            ;

            
        
    
        var marker_9a07fa4f12ed47e0abe82a227404549a = L.marker(
            [40.779602, -111.806669],
            {
                icon: new L.Icon.Default()
                }
            ).addTo(marker_cluster_560afe8fd2cb4a17b4f42befa9884869);
        
    

                var icon_fde960873eec48c095d877115764fc85 = L.AwesomeMarkers.icon({
                    icon: 'info-sign',
                    iconColor: 'white',
                    markerColor: 'green',
                    prefix: 'glyphicon',
                    extraClasses: 'fa-rotate-0'
                    });
                marker_9a07fa4f12ed47e0abe82a227404549a.setIcon(icon_fde960873eec48c095d877115764fc85);
            
    
            var popup_4f6d9c71ad6249bb98b90dd97515be01 = L.popup({maxWidth: '300'
            
            });

            
                var html_12a4eb65c6c745068aeee2ea9c179109 = $('<div id="html_12a4eb65c6c745068aeee2ea9c179109" style="width: 100.0%; height: 100.0%;">RB_ARBR_AA (Stream): Red Butte Creek above Red Butte Reservoir Adanced Aquatic</div>')[0];
                popup_4f6d9c71ad6249bb98b90dd97515be01.setContent(html_12a4eb65c6c745068aeee2ea9c179109);
            

            marker_9a07fa4f12ed47e0abe82a227404549a.bindPopup(popup_4f6d9c71ad6249bb98b90dd97515be01)
            ;

            
        
    
        var marker_ad76bfbe876b42cd8e327ea827a27a66 = L.marker(
            [40.763958, -111.828286],
            {
                icon: new L.Icon.Default()
                }
            ).addTo(marker_cluster_560afe8fd2cb4a17b4f42befa9884869);
        
    

                var icon_b100f276a6c24adab595ac034265f57d = L.AwesomeMarkers.icon({
                    icon: 'info-sign',
                    iconColor: 'white',
                    markerColor: 'green',
                    prefix: 'glyphicon',
                    extraClasses: 'fa-rotate-0'
                    });
                marker_ad76bfbe876b42cd8e327ea827a27a66.setIcon(icon_b100f276a6c24adab595ac034265f57d);
            
    
            var popup_96ef7e3d650240ca801fdc02e17b2a4f = L.popup({maxWidth: '300'
            
            });

            
                var html_432e3e2adae6435b95fb8aa0a8e24a92 = $('<div id="html_432e3e2adae6435b95fb8aa0a8e24a92" style="width: 100.0%; height: 100.0%;">RB_CG_BA (Stream): Red Butte Creek at Cottams Grove Basic Aquatic</div>')[0];
                popup_96ef7e3d650240ca801fdc02e17b2a4f.setContent(html_432e3e2adae6435b95fb8aa0a8e24a92);
            

            marker_ad76bfbe876b42cd8e327ea827a27a66.bindPopup(popup_96ef7e3d650240ca801fdc02e17b2a4f)
            ;

            
        
    
        var marker_0ec6c78844ae4a07ac0d6ca2ba2913ee = L.marker(
            [40.757225, -111.833722],
            {
                icon: new L.Icon.Default()
                }
            ).addTo(marker_cluster_560afe8fd2cb4a17b4f42befa9884869);
        
    

                var icon_6d0d112dea6d48d1aabb79b538c5fc68 = L.AwesomeMarkers.icon({
                    icon: 'info-sign',
                    iconColor: 'white',
                    markerColor: 'green',
                    prefix: 'glyphicon',
                    extraClasses: 'fa-rotate-0'
                    });
                marker_0ec6c78844ae4a07ac0d6ca2ba2913ee.setIcon(icon_6d0d112dea6d48d1aabb79b538c5fc68);
            
    
            var popup_af4a1edccf72483399530607d5e60219 = L.popup({maxWidth: '300'
            
            });

            
                var html_4260c738208642a985c04264a146467e = $('<div id="html_4260c738208642a985c04264a146467e" style="width: 100.0%; height: 100.0%;">RB_FD_AA (Stream): Red Butte Creek at Foothill Drive Advanced Aquatic</div>')[0];
                popup_af4a1edccf72483399530607d5e60219.setContent(html_4260c738208642a985c04264a146467e);
            

            marker_0ec6c78844ae4a07ac0d6ca2ba2913ee.bindPopup(popup_af4a1edccf72483399530607d5e60219)
            ;

            
        
    
        var marker_9c8c1d2d233144d1b85ed3ab88c8a17a = L.marker(
            [40.760139, -111.830222],
            {
                icon: new L.Icon.Default()
                }
            ).addTo(marker_cluster_560afe8fd2cb4a17b4f42befa9884869);
        
    

                var icon_203a53fe45fb4ceaa95ce42a52fa2bcc = L.AwesomeMarkers.icon({
                    icon: 'info-sign',
                    iconColor: 'white',
                    markerColor: 'green',
                    prefix: 'glyphicon',
                    extraClasses: 'fa-rotate-0'
                    });
                marker_9c8c1d2d233144d1b85ed3ab88c8a17a.setIcon(icon_203a53fe45fb4ceaa95ce42a52fa2bcc);
            
    
            var popup_0d1c569d442e4e3a9c0387717e709502 = L.popup({maxWidth: '300'
            
            });

            
                var html_53059000661946ebbb348f2c1fad5e91 = $('<div id="html_53059000661946ebbb348f2c1fad5e91" style="width: 100.0%; height: 100.0%;">RB_GIRF (Stream): Red Butte Creek below Green Infrastructure Research Facility</div>')[0];
                popup_0d1c569d442e4e3a9c0387717e709502.setContent(html_53059000661946ebbb348f2c1fad5e91);
            

            marker_9c8c1d2d233144d1b85ed3ab88c8a17a.bindPopup(popup_0d1c569d442e4e3a9c0387717e709502)
            ;

            
        
    
        var marker_7ee371a48f484882ac3ea4f447c7ee25 = L.marker(
            [40.74125, -111.918028],
            {
                icon: new L.Icon.Default()
                }
            ).addTo(marker_cluster_560afe8fd2cb4a17b4f42befa9884869);
        
    

                var icon_956677be042b42d098197180d9bea893 = L.AwesomeMarkers.icon({
                    icon: 'info-sign',
                    iconColor: 'white',
                    markerColor: 'green',
                    prefix: 'glyphicon',
                    extraClasses: 'fa-rotate-0'
                    });
                marker_7ee371a48f484882ac3ea4f447c7ee25.setIcon(icon_956677be042b42d098197180d9bea893);
            
    
            var popup_8c8b209246f94ec9a5c87abbcaa892e9 = L.popup({maxWidth: '300'
            
            });

            
                var html_22bae483084c4b1b8428ec69c712afb2 = $('<div id="html_22bae483084c4b1b8428ec69c712afb2" style="width: 100.0%; height: 100.0%;">RB_Jordan (Stream): Jordan River at 1300 South 900 West</div>')[0];
                popup_8c8b209246f94ec9a5c87abbcaa892e9.setContent(html_22bae483084c4b1b8428ec69c712afb2);
            

            marker_7ee371a48f484882ac3ea4f447c7ee25.bindPopup(popup_8c8b209246f94ec9a5c87abbcaa892e9)
            ;

            
        
    
        var marker_fd40f934acad435da2a0e340b05ef0be = L.marker(
            [40.809522, -111.765472],
            {
                icon: new L.Icon.Default()
                }
            ).addTo(marker_cluster_560afe8fd2cb4a17b4f42befa9884869);
        
    

                var icon_6f7ac6a21c5c4d46aa14eb53a25274a1 = L.AwesomeMarkers.icon({
                    icon: 'info-sign',
                    iconColor: 'white',
                    markerColor: 'green',
                    prefix: 'glyphicon',
                    extraClasses: 'fa-rotate-0'
                    });
                marker_fd40f934acad435da2a0e340b05ef0be.setIcon(icon_6f7ac6a21c5c4d46aa14eb53a25274a1);
            
    
            var popup_d34905818e1345aab781511b5de4db49 = L.popup({maxWidth: '300'
            
            });

            
                var html_173c842457f34925b29c08285140456c = $('<div id="html_173c842457f34925b29c08285140456c" style="width: 100.0%; height: 100.0%;">RB_KF_BA (Stream): Knowlton Fork at Knowlton Fork Basic Aquatic</div>')[0];
                popup_d34905818e1345aab781511b5de4db49.setContent(html_173c842457f34925b29c08285140456c);
            

            marker_fd40f934acad435da2a0e340b05ef0be.bindPopup(popup_d34905818e1345aab781511b5de4db49)
            ;

            
        
    
        var marker_15d5c69fe20d4728ba0f88563022ec91 = L.marker(
            [40.802361, -111.766944],
            {
                icon: new L.Icon.Default()
                }
            ).addTo(marker_cluster_560afe8fd2cb4a17b4f42befa9884869);
        
    

                var icon_f82a679a9f19422fb2d6f7eeb0ae1e72 = L.AwesomeMarkers.icon({
                    icon: 'info-sign',
                    iconColor: 'white',
                    markerColor: 'green',
                    prefix: 'glyphicon',
                    extraClasses: 'fa-rotate-0'
                    });
                marker_15d5c69fe20d4728ba0f88563022ec91.setIcon(icon_f82a679a9f19422fb2d6f7eeb0ae1e72);
            
    
            var popup_20c094523c89476998fdc4f2a61deb30 = L.popup({maxWidth: '300'
            
            });

            
                var html_ce64e3c1c86449dc94797e56f6d2c1ad = $('<div id="html_ce64e3c1c86449dc94797e56f6d2c1ad" style="width: 100.0%; height: 100.0%;">RB_KFJunction (Stream): Red Butte Creek at Knowltons Fork junction</div>')[0];
                popup_20c094523c89476998fdc4f2a61deb30.setContent(html_ce64e3c1c86449dc94797e56f6d2c1ad);
            

            marker_15d5c69fe20d4728ba0f88563022ec91.bindPopup(popup_20c094523c89476998fdc4f2a61deb30)
            ;

            
        
    
        var marker_e5bc0d7abb574e5aa9af27fab10393f1 = L.marker(
            [40.744936, -111.8575],
            {
                icon: new L.Icon.Default()
                }
            ).addTo(marker_cluster_560afe8fd2cb4a17b4f42befa9884869);
        
    

                var icon_785ebed65d0d4ae99d927538c8c9a89a = L.AwesomeMarkers.icon({
                    icon: 'info-sign',
                    iconColor: 'white',
                    markerColor: 'green',
                    prefix: 'glyphicon',
                    extraClasses: 'fa-rotate-0'
                    });
                marker_e5bc0d7abb574e5aa9af27fab10393f1.setIcon(icon_785ebed65d0d4ae99d927538c8c9a89a);
            
    
            var popup_10f7c8db5cb94040ac1defa33320541b = L.popup({maxWidth: '300'
            
            });

            
                var html_6beb4d59a2db4a61a60331317341a060 = $('<div id="html_6beb4d59a2db4a61a60331317341a060" style="width: 100.0%; height: 100.0%;">RB_LDSWard (Stream): Red Butte Creek at LDS ward house at 1150 E Yale Ave</div>')[0];
                popup_10f7c8db5cb94040ac1defa33320541b.setContent(html_6beb4d59a2db4a61a60331317341a060);
            

            marker_e5bc0d7abb574e5aa9af27fab10393f1.bindPopup(popup_10f7c8db5cb94040ac1defa33320541b)
            ;

            
        
    
        var marker_86ced5e98b91465cb2963485ee9a680f = L.marker(
            [40.743794, -111.873406],
            {
                icon: new L.Icon.Default()
                }
            ).addTo(marker_cluster_560afe8fd2cb4a17b4f42befa9884869);
        
    

                var icon_4701f5813bd74fe5aaff89255228d718 = L.AwesomeMarkers.icon({
                    icon: 'info-sign',
                    iconColor: 'white',
                    markerColor: 'green',
                    prefix: 'glyphicon',
                    extraClasses: 'fa-rotate-0'
                    });
                marker_86ced5e98b91465cb2963485ee9a680f.setIcon(icon_4701f5813bd74fe5aaff89255228d718);
            
    
            var popup_ce789ec849934746a17ec5982bc477b0 = L.popup({maxWidth: '300'
            
            });

            
                var html_41765c39c38d497d911983fc26f05622 = $('<div id="html_41765c39c38d497d911983fc26f05622" style="width: 100.0%; height: 100.0%;">RB_LibLakeDock (Stream): Liberty Lake at Liberty Lake Dock</div>')[0];
                popup_ce789ec849934746a17ec5982bc477b0.setContent(html_41765c39c38d497d911983fc26f05622);
            

            marker_86ced5e98b91465cb2963485ee9a680f.bindPopup(popup_ce789ec849934746a17ec5982bc477b0)
            ;

            
        
    
        var marker_59be1a54e2c548aba883a6b794a9cc04 = L.marker(
            [40.742346, -111.8721],
            {
                icon: new L.Icon.Default()
                }
            ).addTo(marker_cluster_560afe8fd2cb4a17b4f42befa9884869);
        
    

                var icon_e381bfae4bcc4ec98513b672bcf22046 = L.AwesomeMarkers.icon({
                    icon: 'info-sign',
                    iconColor: 'white',
                    markerColor: 'green',
                    prefix: 'glyphicon',
                    extraClasses: 'fa-rotate-0'
                    });
                marker_59be1a54e2c548aba883a6b794a9cc04.setIcon(icon_e381bfae4bcc4ec98513b672bcf22046);
            
    
            var popup_251395bd30ba4264a61202eb454301d0 = L.popup({maxWidth: '300'
            
            });

            
                var html_fbee9036f0844e4090448c550dda94a8 = $('<div id="html_fbee9036f0844e4090448c550dda94a8" style="width: 100.0%; height: 100.0%;">RB_LibLakeEmigration (Stream): Emigration Creek terminus at Liberty Lake (pipe entering lake)</div>')[0];
                popup_251395bd30ba4264a61202eb454301d0.setContent(html_fbee9036f0844e4090448c550dda94a8);
            

            marker_59be1a54e2c548aba883a6b794a9cc04.bindPopup(popup_251395bd30ba4264a61202eb454301d0)
            ;

            
        
    
        var marker_68d77652e09a46438942565112c3cf93 = L.marker(
            [40.743881, -111.872147],
            {
                icon: new L.Icon.Default()
                }
            ).addTo(marker_cluster_560afe8fd2cb4a17b4f42befa9884869);
        
    

                var icon_d5b3a8d249a84a92a7c0b808a37d9681 = L.AwesomeMarkers.icon({
                    icon: 'info-sign',
                    iconColor: 'white',
                    markerColor: 'green',
                    prefix: 'glyphicon',
                    extraClasses: 'fa-rotate-0'
                    });
                marker_68d77652e09a46438942565112c3cf93.setIcon(icon_d5b3a8d249a84a92a7c0b808a37d9681);
            
    
            var popup_2bee7b2f28174d04b055d15a88bf5bd9 = L.popup({maxWidth: '300'
            
            });

            
                var html_0974e497ff354c678cfd9a3e7a4ef06e = $('<div id="html_0974e497ff354c678cfd9a3e7a4ef06e" style="width: 100.0%; height: 100.0%;">RB_LibLakeRedButte (Stream): Red Butte Creek terminus at Liberty Lake (pipe entering lake)</div>')[0];
                popup_2bee7b2f28174d04b055d15a88bf5bd9.setContent(html_0974e497ff354c678cfd9a3e7a4ef06e);
            

            marker_68d77652e09a46438942565112c3cf93.bindPopup(popup_2bee7b2f28174d04b055d15a88bf5bd9)
            ;

            
        
    
        var marker_bb81300dadde491ea41ee48595db244b = L.marker(
            [40.749658, -111.841814],
            {
                icon: new L.Icon.Default()
                }
            ).addTo(marker_cluster_560afe8fd2cb4a17b4f42befa9884869);
        
    

                var icon_7774283e0d4f47cd8d1e8c5075a9b907 = L.AwesomeMarkers.icon({
                    icon: 'info-sign',
                    iconColor: 'white',
                    markerColor: 'green',
                    prefix: 'glyphicon',
                    extraClasses: 'fa-rotate-0'
                    });
                marker_bb81300dadde491ea41ee48595db244b.setIcon(icon_7774283e0d4f47cd8d1e8c5075a9b907);
            
    
            var popup_90fee05ce1f1403291dbe010f4dcab38 = L.popup({maxWidth: '300'
            
            });

            
                var html_2ddeec4c34904187a6b59a5e3e880480 = $('<div id="html_2ddeec4c34904187a6b59a5e3e880480" style="width: 100.0%; height: 100.0%;">RB_MillerEntrance (Stream): Red Butte Creek at Miller Park Enterance at 900 South</div>')[0];
                popup_90fee05ce1f1403291dbe010f4dcab38.setContent(html_2ddeec4c34904187a6b59a5e3e880480);
            

            marker_bb81300dadde491ea41ee48595db244b.bindPopup(popup_90fee05ce1f1403291dbe010f4dcab38)
            ;

            
        
    
        var marker_629bb7006ff543258eb1585a33f48aca = L.marker(
            [40.787611, -111.796389],
            {
                icon: new L.Icon.Default()
                }
            ).addTo(marker_cluster_560afe8fd2cb4a17b4f42befa9884869);
        
    

                var icon_c958a0a5238543fa90d0682cdc0a5a26 = L.AwesomeMarkers.icon({
                    icon: 'info-sign',
                    iconColor: 'white',
                    markerColor: 'green',
                    prefix: 'glyphicon',
                    extraClasses: 'fa-rotate-0'
                    });
                marker_629bb7006ff543258eb1585a33f48aca.setIcon(icon_c958a0a5238543fa90d0682cdc0a5a26);
            
    
            var popup_b2131a6a67784ee0b9932fb12ab7adf2 = L.popup({maxWidth: '300'
            
            });

            
                var html_41208edc779f420790adf39e0715cf9b = $('<div id="html_41208edc779f420790adf39e0715cf9b" style="width: 100.0%; height: 100.0%;">RB_PFJunction (Stream): Parleys Fork at Parleys Fork junction</div>')[0];
                popup_b2131a6a67784ee0b9932fb12ab7adf2.setContent(html_41208edc779f420790adf39e0715cf9b);
            

            marker_629bb7006ff543258eb1585a33f48aca.bindPopup(popup_b2131a6a67784ee0b9932fb12ab7adf2)
            ;

            
        
    
        var marker_adab774c5ca24473a70f83e88f9fba77 = L.marker(
            [40.80289722, -111.7643389],
            {
                icon: new L.Icon.Default()
                }
            ).addTo(marker_cluster_560afe8fd2cb4a17b4f42befa9884869);
        
    

                var icon_54ae553e6e3e400587a87eca5dbf9ede = L.AwesomeMarkers.icon({
                    icon: 'info-sign',
                    iconColor: 'white',
                    markerColor: 'green',
                    prefix: 'glyphicon',
                    extraClasses: 'fa-rotate-0'
                    });
                marker_adab774c5ca24473a70f83e88f9fba77.setIcon(icon_54ae553e6e3e400587a87eca5dbf9ede);
            
    
            var popup_eabff96db84745ae91542c4bd48bf8bc = L.popup({maxWidth: '300'
            
            });

            
                var html_fcbc041555f4464b90c097ed060d1a32 = $('<div id="html_fcbc041555f4464b90c097ed060d1a32" style="width: 100.0%; height: 100.0%;">RB_RBFork (Stream): Red Butte Creek at Red Butte Fork</div>')[0];
                popup_eabff96db84745ae91542c4bd48bf8bc.setContent(html_fcbc041555f4464b90c097ed060d1a32);
            

            marker_adab774c5ca24473a70f83e88f9fba77.bindPopup(popup_eabff96db84745ae91542c4bd48bf8bc)
            ;

            
        
    
        var marker_b9f861107c7b4e41a99c5dd4659f6cf8 = L.marker(
            [40.774228, -111.817025],
            {
                icon: new L.Icon.Default()
                }
            ).addTo(marker_cluster_560afe8fd2cb4a17b4f42befa9884869);
        
    

                var icon_ee65370ce04a4856b607514dd1bf6646 = L.AwesomeMarkers.icon({
                    icon: 'info-sign',
                    iconColor: 'white',
                    markerColor: 'green',
                    prefix: 'glyphicon',
                    extraClasses: 'fa-rotate-0'
                    });
                marker_b9f861107c7b4e41a99c5dd4659f6cf8.setIcon(icon_ee65370ce04a4856b607514dd1bf6646);
            
    
            var popup_bbbdf4f7771d4404b311273d4aa7d67e = L.popup({maxWidth: '300'
            
            });

            
                var html_9e33e7d4f5884e2ca12d34bc7b18a10a = $('<div id="html_9e33e7d4f5884e2ca12d34bc7b18a10a" style="width: 100.0%; height: 100.0%;">RB_RBG_BA (Stream): Red Butte Creek at Red Butte Gate Basic Aquatic</div>')[0];
                popup_bbbdf4f7771d4404b311273d4aa7d67e.setContent(html_9e33e7d4f5884e2ca12d34bc7b18a10a);
            

            marker_b9f861107c7b4e41a99c5dd4659f6cf8.bindPopup(popup_bbbdf4f7771d4404b311273d4aa7d67e)
            ;

            
        
    
        var marker_2789dd5b7488422a9437db75ff575ab4 = L.marker(
            [40.779379, -111.808632],
            {
                icon: new L.Icon.Default()
                }
            ).addTo(marker_cluster_560afe8fd2cb4a17b4f42befa9884869);
        
    

                var icon_eafd482bf3454411b6672e4d1420b7e9 = L.AwesomeMarkers.icon({
                    icon: 'info-sign',
                    iconColor: 'white',
                    markerColor: 'green',
                    prefix: 'glyphicon',
                    extraClasses: 'fa-rotate-0'
                    });
                marker_2789dd5b7488422a9437db75ff575ab4.setIcon(icon_eafd482bf3454411b6672e4d1420b7e9);
            
    
            var popup_673e3f9bb1344e2190811cbd8376f777 = L.popup({maxWidth: '300'
            
            });

            
                var html_82c74b557f2846cfb93c17021451650a = $('<div id="html_82c74b557f2846cfb93c17021451650a" style="width: 100.0%; height: 100.0%;">RB_RBReservoir (Stream): Red Butte Reservoir at boat ramp</div>')[0];
                popup_673e3f9bb1344e2190811cbd8376f777.setContent(html_82c74b557f2846cfb93c17021451650a);
            

            marker_2789dd5b7488422a9437db75ff575ab4.bindPopup(popup_673e3f9bb1344e2190811cbd8376f777)
            ;

            
        
    
        var marker_8aa51e1889e7446a96748db63a0ad88c = L.marker(
            [40.74711111, -111.8447389],
            {
                icon: new L.Icon.Default()
                }
            ).addTo(marker_cluster_560afe8fd2cb4a17b4f42befa9884869);
        
    

                var icon_1f62f1bd1bc64b5dbb77df4428091d25 = L.AwesomeMarkers.icon({
                    icon: 'info-sign',
                    iconColor: 'white',
                    markerColor: 'green',
                    prefix: 'glyphicon',
                    extraClasses: 'fa-rotate-0'
                    });
                marker_8aa51e1889e7446a96748db63a0ad88c.setIcon(icon_1f62f1bd1bc64b5dbb77df4428091d25);
            
    
            var popup_6c97dcdf005a440ea221d352aa53e4a2 = L.popup({maxWidth: '300'
            
            });

            
                var html_d8591ff568f2406693c4c925dbc67e6b = $('<div id="html_d8591ff568f2406693c4c925dbc67e6b" style="width: 100.0%; height: 100.0%;">RB_SLCO (Stream): Red Butte Creek at 1600 East SLCO Bonneview aquatic monitoring station</div>')[0];
                popup_6c97dcdf005a440ea221d352aa53e4a2.setContent(html_d8591ff568f2406693c4c925dbc67e6b);
            

            marker_8aa51e1889e7446a96748db63a0ad88c.bindPopup(popup_6c97dcdf005a440ea221d352aa53e4a2)
            ;

            
        
    
        var marker_c3f2a77cca964593aa53304a644a2051 = L.marker(
            [40.751677, -111.839529],
            {
                icon: new L.Icon.Default()
                }
            ).addTo(marker_cluster_560afe8fd2cb4a17b4f42befa9884869);
        
    

                var icon_265bcd28d6914b30b1d09840cb6a94ed = L.AwesomeMarkers.icon({
                    icon: 'info-sign',
                    iconColor: 'white',
                    markerColor: 'green',
                    prefix: 'glyphicon',
                    extraClasses: 'fa-rotate-0'
                    });
                marker_c3f2a77cca964593aa53304a644a2051.setIcon(icon_265bcd28d6914b30b1d09840cb6a94ed);
            
    
            var popup_80d71e42fe6d44f492c46df9d639e0d2 = L.popup({maxWidth: '300'
            
            });

            
                var html_a96b6f0afd7a47f4983c6bcef6ed4c72 = $('<div id="html_a96b6f0afd7a47f4983c6bcef6ed4c72" style="width: 100.0%; height: 100.0%;">RB_SunnysidePark (Stream): Red Butte Creek at Sunnyside Park</div>')[0];
                popup_80d71e42fe6d44f492c46df9d639e0d2.setContent(html_a96b6f0afd7a47f4983c6bcef6ed4c72);
            

            marker_c3f2a77cca964593aa53304a644a2051.bindPopup(popup_80d71e42fe6d44f492c46df9d639e0d2)
            ;

            
        
    
        var marker_0e3b8ddc8e364d789e3362bf5dae92fe = L.marker(
            [40.789056, -111.796667],
            {
                icon: new L.Icon.Default()
                }
            ).addTo(marker_cluster_560afe8fd2cb4a17b4f42befa9884869);
        
    

                var icon_1307b6f9245a45818935fc0f0c54620d = L.AwesomeMarkers.icon({
                    icon: 'info-sign',
                    iconColor: 'white',
                    markerColor: 'green',
                    prefix: 'glyphicon',
                    extraClasses: 'fa-rotate-0'
                    });
                marker_0e3b8ddc8e364d789e3362bf5dae92fe.setIcon(icon_1307b6f9245a45818935fc0f0c54620d);
            
    
            var popup_90ba5d170d9f4f3eafa600a659e2a707 = L.popup({maxWidth: '300'
            
            });

            
                var html_cceeec0d330c478e9cc2bd8252473e6d = $('<div id="html_cceeec0d330c478e9cc2bd8252473e6d" style="width: 100.0%; height: 100.0%;">RB_ToddMeadow (Stream): Parleys Fork at Todds Meadow</div>')[0];
                popup_90ba5d170d9f4f3eafa600a659e2a707.setContent(html_cceeec0d330c478e9cc2bd8252473e6d);
            

            marker_0e3b8ddc8e364d789e3362bf5dae92fe.bindPopup(popup_90ba5d170d9f4f3eafa600a659e2a707)
            ;

            
        
    
        var marker_a06aa4eb3b4d481fbb60b80cde9ac95c = L.marker(
            [40.756048, -111.835348],
            {
                icon: new L.Icon.Default()
                }
            ).addTo(marker_cluster_560afe8fd2cb4a17b4f42befa9884869);
        
    

                var icon_96571ba68d3744d2a109aca9051cfed2 = L.AwesomeMarkers.icon({
                    icon: 'info-sign',
                    iconColor: 'white',
                    markerColor: 'green',
                    prefix: 'glyphicon',
                    extraClasses: 'fa-rotate-0'
                    });
                marker_a06aa4eb3b4d481fbb60b80cde9ac95c.setIcon(icon_96571ba68d3744d2a109aca9051cfed2);
            
    
            var popup_7eeaaa61f27544f296cdbb271c0c482a = L.popup({maxWidth: '300'
            
            });

            
                var html_dacba4962d584c54b1739f13e2a5dfa6 = $('<div id="html_dacba4962d584c54b1739f13e2a5dfa6" style="width: 100.0%; height: 100.0%;">RB_Walkway (Stream): Red Butte Creek at walkway near Veterens Administration buildings</div>')[0];
                popup_7eeaaa61f27544f296cdbb271c0c482a.setContent(html_dacba4962d584c54b1739f13e2a5dfa6);
            

            marker_a06aa4eb3b4d481fbb60b80cde9ac95c.bindPopup(popup_7eeaaa61f27544f296cdbb271c0c482a)
            ;

            
        
    
        var marker_8b715567e829459f982cb8d313c03654 = L.marker(
            [40.746167, -111.846639],
            {
                icon: new L.Icon.Default()
                }
            ).addTo(marker_cluster_560afe8fd2cb4a17b4f42befa9884869);
        
    

                var icon_2c0b7ecc1c0448fe8da197977ead3ffa = L.AwesomeMarkers.icon({
                    icon: 'info-sign',
                    iconColor: 'white',
                    markerColor: 'green',
                    prefix: 'glyphicon',
                    extraClasses: 'fa-rotate-0'
                    });
                marker_8b715567e829459f982cb8d313c03654.setIcon(icon_2c0b7ecc1c0448fe8da197977ead3ffa);
            
    
            var popup_b948cff20791451a83a757cd5f1d8d2a = L.popup({maxWidth: '300'
            
            });

            
                var html_2eb866a5a61443fd8336b05177956d2b = $('<div id="html_2eb866a5a61443fd8336b05177956d2b" style="width: 100.0%; height: 100.0%;">RB_WestMiller (Stream): Red Butte Creek at West Miller Park</div>')[0];
                popup_b948cff20791451a83a757cd5f1d8d2a.setContent(html_2eb866a5a61443fd8336b05177956d2b);
            

            marker_8b715567e829459f982cb8d313c03654.bindPopup(popup_b948cff20791451a83a757cd5f1d8d2a)
            ;

            
        
</script>\" style=\"position:absolute;width:100%;height:100%;left:0;top:0;border:none !important;\" allowfullscreen webkitallowfullscreen mozallowfullscreen></iframe></div></div>"
+       "<div style=\"width:100%;\"><div style=\"position:relative;width:100%;height:0;padding-bottom:60%;\"><iframe src=\"data:text/html;charset=utf-8;base64,<!DOCTYPE html>
<head>    
    <meta http-equiv="content-type" content="text/html; charset=UTF-8" />
    <script>L_PREFER_CANVAS=false; L_NO_TOUCH=false; L_DISABLE_3D=false;</script>
    <script src="https://cdn.jsdelivr.net/npm/leaflet@1.2.0/dist/leaflet.js"></script>
    <script src="https://ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min.js"></script>
    <script src="https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/js/bootstrap.min.js"></script>
    <script src="https://cdnjs.cloudflare.com/ajax/libs/Leaflet.awesome-markers/2.0.2/leaflet.awesome-markers.js"></script>
    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/leaflet@1.2.0/dist/leaflet.css"/>
    <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/css/bootstrap.min.css"/>
    <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/css/bootstrap-theme.min.css"/>
    <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/font-awesome/4.6.3/css/font-awesome.min.css"/>
    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/Leaflet.awesome-markers/2.0.2/leaflet.awesome-markers.css"/>
    <link rel="stylesheet" href="https://rawgit.com/python-visualization/folium/master/folium/templates/leaflet.awesome.rotate.css"/>
    <style>html, body {width: 100%;height: 100%;margin: 0;padding: 0;}</style>
    <style>#map {position:absolute;top:0;bottom:0;right:0;left:0;}</style>
    
    <style>#map_48b3ee26d292422fb5f98991c3c16764 {
        position: relative;
        width: 100.0%;
        height: 100.0%;
        left: 0.0%;
        top: 0.0%;
        }
    </style>
    <script src="https://cdnjs.cloudflare.com/ajax/libs/leaflet.markercluster/1.1.0/leaflet.markercluster.js"></script>
    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/leaflet.markercluster/1.1.0/MarkerCluster.css"/>
    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/leaflet.markercluster/1.1.0/MarkerCluster.Default.css"/>
</head>
<body>    
    
    <div class="folium-map" id="map_48b3ee26d292422fb5f98991c3c16764" ></div>
</body>
<script>    
    
    
        var bounds = null;
    

    var map_48b3ee26d292422fb5f98991c3c16764 = L.map(
        'map_48b3ee26d292422fb5f98991c3c16764', {
        center: [40.7628298932, -111.834746072],
        zoom: 11,
        maxBounds: bounds,
        layers: [],
        worldCopyJump: false,
        crs: L.CRS.EPSG3857,
        zoomControl: true,
        });

    
    
    var tile_layer_f76c4400dbb8430f99c600a3e8943161 = L.tileLayer(
        'https://cartodb-basemaps-{s}.global.ssl.fastly.net/light_all/{z}/{x}/{y}.png',
        {
        "attribution": null, 
        "detectRetina": false, 
        "maxNativeZoom": 18, 
        "maxZoom": 18, 
        "minZoom": 0, 
        "noWrap": false, 
        "subdomains": "abc"
}).addTo(map_48b3ee26d292422fb5f98991c3c16764);
    
            var marker_cluster_ac4f92808f7642e4b4f23d861bcfe06c = L.markerClusterGroup({});
            map_48b3ee26d292422fb5f98991c3c16764.addLayer(marker_cluster_ac4f92808f7642e4b4f23d861bcfe06c);
            
    
        var marker_bd6bcadda36c42f796ad84da54052624 = L.marker(
            [40.745078, -111.854449],
            {
                icon: new L.Icon.Default()
                }
            ).addTo(marker_cluster_ac4f92808f7642e4b4f23d861bcfe06c);
        
    

                var icon_393665e22cf744fa9840b8dfdbaa4d5f = L.AwesomeMarkers.icon({
                    icon: 'info-sign',
                    iconColor: 'white',
                    markerColor: 'green',
                    prefix: 'glyphicon',
                    extraClasses: 'fa-rotate-0'
                    });
                marker_bd6bcadda36c42f796ad84da54052624.setIcon(icon_393665e22cf744fa9840b8dfdbaa4d5f);
            
    
            var popup_f784071c0e3240ac8ad1d5adc1cf766c = L.popup({maxWidth: '300'
            
            });

            
                var html_3bb96d4c0a1e4e0b8f4c0c5f78764148 = $('<div id="html_3bb96d4c0a1e4e0b8f4c0c5f78764148" style="width: 100.0%; height: 100.0%;">RB_1300E (Stream): Red Butte Creek at 1300E (downstream of spring)</div>')[0];
                popup_f784071c0e3240ac8ad1d5adc1cf766c.setContent(html_3bb96d4c0a1e4e0b8f4c0c5f78764148);
            

            marker_bd6bcadda36c42f796ad84da54052624.bindPopup(popup_f784071c0e3240ac8ad1d5adc1cf766c)
            ;

            
        
    
        var marker_05752b20bfda4fdc9e4fbea1a4235821 = L.marker(
            [40.745106, -111.854389],
            {
                icon: new L.Icon.Default()
                }
            ).addTo(marker_cluster_ac4f92808f7642e4b4f23d861bcfe06c);
        
    

                var icon_f135e71e7a684b81b72d551f2f1823e9 = L.AwesomeMarkers.icon({
                    icon: 'info-sign',
                    iconColor: 'white',
                    markerColor: 'red',
                    prefix: 'glyphicon',
                    extraClasses: 'fa-rotate-0'
                    });
                marker_05752b20bfda4fdc9e4fbea1a4235821.setIcon(icon_f135e71e7a684b81b72d551f2f1823e9);
            
    
            var popup_ec0c1fce1e8e429e87fc22a5c6be49ab = L.popup({maxWidth: '300'
            
            });

            
                var html_6a1cf89bd7f94e169cfc343845c5add6 = $('<div id="html_6a1cf89bd7f94e169cfc343845c5add6" style="width: 100.0%; height: 100.0%;">RB_1300ESpring (Spring): Spring that enters Red Butte Creek at 1300E</div>')[0];
                popup_ec0c1fce1e8e429e87fc22a5c6be49ab.setContent(html_6a1cf89bd7f94e169cfc343845c5add6);
            

            marker_05752b20bfda4fdc9e4fbea1a4235821.bindPopup(popup_ec0c1fce1e8e429e87fc22a5c6be49ab)
            ;

            
        
    
        var marker_6bddb1651f984398a61d6b19491a6e8d = L.marker(
            [40.741583, -111.917667],
            {
                icon: new L.Icon.Default()
                }
            ).addTo(marker_cluster_ac4f92808f7642e4b4f23d861bcfe06c);
        
    

                var icon_e14b77fc0641421fb6f5a31e2ae77030 = L.AwesomeMarkers.icon({
                    icon: 'info-sign',
                    iconColor: 'white',
                    markerColor: 'green',
                    prefix: 'glyphicon',
                    extraClasses: 'fa-rotate-0'
                    });
                marker_6bddb1651f984398a61d6b19491a6e8d.setIcon(icon_e14b77fc0641421fb6f5a31e2ae77030);
            
    
            var popup_0244d8908da9416eb2d273565a4a96d1 = L.popup({maxWidth: '300'
            
            });

            
                var html_5c451bcaf23a4b408a5915cdf2909f47 = $('<div id="html_5c451bcaf23a4b408a5915cdf2909f47" style="width: 100.0%; height: 100.0%;">RB_900W_BA (Stream): Red Butte Creek terminus at Jordan River at 1300 South (pipe entering river)</div>')[0];
                popup_0244d8908da9416eb2d273565a4a96d1.setContent(html_5c451bcaf23a4b408a5915cdf2909f47);
            

            marker_6bddb1651f984398a61d6b19491a6e8d.bindPopup(popup_0244d8908da9416eb2d273565a4a96d1)
            ;

            
        
    
        var marker_3fe7b7fed8f84134b44939604300c7f4 = L.marker(
            [40.766134, -111.82653],
            {
                icon: new L.Icon.Default()
                }
            ).addTo(marker_cluster_ac4f92808f7642e4b4f23d861bcfe06c);
        
    

                var icon_5536810cba29400a9d50a31a8a501b60 = L.AwesomeMarkers.icon({
                    icon: 'info-sign',
                    iconColor: 'white',
                    markerColor: 'green',
                    prefix: 'glyphicon',
                    extraClasses: 'fa-rotate-0'
                    });
                marker_3fe7b7fed8f84134b44939604300c7f4.setIcon(icon_5536810cba29400a9d50a31a8a501b60);
            
    
            var popup_dcf0b799e08e4907a6494c3875925f1c = L.popup({maxWidth: '300'
            
            });

            
                var html_0c7f045f09a34123948c752d076e10c1 = $('<div id="html_0c7f045f09a34123948c752d076e10c1" style="width: 100.0%; height: 100.0%;">RB_Amphitheater (Stream): Red Butte Creek below Red Butte Garden Amphitheater</div>')[0];
                popup_dcf0b799e08e4907a6494c3875925f1c.setContent(html_0c7f045f09a34123948c752d076e10c1);
            

            marker_3fe7b7fed8f84134b44939604300c7f4.bindPopup(popup_dcf0b799e08e4907a6494c3875925f1c)
            ;

            
        
    
        var marker_e4147eea7f1143b192854f2acd25041a = L.marker(
            [40.779602, -111.806669],
            {
                icon: new L.Icon.Default()
                }
            ).addTo(marker_cluster_ac4f92808f7642e4b4f23d861bcfe06c);
        
    

                var icon_d8d99f6b8dc74e7f975a4684f13e169b = L.AwesomeMarkers.icon({
                    icon: 'info-sign',
                    iconColor: 'white',
                    markerColor: 'green',
                    prefix: 'glyphicon',
                    extraClasses: 'fa-rotate-0'
                    });
                marker_e4147eea7f1143b192854f2acd25041a.setIcon(icon_d8d99f6b8dc74e7f975a4684f13e169b);
            
    
            var popup_81206bd451ce493295204671d759e9c8 = L.popup({maxWidth: '300'
            
            });

            
                var html_4b2ff652ebc5491cabcee42970dd96f7 = $('<div id="html_4b2ff652ebc5491cabcee42970dd96f7" style="width: 100.0%; height: 100.0%;">RB_ARBR_AA (Stream): Red Butte Creek above Red Butte Reservoir Adanced Aquatic</div>')[0];
                popup_81206bd451ce493295204671d759e9c8.setContent(html_4b2ff652ebc5491cabcee42970dd96f7);
            

            marker_e4147eea7f1143b192854f2acd25041a.bindPopup(popup_81206bd451ce493295204671d759e9c8)
            ;

            
        
    
        var marker_abd0d9de1aa6487d8a587b97218b1f91 = L.marker(
            [40.763958, -111.828286],
            {
                icon: new L.Icon.Default()
                }
            ).addTo(marker_cluster_ac4f92808f7642e4b4f23d861bcfe06c);
        
    

                var icon_c236f124be094bffae5577e081a106ce = L.AwesomeMarkers.icon({
                    icon: 'info-sign',
                    iconColor: 'white',
                    markerColor: 'green',
                    prefix: 'glyphicon',
                    extraClasses: 'fa-rotate-0'
                    });
                marker_abd0d9de1aa6487d8a587b97218b1f91.setIcon(icon_c236f124be094bffae5577e081a106ce);
            
    
            var popup_28ba34c40c4b4e95b878514067d0e3fb = L.popup({maxWidth: '300'
            
            });

            
                var html_1ea88b65608c40e38f9479f45dbc978b = $('<div id="html_1ea88b65608c40e38f9479f45dbc978b" style="width: 100.0%; height: 100.0%;">RB_CG_BA (Stream): Red Butte Creek at Cottams Grove Basic Aquatic</div>')[0];
                popup_28ba34c40c4b4e95b878514067d0e3fb.setContent(html_1ea88b65608c40e38f9479f45dbc978b);
            

            marker_abd0d9de1aa6487d8a587b97218b1f91.bindPopup(popup_28ba34c40c4b4e95b878514067d0e3fb)
            ;

            
        
    
        var marker_ae92269dc39e4c96b5c0d9b76524d7d9 = L.marker(
            [40.757225, -111.833722],
            {
                icon: new L.Icon.Default()
                }
            ).addTo(marker_cluster_ac4f92808f7642e4b4f23d861bcfe06c);
        
    

                var icon_b304e95662b04b849e3077aef56453ce = L.AwesomeMarkers.icon({
                    icon: 'info-sign',
                    iconColor: 'white',
                    markerColor: 'green',
                    prefix: 'glyphicon',
                    extraClasses: 'fa-rotate-0'
                    });
                marker_ae92269dc39e4c96b5c0d9b76524d7d9.setIcon(icon_b304e95662b04b849e3077aef56453ce);
            
    
            var popup_b730980d464140f78b57bf2b95e03dcb = L.popup({maxWidth: '300'
            
            });

            
                var html_c427fcc95ec84f7a823c493d8653a123 = $('<div id="html_c427fcc95ec84f7a823c493d8653a123" style="width: 100.0%; height: 100.0%;">RB_FD_AA (Stream): Red Butte Creek at Foothill Drive Advanced Aquatic</div>')[0];
                popup_b730980d464140f78b57bf2b95e03dcb.setContent(html_c427fcc95ec84f7a823c493d8653a123);
            

            marker_ae92269dc39e4c96b5c0d9b76524d7d9.bindPopup(popup_b730980d464140f78b57bf2b95e03dcb)
            ;

            
        
    
        var marker_4238ba86de7445ba99bba62ea57d0372 = L.marker(
            [40.760139, -111.830222],
            {
                icon: new L.Icon.Default()
                }
            ).addTo(marker_cluster_ac4f92808f7642e4b4f23d861bcfe06c);
        
    

                var icon_2fea075701e74f77836edf8e353b7bb9 = L.AwesomeMarkers.icon({
                    icon: 'info-sign',
                    iconColor: 'white',
                    markerColor: 'green',
                    prefix: 'glyphicon',
                    extraClasses: 'fa-rotate-0'
                    });
                marker_4238ba86de7445ba99bba62ea57d0372.setIcon(icon_2fea075701e74f77836edf8e353b7bb9);
            
    
            var popup_f60dfdd0f1614791b80bd02d21239ce9 = L.popup({maxWidth: '300'
            
            });

            
                var html_7c9022ff21df4c3e8dfbf5c69a473687 = $('<div id="html_7c9022ff21df4c3e8dfbf5c69a473687" style="width: 100.0%; height: 100.0%;">RB_GIRF (Stream): Red Butte Creek below Green Infrastructure Research Facility</div>')[0];
                popup_f60dfdd0f1614791b80bd02d21239ce9.setContent(html_7c9022ff21df4c3e8dfbf5c69a473687);
            

            marker_4238ba86de7445ba99bba62ea57d0372.bindPopup(popup_f60dfdd0f1614791b80bd02d21239ce9)
            ;

            
        
    
        var marker_e595ed9ff27e4eb58559ee2a73528fdd = L.marker(
            [40.74125, -111.918028],
            {
                icon: new L.Icon.Default()
                }
            ).addTo(marker_cluster_ac4f92808f7642e4b4f23d861bcfe06c);
        
    

                var icon_0c0f691c0e2d41e4a321bd4100e29526 = L.AwesomeMarkers.icon({
                    icon: 'info-sign',
                    iconColor: 'white',
                    markerColor: 'green',
                    prefix: 'glyphicon',
                    extraClasses: 'fa-rotate-0'
                    });
                marker_e595ed9ff27e4eb58559ee2a73528fdd.setIcon(icon_0c0f691c0e2d41e4a321bd4100e29526);
            
    
            var popup_993a3715597f4287bcbb9533cd44c328 = L.popup({maxWidth: '300'
            
            });

            
                var html_9b43601932ce4015b1ac412fe985a0b2 = $('<div id="html_9b43601932ce4015b1ac412fe985a0b2" style="width: 100.0%; height: 100.0%;">RB_Jordan (Stream): Jordan River at 1300 South 900 West</div>')[0];
                popup_993a3715597f4287bcbb9533cd44c328.setContent(html_9b43601932ce4015b1ac412fe985a0b2);
            

            marker_e595ed9ff27e4eb58559ee2a73528fdd.bindPopup(popup_993a3715597f4287bcbb9533cd44c328)
            ;

            
        
    
        var marker_2cff1d80f75a40499285615522e9d95c = L.marker(
            [40.809522, -111.765472],
            {
                icon: new L.Icon.Default()
                }
            ).addTo(marker_cluster_ac4f92808f7642e4b4f23d861bcfe06c);
        
    

                var icon_65b1acd930894ce2a4b0c135fc5b4156 = L.AwesomeMarkers.icon({
                    icon: 'info-sign',
                    iconColor: 'white',
                    markerColor: 'green',
                    prefix: 'glyphicon',
                    extraClasses: 'fa-rotate-0'
                    });
                marker_2cff1d80f75a40499285615522e9d95c.setIcon(icon_65b1acd930894ce2a4b0c135fc5b4156);
            
    
            var popup_88e85e887e464640a73c00e16717e0a9 = L.popup({maxWidth: '300'
            
            });

            
                var html_c5823eea5c6d4a4d8ab91ad38f4f22c8 = $('<div id="html_c5823eea5c6d4a4d8ab91ad38f4f22c8" style="width: 100.0%; height: 100.0%;">RB_KF_BA (Stream): Knowlton Fork at Knowlton Fork Basic Aquatic</div>')[0];
                popup_88e85e887e464640a73c00e16717e0a9.setContent(html_c5823eea5c6d4a4d8ab91ad38f4f22c8);
            

            marker_2cff1d80f75a40499285615522e9d95c.bindPopup(popup_88e85e887e464640a73c00e16717e0a9)
            ;

            
        
    
        var marker_2ce36fb320604907a7237d1dab6213d0 = L.marker(
            [40.802361, -111.766944],
            {
                icon: new L.Icon.Default()
                }
            ).addTo(marker_cluster_ac4f92808f7642e4b4f23d861bcfe06c);
        
    

                var icon_b92b1e85de294c9aaaf117c47a0b8230 = L.AwesomeMarkers.icon({
                    icon: 'info-sign',
                    iconColor: 'white',
                    markerColor: 'green',
                    prefix: 'glyphicon',
                    extraClasses: 'fa-rotate-0'
                    });
                marker_2ce36fb320604907a7237d1dab6213d0.setIcon(icon_b92b1e85de294c9aaaf117c47a0b8230);
            
    
            var popup_317ab55c5945455f900da6e7e4070f0a = L.popup({maxWidth: '300'
            
            });

            
                var html_1985c53e53bd4ea0acaf9db911df0088 = $('<div id="html_1985c53e53bd4ea0acaf9db911df0088" style="width: 100.0%; height: 100.0%;">RB_KFJunction (Stream): Red Butte Creek at Knowltons Fork junction</div>')[0];
                popup_317ab55c5945455f900da6e7e4070f0a.setContent(html_1985c53e53bd4ea0acaf9db911df0088);
            

            marker_2ce36fb320604907a7237d1dab6213d0.bindPopup(popup_317ab55c5945455f900da6e7e4070f0a)
            ;

            
        
    
        var marker_caff96aa3f194a37b5416208197ba6dd = L.marker(
            [40.744936, -111.8575],
            {
                icon: new L.Icon.Default()
                }
            ).addTo(marker_cluster_ac4f92808f7642e4b4f23d861bcfe06c);
        
    

                var icon_f98ad3b27cc6493ea9965ee6f4227580 = L.AwesomeMarkers.icon({
                    icon: 'info-sign',
                    iconColor: 'white',
                    markerColor: 'green',
                    prefix: 'glyphicon',
                    extraClasses: 'fa-rotate-0'
                    });
                marker_caff96aa3f194a37b5416208197ba6dd.setIcon(icon_f98ad3b27cc6493ea9965ee6f4227580);
            
    
            var popup_4d84447c0c7e425a8945663bb25c0203 = L.popup({maxWidth: '300'
            
            });

            
                var html_b29811aa2aa94013b82d4398b445cac7 = $('<div id="html_b29811aa2aa94013b82d4398b445cac7" style="width: 100.0%; height: 100.0%;">RB_LDSWard (Stream): Red Butte Creek at LDS ward house at 1150 E Yale Ave</div>')[0];
                popup_4d84447c0c7e425a8945663bb25c0203.setContent(html_b29811aa2aa94013b82d4398b445cac7);
            

            marker_caff96aa3f194a37b5416208197ba6dd.bindPopup(popup_4d84447c0c7e425a8945663bb25c0203)
            ;

            
        
    
        var marker_77b003b44ee34f61a8f7f42b5610c227 = L.marker(
            [40.743794, -111.873406],
            {
                icon: new L.Icon.Default()
                }
            ).addTo(marker_cluster_ac4f92808f7642e4b4f23d861bcfe06c);
        
    

                var icon_e59f4fb1dd8b4a83b196f876456c4a2e = L.AwesomeMarkers.icon({
                    icon: 'info-sign',
                    iconColor: 'white',
                    markerColor: 'green',
                    prefix: 'glyphicon',
                    extraClasses: 'fa-rotate-0'
                    });
                marker_77b003b44ee34f61a8f7f42b5610c227.setIcon(icon_e59f4fb1dd8b4a83b196f876456c4a2e);
            
    
            var popup_f844b05604bb4c169c061a077a46cedb = L.popup({maxWidth: '300'
            
            });

            
                var html_8c907828e13543268d8664857522a45c = $('<div id="html_8c907828e13543268d8664857522a45c" style="width: 100.0%; height: 100.0%;">RB_LibLakeDock (Stream): Liberty Lake at Liberty Lake Dock</div>')[0];
                popup_f844b05604bb4c169c061a077a46cedb.setContent(html_8c907828e13543268d8664857522a45c);
            

            marker_77b003b44ee34f61a8f7f42b5610c227.bindPopup(popup_f844b05604bb4c169c061a077a46cedb)
            ;

            
        
    
        var marker_604d38ce108d4cc69a152be1cd758026 = L.marker(
            [40.742346, -111.8721],
            {
                icon: new L.Icon.Default()
                }
            ).addTo(marker_cluster_ac4f92808f7642e4b4f23d861bcfe06c);
        
    

                var icon_a22e8a0f25c44de88e45fb41cc2add81 = L.AwesomeMarkers.icon({
                    icon: 'info-sign',
                    iconColor: 'white',
                    markerColor: 'green',
                    prefix: 'glyphicon',
                    extraClasses: 'fa-rotate-0'
                    });
                marker_604d38ce108d4cc69a152be1cd758026.setIcon(icon_a22e8a0f25c44de88e45fb41cc2add81);
            
    
            var popup_1d46f708d2084f27ba7698e13c2bfa46 = L.popup({maxWidth: '300'
            
            });

            
                var html_c5f680e47cbd42349cd9aea90494b671 = $('<div id="html_c5f680e47cbd42349cd9aea90494b671" style="width: 100.0%; height: 100.0%;">RB_LibLakeEmigration (Stream): Emigration Creek terminus at Liberty Lake (pipe entering lake)</div>')[0];
                popup_1d46f708d2084f27ba7698e13c2bfa46.setContent(html_c5f680e47cbd42349cd9aea90494b671);
            

            marker_604d38ce108d4cc69a152be1cd758026.bindPopup(popup_1d46f708d2084f27ba7698e13c2bfa46)
            ;

            
        
    
        var marker_9cee4ec0b35e49c99829232e9ad420c1 = L.marker(
            [40.743881, -111.872147],
            {
                icon: new L.Icon.Default()
                }
            ).addTo(marker_cluster_ac4f92808f7642e4b4f23d861bcfe06c);
        
    

                var icon_c8c9ce5bdb0c4738b2ee9a66e0de4be5 = L.AwesomeMarkers.icon({
                    icon: 'info-sign',
                    iconColor: 'white',
                    markerColor: 'green',
                    prefix: 'glyphicon',
                    extraClasses: 'fa-rotate-0'
                    });
                marker_9cee4ec0b35e49c99829232e9ad420c1.setIcon(icon_c8c9ce5bdb0c4738b2ee9a66e0de4be5);
            
    
            var popup_b1ab8c223c37424db3aeec88e7bb0cb7 = L.popup({maxWidth: '300'
            
            });

            
                var html_3b519ee8bff24fe89c0055847122ae74 = $('<div id="html_3b519ee8bff24fe89c0055847122ae74" style="width: 100.0%; height: 100.0%;">RB_LibLakeRedButte (Stream): Red Butte Creek terminus at Liberty Lake (pipe entering lake)</div>')[0];
                popup_b1ab8c223c37424db3aeec88e7bb0cb7.setContent(html_3b519ee8bff24fe89c0055847122ae74);
            

            marker_9cee4ec0b35e49c99829232e9ad420c1.bindPopup(popup_b1ab8c223c37424db3aeec88e7bb0cb7)
            ;

            
        
    
        var marker_08744b084f504836b627ddd0ba022307 = L.marker(
            [40.749658, -111.841814],
            {
                icon: new L.Icon.Default()
                }
            ).addTo(marker_cluster_ac4f92808f7642e4b4f23d861bcfe06c);
        
    

                var icon_8c4937c3988045dc94819b751ce501cc = L.AwesomeMarkers.icon({
                    icon: 'info-sign',
                    iconColor: 'white',
                    markerColor: 'green',
                    prefix: 'glyphicon',
                    extraClasses: 'fa-rotate-0'
                    });
                marker_08744b084f504836b627ddd0ba022307.setIcon(icon_8c4937c3988045dc94819b751ce501cc);
            
    
            var popup_fcbc17e0899245d4bc987f0a4137af50 = L.popup({maxWidth: '300'
            
            });

            
                var html_04c4b29c50034141ba096093ce854384 = $('<div id="html_04c4b29c50034141ba096093ce854384" style="width: 100.0%; height: 100.0%;">RB_MillerEntrance (Stream): Red Butte Creek at Miller Park Enterance at 900 South</div>')[0];
                popup_fcbc17e0899245d4bc987f0a4137af50.setContent(html_04c4b29c50034141ba096093ce854384);
            

            marker_08744b084f504836b627ddd0ba022307.bindPopup(popup_fcbc17e0899245d4bc987f0a4137af50)
            ;

            
        
    
        var marker_d2a465ff97c246d8b0c16d96fdee5843 = L.marker(
            [40.787611, -111.796389],
            {
                icon: new L.Icon.Default()
                }
            ).addTo(marker_cluster_ac4f92808f7642e4b4f23d861bcfe06c);
        
    

                var icon_76ade83af5c3474fb1293199755aa42e = L.AwesomeMarkers.icon({
                    icon: 'info-sign',
                    iconColor: 'white',
                    markerColor: 'green',
                    prefix: 'glyphicon',
                    extraClasses: 'fa-rotate-0'
                    });
                marker_d2a465ff97c246d8b0c16d96fdee5843.setIcon(icon_76ade83af5c3474fb1293199755aa42e);
            
    
            var popup_20cd8383d11345449cf0baec42e4285a = L.popup({maxWidth: '300'
            
            });

            
                var html_ff19d49f6dd943a3badcb257d15c4b1b = $('<div id="html_ff19d49f6dd943a3badcb257d15c4b1b" style="width: 100.0%; height: 100.0%;">RB_PFJunction (Stream): Parleys Fork at Parleys Fork junction</div>')[0];
                popup_20cd8383d11345449cf0baec42e4285a.setContent(html_ff19d49f6dd943a3badcb257d15c4b1b);
            

            marker_d2a465ff97c246d8b0c16d96fdee5843.bindPopup(popup_20cd8383d11345449cf0baec42e4285a)
            ;

            
        
    
        var marker_c37f6821bd064edfa41caff09aa2eb12 = L.marker(
            [40.80289722, -111.7643389],
            {
                icon: new L.Icon.Default()
                }
            ).addTo(marker_cluster_ac4f92808f7642e4b4f23d861bcfe06c);
        
    

                var icon_a812123408e343769ed09122a2a70ae0 = L.AwesomeMarkers.icon({
                    icon: 'info-sign',
                    iconColor: 'white',
                    markerColor: 'green',
                    prefix: 'glyphicon',
                    extraClasses: 'fa-rotate-0'
                    });
                marker_c37f6821bd064edfa41caff09aa2eb12.setIcon(icon_a812123408e343769ed09122a2a70ae0);
            
    
            var popup_73928e9092364b76a8bf3b1bf96e70e3 = L.popup({maxWidth: '300'
            
            });

            
                var html_c1ee1908427444948faa93e3c33b6efe = $('<div id="html_c1ee1908427444948faa93e3c33b6efe" style="width: 100.0%; height: 100.0%;">RB_RBFork (Stream): Red Butte Creek at Red Butte Fork</div>')[0];
                popup_73928e9092364b76a8bf3b1bf96e70e3.setContent(html_c1ee1908427444948faa93e3c33b6efe);
            

            marker_c37f6821bd064edfa41caff09aa2eb12.bindPopup(popup_73928e9092364b76a8bf3b1bf96e70e3)
            ;

            
        
    
        var marker_a72ceb967ba94440aa9625d8ea716477 = L.marker(
            [40.774228, -111.817025],
            {
                icon: new L.Icon.Default()
                }
            ).addTo(marker_cluster_ac4f92808f7642e4b4f23d861bcfe06c);
        
    

                var icon_5d529b1b2e534f81bee291d2112b06d7 = L.AwesomeMarkers.icon({
                    icon: 'info-sign',
                    iconColor: 'white',
                    markerColor: 'green',
                    prefix: 'glyphicon',
                    extraClasses: 'fa-rotate-0'
                    });
                marker_a72ceb967ba94440aa9625d8ea716477.setIcon(icon_5d529b1b2e534f81bee291d2112b06d7);
            
    
            var popup_620104544ffd487b9f0e0a940f4edcc0 = L.popup({maxWidth: '300'
            
            });

            
                var html_e48a0da9eca849df99a43915d5f9916d = $('<div id="html_e48a0da9eca849df99a43915d5f9916d" style="width: 100.0%; height: 100.0%;">RB_RBG_BA (Stream): Red Butte Creek at Red Butte Gate Basic Aquatic</div>')[0];
                popup_620104544ffd487b9f0e0a940f4edcc0.setContent(html_e48a0da9eca849df99a43915d5f9916d);
            

            marker_a72ceb967ba94440aa9625d8ea716477.bindPopup(popup_620104544ffd487b9f0e0a940f4edcc0)
            ;

            
        
    
        var marker_f98eaa26b7bc414ba544e72e7603db6d = L.marker(
            [40.779379, -111.808632],
            {
                icon: new L.Icon.Default()
                }
            ).addTo(marker_cluster_ac4f92808f7642e4b4f23d861bcfe06c);
        
    

                var icon_5eae6661f42e47859f943c2e22acda17 = L.AwesomeMarkers.icon({
                    icon: 'info-sign',
                    iconColor: 'white',
                    markerColor: 'green',
                    prefix: 'glyphicon',
                    extraClasses: 'fa-rotate-0'
                    });
                marker_f98eaa26b7bc414ba544e72e7603db6d.setIcon(icon_5eae6661f42e47859f943c2e22acda17);
            
    
            var popup_5c79a1ecbf6e411487fa3d0943fdf231 = L.popup({maxWidth: '300'
            
            });

            
                var html_99df5f12390c4c839e59951e4f765ff0 = $('<div id="html_99df5f12390c4c839e59951e4f765ff0" style="width: 100.0%; height: 100.0%;">RB_RBReservoir (Stream): Red Butte Reservoir at boat ramp</div>')[0];
                popup_5c79a1ecbf6e411487fa3d0943fdf231.setContent(html_99df5f12390c4c839e59951e4f765ff0);
            

            marker_f98eaa26b7bc414ba544e72e7603db6d.bindPopup(popup_5c79a1ecbf6e411487fa3d0943fdf231)
            ;

            
        
    
        var marker_5094f824ef57468985268903deb35092 = L.marker(
            [40.74711111, -111.8447389],
            {
                icon: new L.Icon.Default()
                }
            ).addTo(marker_cluster_ac4f92808f7642e4b4f23d861bcfe06c);
        
    

                var icon_add406a799124c228ac53e6a1842fa99 = L.AwesomeMarkers.icon({
                    icon: 'info-sign',
                    iconColor: 'white',
                    markerColor: 'green',
                    prefix: 'glyphicon',
                    extraClasses: 'fa-rotate-0'
                    });
                marker_5094f824ef57468985268903deb35092.setIcon(icon_add406a799124c228ac53e6a1842fa99);
            
    
            var popup_be123db11e1f4d318ea385617e072f2a = L.popup({maxWidth: '300'
            
            });

            
                var html_2daf22c2371545d387fb4fcbeb8026a2 = $('<div id="html_2daf22c2371545d387fb4fcbeb8026a2" style="width: 100.0%; height: 100.0%;">RB_SLCO (Stream): Red Butte Creek at 1600 East SLCO Bonneview aquatic monitoring station</div>')[0];
                popup_be123db11e1f4d318ea385617e072f2a.setContent(html_2daf22c2371545d387fb4fcbeb8026a2);
            

            marker_5094f824ef57468985268903deb35092.bindPopup(popup_be123db11e1f4d318ea385617e072f2a)
            ;

            
        
    
        var marker_2db6e4028d6a431ba9aed4b61ecf1114 = L.marker(
            [40.751677, -111.839529],
            {
                icon: new L.Icon.Default()
                }
            ).addTo(marker_cluster_ac4f92808f7642e4b4f23d861bcfe06c);
        
    

                var icon_5b5e67990c334de09d0e335b347fb124 = L.AwesomeMarkers.icon({
                    icon: 'info-sign',
                    iconColor: 'white',
                    markerColor: 'green',
                    prefix: 'glyphicon',
                    extraClasses: 'fa-rotate-0'
                    });
                marker_2db6e4028d6a431ba9aed4b61ecf1114.setIcon(icon_5b5e67990c334de09d0e335b347fb124);
            
    
            var popup_ef7152b3f0344da6959a3ee1fc700c60 = L.popup({maxWidth: '300'
            
            });

            
                var html_925a7928ffc849a4bee8820cab7064b6 = $('<div id="html_925a7928ffc849a4bee8820cab7064b6" style="width: 100.0%; height: 100.0%;">RB_SunnysidePark (Stream): Red Butte Creek at Sunnyside Park</div>')[0];
                popup_ef7152b3f0344da6959a3ee1fc700c60.setContent(html_925a7928ffc849a4bee8820cab7064b6);
            

            marker_2db6e4028d6a431ba9aed4b61ecf1114.bindPopup(popup_ef7152b3f0344da6959a3ee1fc700c60)
            ;

            
        
    
        var marker_175fee6ad5864680957794c77f4e98c7 = L.marker(
            [40.789056, -111.796667],
            {
                icon: new L.Icon.Default()
                }
            ).addTo(marker_cluster_ac4f92808f7642e4b4f23d861bcfe06c);
        
    

                var icon_a385f5da9313496d87d7f8d9acf7d246 = L.AwesomeMarkers.icon({
                    icon: 'info-sign',
                    iconColor: 'white',
                    markerColor: 'green',
                    prefix: 'glyphicon',
                    extraClasses: 'fa-rotate-0'
                    });
                marker_175fee6ad5864680957794c77f4e98c7.setIcon(icon_a385f5da9313496d87d7f8d9acf7d246);
            
    
            var popup_dc8608f3f3d745e59a0b1d815d2924f1 = L.popup({maxWidth: '300'
            
            });

            
                var html_eb15e68b8d8f4d028dafeeda6e04b412 = $('<div id="html_eb15e68b8d8f4d028dafeeda6e04b412" style="width: 100.0%; height: 100.0%;">RB_ToddMeadow (Stream): Parleys Fork at Todds Meadow</div>')[0];
                popup_dc8608f3f3d745e59a0b1d815d2924f1.setContent(html_eb15e68b8d8f4d028dafeeda6e04b412);
            

            marker_175fee6ad5864680957794c77f4e98c7.bindPopup(popup_dc8608f3f3d745e59a0b1d815d2924f1)
            ;

            
        
    
        var marker_17a30b5416c348eebaaaebc9b2845b75 = L.marker(
            [40.756048, -111.835348],
            {
                icon: new L.Icon.Default()
                }
            ).addTo(marker_cluster_ac4f92808f7642e4b4f23d861bcfe06c);
        
    

                var icon_eb4264077c4441bb96e5c17091cdf74a = L.AwesomeMarkers.icon({
                    icon: 'info-sign',
                    iconColor: 'white',
                    markerColor: 'green',
                    prefix: 'glyphicon',
                    extraClasses: 'fa-rotate-0'
                    });
                marker_17a30b5416c348eebaaaebc9b2845b75.setIcon(icon_eb4264077c4441bb96e5c17091cdf74a);
            
    
            var popup_f5e186d229ea49f7b1f75dd5aca5788f = L.popup({maxWidth: '300'
            
            });

            
                var html_78a00f5d20d5417b830c0b6e8353b771 = $('<div id="html_78a00f5d20d5417b830c0b6e8353b771" style="width: 100.0%; height: 100.0%;">RB_Walkway (Stream): Red Butte Creek at walkway near Veterens Administration buildings</div>')[0];
                popup_f5e186d229ea49f7b1f75dd5aca5788f.setContent(html_78a00f5d20d5417b830c0b6e8353b771);
            

            marker_17a30b5416c348eebaaaebc9b2845b75.bindPopup(popup_f5e186d229ea49f7b1f75dd5aca5788f)
            ;

            
        
    
        var marker_e9e0310dafe74caf8b0bf89d3b06fa43 = L.marker(
            [40.746167, -111.846639],
            {
                icon: new L.Icon.Default()
                }
            ).addTo(marker_cluster_ac4f92808f7642e4b4f23d861bcfe06c);
        
    

                var icon_ed2df423ea924f56a986b139892b23d4 = L.AwesomeMarkers.icon({
                    icon: 'info-sign',
                    iconColor: 'white',
                    markerColor: 'green',
                    prefix: 'glyphicon',
                    extraClasses: 'fa-rotate-0'
                    });
                marker_e9e0310dafe74caf8b0bf89d3b06fa43.setIcon(icon_ed2df423ea924f56a986b139892b23d4);
            
    
            var popup_df341c9353e1480799ca9427abbef28d = L.popup({maxWidth: '300'
            
            });

            
                var html_d5594deb324f4d6bbe5cea8eb216e7c9 = $('<div id="html_d5594deb324f4d6bbe5cea8eb216e7c9" style="width: 100.0%; height: 100.0%;">RB_WestMiller (Stream): Red Butte Creek at West Miller Park</div>')[0];
                popup_df341c9353e1480799ca9427abbef28d.setContent(html_d5594deb324f4d6bbe5cea8eb216e7c9);
            

            marker_e9e0310dafe74caf8b0bf89d3b06fa43.bindPopup(popup_df341c9353e1480799ca9427abbef28d)
            ;

            
        
</script>\" style=\"position:absolute;width:100%;height:100%;left:0;top:0;border:none !important;\" allowfullscreen webkitallowfullscreen mozallowfullscreen></iframe></div></div>"
       ],
       "text/plain": [
-       "<folium.folium.Map at 0x7fdd5a7527d0>"
+       "<folium.folium.Map at 0x7febfc3af190>"
       ]
      },
      "execution_count": 15,
@@ -1016,7 +1015,7 @@
        " 'SamplingFeatureUUID': u'0DDE8EF6-EC2F-42C0-AB50-20C6C02E89B2',\n",
        " 'SiteTypeCV': u'Stream',\n",
        " 'SpatialReferenceID': 1,\n",
-       " '_sa_instance_state': <sqlalchemy.orm.state.InstanceState at 0x7fdd5c89bed0>}"
+       " '_sa_instance_state': <sqlalchemy.orm.state.InstanceState at 0x7febbd3211d0>}"
       ]
      },
      "execution_count": 18,
@@ -1045,9 +1044,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "------------ Foreign Key Example --------- \n",
-      "\n",
-      "('The FeatureAction object for the Result is: ', <FeatureActions({'SamplingFeatureID': 26, 'FeatureActionID': 1, 'ActionID': 1})>)\n",
+      "('The FeatureAction object for the Result is: ', <FeatureActions({'FeatureActionID': 1, 'SamplingFeatureID': 26, 'ActionID': 1})>)\n",
       "('The Action object for the Result is: ', <Actions({'MethodID': 2, 'ActionDescription': None, 'ActionFileLink': None, 'EndDateTime': None, 'BeginDateTime': datetime.datetime(2014, 10, 30, 0, 0), 'EndDateTimeUTCOffset': None, 'ActionTypeCV': u'Specimen analysis', 'ActionID': 1, 'BeginDateTimeUTCOffset': -7})>)\n",
       "\n",
       "The following are some of the attributes for the Action that created the Result: \n",
@@ -1061,16 +1058,15 @@
     }
    ],
    "source": [
-    "print(\"------------ Foreign Key Example --------- \\n\")\n",
     "try:\n",
     "    # Call getResults, but return only the first Result\n",
     "    firstResult = read.getResults()[0]\n",
     "    frfa = firstResult.FeatureActionObj\n",
+    "    frfaa = firstResult.FeatureActionObj.ActionObj\n",
     "    print(\"The FeatureAction object for the Result is: \", frfa)\n",
-    "    print(\"The Action object for the Result is: \", frfa.ActionObj)\n",
+    "    print(\"The Action object for the Result is: \", frfaa)\n",
     "    \n",
-    "    # Print some of those attributes in a more human readable form\n",
-    "    frfaa = firstResult.FeatureActionObj.ActionObj\n",
+    "    # Print some Action attributes in a more human readable form\n",
     "    print(\"\\nThe following are some of the attributes for the Action that created the Result: \")\n",
     "    print(\"ActionTypeCV: {}\".format(frfaa.ActionTypeCV))\n",
     "    print(\"ActionDescription: {}\".format(frfaa.ActionDescription))\n",
@@ -1079,7 +1075,7 @@
     "    print(\"MethodName: {}\".format(frfaa.MethodObj.MethodName))\n",
     "    print(\"MethodDescription: {}\".format(frfaa.MethodObj.MethodDescription))\n",
     "except Exception as e:\n",
-    "    print(\"Unable to demo Foreign Key Example: \", e)"
+    "    print(\"Unable to demo Foreign Key Example: {}\".format(e))"
    ]
   },
   {
@@ -1131,7 +1127,7 @@
     "    print(\"SamplingFeatureID: {}\".format(frfa.SamplingFeatureObj.SamplingFeatureID))\n",
     "    print(\"SamplingFeatureCode: {}\".format(frfa.SamplingFeatureObj.SamplingFeatureCode))\n",
     "except Exception as e:\n",
-    "    print(\"Unable to demo example of retrieving Attributes of a Result: \", e)"
+    "    print(\"Unable to demo example of retrieving Attributes of a Result: {}\".format(e))"
    ]
   },
   {
@@ -1180,7 +1176,7 @@
        " 'SamplingFeatureUUID': u'0DDE8EF6-EC2F-42C0-AB50-20C6C02E89B2',\n",
        " 'SiteTypeCV': u'Stream',\n",
        " 'SpatialReferenceID': 1,\n",
-       " '_sa_instance_state': <sqlalchemy.orm.state.InstanceState at 0x7fdd5c89bed0>}"
+       " '_sa_instance_state': <sqlalchemy.orm.state.InstanceState at 0x7febbd3211d0>}"
       ]
      },
      "execution_count": 22,
@@ -1286,7 +1282,7 @@
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>0.0100</td>\n",
-       "      <td>2015-10-27 13:26:24.000000</td>\n",
+       "      <td>2015-10-27 13:26:24</td>\n",
        "      <td>-7</td>\n",
        "    </tr>\n",
        "    <tr>\n",
@@ -1294,7 +1290,7 @@
        "      <td>100</td>\n",
        "      <td>1</td>\n",
        "      <td>0.0100</td>\n",
-       "      <td>2015-11-17 13:55:12.000000</td>\n",
+       "      <td>2015-11-17 13:55:12</td>\n",
        "      <td>-7</td>\n",
        "    </tr>\n",
        "    <tr>\n",
@@ -1302,7 +1298,7 @@
        "      <td>109</td>\n",
        "      <td>10</td>\n",
        "      <td>0.0574</td>\n",
-       "      <td>2015-05-12 14:24:00.000000</td>\n",
+       "      <td>2015-05-12 14:24:00</td>\n",
        "      <td>-7</td>\n",
        "    </tr>\n",
        "    <tr>\n",
@@ -1310,7 +1306,7 @@
        "      <td>10</td>\n",
        "      <td>10</td>\n",
        "      <td>0.0574</td>\n",
-       "      <td>2015-06-18 12:43:12.000000</td>\n",
+       "      <td>2015-06-18 12:43:12</td>\n",
        "      <td>-7</td>\n",
        "    </tr>\n",
        "    <tr>\n",
@@ -1318,7 +1314,7 @@
        "      <td>198</td>\n",
        "      <td>99</td>\n",
        "      <td>0.0424</td>\n",
-       "      <td>2015-10-27 13:55:12.000000</td>\n",
+       "      <td>2015-10-27 13:55:12</td>\n",
        "      <td>-7</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
@@ -1326,19 +1322,12 @@
        "</div>"
       ],
       "text/plain": [
-       "   ValueID  ResultID  DataValue               ValueDateTime  \\\n",
-       "0        1         1     0.0100  2015-10-27 13:26:24.000000   \n",
-       "1      100         1     0.0100  2015-11-17 13:55:12.000000   \n",
-       "2      109        10     0.0574  2015-05-12 14:24:00.000000   \n",
-       "3       10        10     0.0574  2015-06-18 12:43:12.000000   \n",
-       "4      198        99     0.0424  2015-10-27 13:55:12.000000   \n",
-       "\n",
-       "   ValueDateTimeUTCOffset  \n",
-       "0                      -7  \n",
-       "1                      -7  \n",
-       "2                      -7  \n",
-       "3                      -7  \n",
-       "4                      -7  "
+       "   ValueID  ResultID  DataValue       ValueDateTime  ValueDateTimeUTCOffset\n",
+       "0        1         1     0.0100 2015-10-27 13:26:24                      -7\n",
+       "1      100         1     0.0100 2015-11-17 13:55:12                      -7\n",
+       "2      109        10     0.0574 2015-05-12 14:24:00                      -7\n",
+       "3       10        10     0.0574 2015-06-18 12:43:12                      -7\n",
+       "4      198        99     0.0424 2015-10-27 13:55:12                      -7"
       ]
      },
      "execution_count": 25,
@@ -1350,9 +1339,21 @@
     "# Get all of the data values for the Results in the list created above\n",
     "# Call getResultValues, which returns a Pandas Data Frame with the data\n",
     "resultValues = read.getResultValues(resultids=resultIDList, lowercols=False)\n",
+    "resultValues['ValueDateTime'] = pd.to_datetime(resultValues['ValueDateTime'])\n",
     "resultValues.head()"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**10/5/2018. NOTE CURRENT ISSUE REGARDING `ValueDateTime` RETURNED BY `read.getResultValues`.** There seems to be an unexpected behavior with the data type returned for `ValueDateTime` for SQLite databases. It should be a datetime, but it's currently a string. This is [being investigated](https://github.com/ODM2/ODM2PythonAPI/issues/158). For now, we are converting to a datetime manually in cells 25 and 27 via the statement:\n",
+    "```python\n",
+    "resultValues['ValueDateTime'] = pd.to_datetime(resultValues['ValueDateTime'])\n",
+    "```\n",
+    "This problem is present in `odm2api` version 0.7.1, but was not present in Nov. 2017"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 26,
@@ -1360,7 +1361,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -1378,17 +1379,9 @@
     "ax.set_ylabel(\"{0} ({1})\".format(results[0].VariableObj.VariableNameCV, \n",
     "                                 results[0].UnitsObj.UnitsAbbreviation))\n",
     "ax.set_xlabel('Date/Time')\n",
-    "ax.grid(True)\n",
     "ax.legend().set_visible(False)"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**9/23/2018. NOTE CURRENT ISSUE REGARDING `ValueDateTime` RETURNED BY `read.getResultValues`.** There seems to be a problem with the data type returned for `ValueDateTime` for SQLite databases. It should be a datetime, but it's currently a string. This is [being investigated](https://github.com/ODM2/ODM2PythonAPI/issues/158). For now, the x-axis in this plot and the one below do not show proper datetime values, as expected. Refer to the [original notebook]( https://github.com/BiG-CZ/wshp2017_tutorial_content/blob/master/notebooks/ODM2_Example3.ipynb) to see what the axis should look like. This problem wasn't present in Nov. 2017."
-   ]
-  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -1411,6 +1404,7 @@
     "    results = read.getResults(siteid=siteid, variableid=variableID, restype=\"Measurement\")\n",
     "    resultIDList = [x.ResultID for x in results]\n",
     "    resultValues = read.getResultValues(resultids=resultIDList, lowercols=False)\n",
+    "    resultValues['ValueDateTime'] = pd.to_datetime(resultValues['ValueDateTime'])\n",
     "    \n",
     "    return resultValues, results"
    ]
@@ -1429,7 +1423,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 936x432 with 2 Axes>"
       ]
@@ -1441,7 +1435,7 @@
     }
    ],
    "source": [
-    "# Plot figure and axis set up (just *one* subplot, actually)\n",
+    "# Plot figure and axis set up\n",
     "f, ax = plt.subplots(1, figsize=(13, 6))\n",
     "\n",
     "# First plot (left axis)\n",
diff --git a/Examples/data/README.md b/Examples/data/README.md
new file mode 100644
index 0000000..2a89482
--- /dev/null
+++ b/Examples/data/README.md
@@ -0,0 +1,4 @@
+## Original source of each of the sample ODM2 databases:
+
+- `USU_LittleBearRiver_timeseriesresults_ODM2.sqlite`: https://github.com/ODM2/WOFpy/blob/master/test/odm2/ODM2.sqlite
+- `iUTAHGAMUT_waterquality_measurementresults_ODM2.sqlite`: https://github.com/BiG-CZ/wshp2017_tutorial_content/blob/master/data/expectedoutput/ODM2_Example2.sqlite
diff --git a/Examples/data/USU_LittleBearRiver_timeseriesresults_ODM2.sqlite b/Examples/data/USU_LittleBearRiver_timeseriesresults_ODM2.sqlite
new file mode 100644
index 0000000..e15ecf9
Binary files /dev/null and b/Examples/data/USU_LittleBearRiver_timeseriesresults_ODM2.sqlite differ