{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# ODM2 API: Retrieve, manipulate and visualize ODM2 water quality measurement-type 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 (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, 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",
"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.\n",
"\n",
"[Emilio Mayorga](https://github.com/emiliom/)"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"/home/mayorga/miniconda/envs/odm2client/lib/python2.7/site-packages/folium/__init__.py:59: UserWarning: This version of folium is the last to support Python 2. Transition to Python 3 to be able to receive updates and fixes. Check out https://python3statement.org/ for more info.\n",
" UserWarning\n"
]
}
],
"source": [
"import os\n",
"import datetime\n",
"\n",
"import matplotlib.pyplot as plt\n",
"%matplotlib inline\n",
"\n",
"from shapely.geometry import Point\n",
"import pandas as pd\n",
"import geopandas as gpd\n",
"import folium\n",
"from folium.plugins import MarkerCluster\n",
"\n",
"import odm2api\n",
"from odm2api.ODMconnection import dbconnection\n",
"import odm2api.services.readService as odm2rs\n",
"from odm2api.models import SamplingFeatures"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'2019-05-12 01:58:17.943605 UTC'"
]
},
"execution_count": 2,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"\"{} UTC\".format(datetime.datetime.utcnow())"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(u'0.24.2', u'0.5.0', u'0.8.3')"
]
},
"execution_count": 3,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"pd.__version__, gpd.__version__, folium.__version__"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**odm2api version used** to run this notebook:"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"u'0.7.2'"
]
},
"execution_count": 4,
"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 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."
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [],
"source": [
"# Assign directory paths and SQLite file name\n",
"dbname_sqlite = \"iUTAHGAMUT_waterquality_measurementresults_ODM2.sqlite\"\n",
"\n",
"sqlite_pth = os.path.join(\"data\", dbname_sqlite)"
]
},
{
"cell_type": "code",
"execution_count": 6,
"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.\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": "markdown",
"metadata": {},
"source": [
"### Get all Variables\n",
"A simple query with simple output."
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"
\n",
"\n",
"
\n",
" \n",
"
\n",
"
\n",
"
NoDataValue
\n",
"
SpeciationCV
\n",
"
VariableCode
\n",
"
VariableDefinition
\n",
"
VariableNameCV
\n",
"
VariableTypeCV
\n",
"
_sa_instance_state
\n",
"
\n",
"
\n",
"
VariableID
\n",
"
\n",
"
\n",
"
\n",
"
\n",
"
\n",
"
\n",
"
\n",
"
\n",
" \n",
" \n",
"
\n",
"
1
\n",
"
-9999.0000000000
\n",
"
N
\n",
"
TN
\n",
"
None
\n",
"
Nitrogen, total
\n",
"
Water quality
\n",
"
<sqlalchemy.orm.state.InstanceState object at ...
\n",
"
\n",
"
\n",
"
2
\n",
"
-9999.0000000000
\n",
"
P
\n",
"
TP
\n",
"
None
\n",
"
Phosphorus, total
\n",
"
Water quality
\n",
"
<sqlalchemy.orm.state.InstanceState object at ...
\n",
"
\n",
"
\n",
"
3
\n",
"
-9999.0000000000
\n",
"
N
\n",
"
Nitrate
\n",
"
None
\n",
"
Nitrogen, dissolved nitrite (NO2) + nitrate (NO3)
\n",
"
Water quality
\n",
"
<sqlalchemy.orm.state.InstanceState object at ...
\n",
"
\n",
"
\n",
"
4
\n",
"
-9999.0000000000
\n",
"
N
\n",
"
Ammonia
\n",
"
None
\n",
"
Nitrogen, NH4
\n",
"
Water quality
\n",
"
<sqlalchemy.orm.state.InstanceState object at ...
\n",
"
\n",
"
\n",
"
5
\n",
"
-9999.0000000000
\n",
"
P
\n",
"
Phosphate
\n",
"
None
\n",
"
Phosphorus, orthophosphate dissolved
\n",
"
Water quality
\n",
"
<sqlalchemy.orm.state.InstanceState object at ...
\n",
"
\n",
"
\n",
"
6
\n",
"
-9999.0000000000
\n",
"
Not Applicable
\n",
"
Tcoliform
\n",
"
None
\n",
"
Coliform, total
\n",
"
Water quality
\n",
"
<sqlalchemy.orm.state.InstanceState object at ...
\n",
"
\n",
"
\n",
"
7
\n",
"
-9999.0000000000
\n",
"
Not Applicable
\n",
"
E-Coli
\n",
"
None
\n",
"
E-coli
\n",
"
Water quality
\n",
"
<sqlalchemy.orm.state.InstanceState object at ...
\n",
"
\n",
"
\n",
"
8
\n",
"
-9999.0000000000
\n",
"
C
\n",
"
DOC
\n",
"
None
\n",
"
Carbon, dissolved organic
\n",
"
Water quality
\n",
"
<sqlalchemy.orm.state.InstanceState object at ...
\n",
"
\n",
"
\n",
"
9
\n",
"
-9999.0000000000
\n",
"
N
\n",
"
TDN
\n",
"
None
\n",
"
Nitrogen, total dissolved
\n",
"
Water quality
\n",
"
<sqlalchemy.orm.state.InstanceState object at ...
\n",
"
\n",
"
\n",
"
10
\n",
"
-9999.0000000000
\n",
"
Not Applicable
\n",
"
Abs254
\n",
"
None
\n",
"
Absorbance
\n",
"
Water quality
\n",
"
<sqlalchemy.orm.state.InstanceState object at ...
\n",
"
\n",
" \n",
"
\n",
"
"
],
"text/plain": [
" NoDataValue SpeciationCV VariableCode VariableDefinition \\\n",
"VariableID \n",
"1 -9999.0000000000 N TN None \n",
"2 -9999.0000000000 P TP None \n",
"3 -9999.0000000000 N Nitrate None \n",
"4 -9999.0000000000 N Ammonia None \n",
"5 -9999.0000000000 P Phosphate None \n",
"6 -9999.0000000000 Not Applicable Tcoliform None \n",
"7 -9999.0000000000 Not Applicable E-Coli None \n",
"8 -9999.0000000000 C DOC None \n",
"9 -9999.0000000000 N TDN None \n",
"10 -9999.0000000000 Not Applicable Abs254 None \n",
"\n",
" VariableNameCV VariableTypeCV \\\n",
"VariableID \n",
"1 Nitrogen, total Water quality \n",
"2 Phosphorus, total Water quality \n",
"3 Nitrogen, dissolved nitrite (NO2) + nitrate (NO3) Water quality \n",
"4 Nitrogen, NH4 Water quality \n",
"5 Phosphorus, orthophosphate dissolved Water quality \n",
"6 Coliform, total Water quality \n",
"7 E-coli Water quality \n",
"8 Carbon, dissolved organic Water quality \n",
"9 Nitrogen, total dissolved Water quality \n",
"10 Absorbance Water quality \n",
"\n",
" _sa_instance_state \n",
"VariableID \n",
"1 \n",
"\n",
"
\n",
""
],
"text/plain": [
" ElevationDatumCV Elevation_m FeatureGeometryWKT Latitude Longitude \\\n",
"0 EGM96 1356.0 None 40.745078 -111.854449 \n",
"1 EGM96 1356.0 None 40.745106 -111.854389 \n",
"2 EGM96 1289.0 None 40.741583 -111.917667 \n",
"3 EGM96 1519.0 None 40.766134 -111.826530 \n",
"4 EGM96 1648.0 None 40.779602 -111.806669 \n",
"\n",
" SamplingFeatureCode SamplingFeatureDescription SamplingFeatureGeotypeCV \\\n",
"0 RB_1300E None None \n",
"1 RB_1300ESpring None None \n",
"2 RB_900W_BA None None \n",
"3 RB_Amphitheater None None \n",
"4 RB_ARBR_AA None None \n",
"\n",
" SamplingFeatureID SamplingFeatureName \\\n",
"0 1 Red Butte Creek at 1300E (downstream of spring) \n",
"1 2 Spring that enters Red Butte Creek at 1300E \n",
"2 3 Red Butte Creek terminus at Jordan River at 13... \n",
"3 4 Red Butte Creek below Red Butte Garden Amphith... \n",
"4 5 Red Butte Creek above Red Butte Reservoir Adan... \n",
"\n",
" SamplingFeatureTypeCV SamplingFeatureUUID SiteTypeCV \\\n",
"0 Site 0DDE8EF6-EC2F-42C0-AB50-20C6C02E89B2 Stream \n",
"1 Site 9848BBFE-EA3F-4918-A324-13E8EDE5381C Spring \n",
"2 Site 688017BC-9E02-4444-A21D-270366BE2348 Stream \n",
"3 Site 9CFE685B-5CDA-4E38-98D9-406D645C7D21 Stream \n",
"4 Site 98C7F63A-FDFB-4898-87C6-5AA8EC34D1E4 Stream \n",
"\n",
" SpatialReferenceID _sa_instance_state \\\n",
"0 1 "
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"# A trivial but easy-to-generate GeoPandas plot\n",
"gdf.plot();"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"A site has a `SiteTypeCV`. Let's examine the site type distribution, and use that information to create a new GeoDataFrame column to specify a map marker color by `SiteTypeCV`."
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"Stream 24\n",
"Spring 1\n",
"Name: SiteTypeCV, dtype: int64"
]
},
"execution_count": 13,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"gdf['SiteTypeCV'].value_counts()"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [],
"source": [
"gdf[\"color\"] = gdf.apply(lambda feat: 'green' if feat['SiteTypeCV'] == 'Stream' else 'red', axis=1)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Note: While the database holds a copy of the **ODM2 Controlled Vocabularies**, the complete description of each CV term is available from a web request to the CV API at http://vocabulary.odm2.org. Want to know more about how a \"spring\" is defined? Here's one simple way, using `Pandas` to access and parse the CSV web service response."
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"
\n",
"\n",
"
\n",
" \n",
"
\n",
"
\n",
"
term
\n",
"
name
\n",
"
definition
\n",
"
category
\n",
"
provenance
\n",
"
provenance_uri
\n",
"
note
\n",
"
\n",
" \n",
" \n",
"
\n",
"
0
\n",
"
spring
\n",
"
Spring
\n",
"
A location at which the water table intersects...
\n",
"
Spring Sites
\n",
"
Adapted from USGS Site Types.
\n",
"
NaN
\n",
"
http://wdr.water.usgs.gov/nwisgmap/help/sitety...
\n",
"
\n",
" \n",
"
\n",
"
"
],
"text/plain": [
" term name definition \\\n",
"0 spring Spring A location at which the water table intersects... \n",
"\n",
" category provenance provenance_uri \\\n",
"0 Spring Sites Adapted from USGS Site Types. NaN \n",
"\n",
" note \n",
"0 http://wdr.water.usgs.gov/nwisgmap/help/sitety... "
]
},
"execution_count": 15,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"sitetype = 'spring'\n",
"pd.read_csv(\"http://vocabulary.odm2.org/api/v1/sitetype/{}/?format=csv\".format(sitetype))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Now we'll create an interactive and helpful `Folium` map of the sites.** This map features:\n",
"- Automatic panning to the location of the sites (no hard wiring, except for the zoom scale), based on GeoPandas functionality and information from the ODM2 Site Sampling Features\n",
"- Color coding by `SiteTypeCV` \n",
"- Marker clustering\n",
"- Simple marker pop ups with content from the ODM2 Site Sampling Features"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"
"
],
"text/plain": [
""
]
},
"execution_count": 16,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"c = gdf.unary_union.centroid\n",
"m = folium.Map(location=[c.y, c.x], tiles='CartoDB positron', zoom_start=11)\n",
"\n",
"marker_cluster = MarkerCluster().add_to(m)\n",
"for idx, feature in gdf.iterrows():\n",
" folium.Marker(location=[feature.geometry.y, feature.geometry.x], \n",
" icon=folium.Icon(color=feature['color']),\n",
" popup=\"{0} ({1}): {2}\".format(\n",
" feature['SamplingFeatureCode'], feature['SiteTypeCV'], \n",
" feature['SamplingFeatureName'])\n",
" ).add_to(marker_cluster)\n",
"\n",
" \n",
"# Done with setup. Now render the map\n",
"m"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Add a new Sampling Feature\n",
"Just to llustrate how to add a new entry. We won't \"commit\" (save) the sampling feature to the database."
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"New sampling feature created, but not saved to database.\n",
"\n",
"\n"
]
}
],
"source": [
"sitesf0 = siteFeatures[0]\n",
"\n",
"try:\n",
" newsf = SamplingFeatures()\n",
" session = session_factory.getSession()\n",
" newsf.FeatureGeometryWKT = \"POINT(-111.946 41.718)\"\n",
" newsf.Elevation_m = 100\n",
" newsf.ElevationDatumCV = sitesf0.ElevationDatumCV\n",
" newsf.SamplingFeatureCode = \"TestSF\"\n",
" newsf.SamplingFeatureDescription = \"this is a test to add a sampling feature\"\n",
" newsf.SamplingFeatureGeotypeCV = \"Point\"\n",
" newsf.SamplingFeatureTypeCV = sitesf0.SamplingFeatureTypeCV\n",
" newsf.SamplingFeatureUUID = sitesf0.SamplingFeatureUUID+\"2\"\n",
" session.add(newsf)\n",
" # To save the new sampling feature, do session.commit()\n",
" print(\"New sampling feature created, but not saved to database.\\n\")\n",
" print(newsf)\n",
"except Exception as e :\n",
" print(\"error adding a sampling feature: {}\".format(e))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Get Objects and Related Objects from the Database (SamplingFeatures example)\n",
"\n",
"This code shows some examples of how objects and related objects can be retrieved using the API. In the following, we use the **getSamplingFeatures( )** function to return a particular sampling feature by passing in its SamplingFeatureCode. This function returns a list of SamplingFeature objects, so just get the first one in the returned list."
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"odm2api.models.Sites"
]
},
"execution_count": 18,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Get the SamplingFeature object for a particular SamplingFeature by passing its SamplingFeatureCode\n",
"sf = read.getSamplingFeatures(codes=['RB_1300E'])[0]\n",
"type(sf)"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"{'ElevationDatumCV': u'EGM96',\n",
" 'Elevation_m': 1356.0,\n",
" 'FeatureGeometryWKT': None,\n",
" 'Latitude': 40.745078,\n",
" 'Longitude': -111.854449,\n",
" 'SamplingFeatureCode': u'RB_1300E',\n",
" 'SamplingFeatureDescription': None,\n",
" 'SamplingFeatureGeotypeCV': None,\n",
" 'SamplingFeatureID': 1,\n",
" 'SamplingFeatureName': u'Red Butte Creek at 1300E (downstream of spring)',\n",
" 'SamplingFeatureTypeCV': u'Site',\n",
" 'SamplingFeatureUUID': u'0DDE8EF6-EC2F-42C0-AB50-20C6C02E89B2',\n",
" 'SiteTypeCV': u'Stream',\n",
" 'SpatialReferenceID': 1,\n",
" '_sa_instance_state': }"
]
},
"execution_count": 19,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Simple way to examine the content (properties) of a Python object, as if it were a dictionary\n",
"vars(sf)"
]
},
{
"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 \"Measurement\" Result), I also get the associated Action that created that Result (e.g., a \"Specimen analysis\" Action)."
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"('The FeatureAction object for the Result is: ', )\n",
"('The Action object for the Result is: ', )\n",
"\n",
"The following are some of the attributes for the Action that created the Result: \n",
"ActionTypeCV: Specimen analysis\n",
"ActionDescription: None\n",
"BeginDateTime: 2014-10-30 00:00:00\n",
"EndDateTime: None\n",
"MethodName: Astoria Total Phosphorus\n",
"MethodDescription: Determination of total phosphorus by persulphate oxidation digestion and ascorbic acid method\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 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": [
"### 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": 21,
"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: Measurement\n",
"ValueCount: 1\n",
"ProcessingLevel: Raw Data\n",
"SampledMedium: Liquid aqueous\n",
"Variable: TP: Phosphorus, total\n",
"Units: milligrams per liter\n",
"SamplingFeatureID: 26\n",
"SamplingFeatureCode: 3\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(\"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": [
"The last block of code returns a particular Measurement Result. From that I can get the SamplingFeaureID (in this case 26) for the Specimen from which the Result was generated. But, if I want to figure out which Site the Specimen was collected at, I need to query the database to get the related Site SamplingFeature. I can use **getRelatedSamplingFeatures( )** for this. Once I've got the SamplingFeature for the Site, I could get the rest of the SamplingFeature attributes."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Retrieve the \"Related\" Site at which a Specimen was collected"
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {},
"outputs": [],
"source": [
"# Pass the Sampling Feature ID of the specimen, and the relationship type\n",
"relatedSite = read.getRelatedSamplingFeatures(sfid=26, relationshiptype='Was Collected at')[0]"
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"{'ElevationDatumCV': u'EGM96',\n",
" 'Elevation_m': 1356.0,\n",
" 'FeatureGeometryWKT': None,\n",
" 'Latitude': 40.745078,\n",
" 'Longitude': -111.854449,\n",
" 'SamplingFeatureCode': u'RB_1300E',\n",
" 'SamplingFeatureDescription': None,\n",
" 'SamplingFeatureGeotypeCV': None,\n",
" 'SamplingFeatureID': 1,\n",
" 'SamplingFeatureName': u'Red Butte Creek at 1300E (downstream of spring)',\n",
" 'SamplingFeatureTypeCV': u'Site',\n",
" 'SamplingFeatureUUID': u'0DDE8EF6-EC2F-42C0-AB50-20C6C02E89B2',\n",
" 'SiteTypeCV': u'Stream',\n",
" 'SpatialReferenceID': 1,\n",
" '_sa_instance_state': }"
]
},
"execution_count": 23,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"vars(relatedSite)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"-----------------------------------------\n",
"\n",
"## Return Results and Data Values for a Particular Site/Variable\n",
"\n",
"From the list of Variables returned above and the information about the SamplingFeature I queried above, I know that VariableID = 2 for Total Phosphorus and SiteID = 1 for the Red Butte Creek site at 1300E. I can use the **getResults( )** function to get all of the Total Phosphorus results for this site by passing in the VariableID and the SiteID."
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {},
"outputs": [],
"source": [
"siteID = 1 # Red Butte Creek at 1300 E (obtained from the getRelatedSamplingFeatures query)"
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"18"
]
},
"execution_count": 25,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"v = variables_df[variables_df['VariableCode'] == 'TP']\n",
"variableID = v.index[0]\n",
"\n",
"results = read.getResults(siteid=siteID, variableid=variableID, restype=\"Measurement\")\n",
"# Get the list of ResultIDs so I can retrieve the data values associated with all of the results\n",
"resultIDList = [x.ResultID for x in results]\n",
"len(resultIDList)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Retrieve the Result (Data) Values, Then Create a Quick Time Series Plot of the Data\n",
"\n",
"Now I can retrieve all of the data values associated with the list of Results I just retrieved. In ODM2, water chemistry measurements are stored as \"Measurement\" results. Each \"Measurement\" Result has a single data value associated with it. So, for convenience, the **getResultValues( )** function allows you to pass in a list of ResultIDs so you can get the data values for all of them back in a Pandas data frame object, which is easier to work with. Once I've got the data in a Pandas data frame object, I can use the **plot( )** function directly on the data frame to create a quick visualization."
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"
\n",
"\n",
"
\n",
" \n",
"
\n",
"
\n",
"
ValueID
\n",
"
ResultID
\n",
"
DataValue
\n",
"
ValueDateTime
\n",
"
ValueDateTimeUTCOffset
\n",
"
\n",
" \n",
" \n",
"
\n",
"
0
\n",
"
1
\n",
"
1
\n",
"
0.0100
\n",
"
2015-10-27 13:26:24
\n",
"
-7
\n",
"
\n",
"
\n",
"
1
\n",
"
100
\n",
"
1
\n",
"
0.0100
\n",
"
2015-11-17 13:55:12
\n",
"
-7
\n",
"
\n",
"
\n",
"
2
\n",
"
109
\n",
"
10
\n",
"
0.0574
\n",
"
2015-05-12 14:24:00
\n",
"
-7
\n",
"
\n",
"
\n",
"
3
\n",
"
10
\n",
"
10
\n",
"
0.0574
\n",
"
2015-06-18 12:43:12
\n",
"
-7
\n",
"
\n",
"
\n",
"
4
\n",
"
198
\n",
"
99
\n",
"
0.0424
\n",
"
2015-10-27 13:55:12
\n",
"
-7
\n",
"
\n",
" \n",
"
\n",
"
"
],
"text/plain": [
" 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": 26,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# 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.head()"
]
},
{
"cell_type": "code",
"execution_count": 27,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
"