{ "cells": [ { "cell_type": "markdown", "id": "0b4bc9c4-efaf-4fef-bd9f-b87a4b611c5c", "metadata": {}, "source": [ "# Filtering through queries\n", "\n", "## Authors\n", "\n", "[Deborah Khider](https://orcid.org/0000-0001-7501-8430)\n", "\n", "## Preamble\n", "\n", "`PyLiPD` is a Python package that allows you to read, manipulate, and write [LiPD](https://doi.org/10.5194/cp-12-1093-2016) formatted datasets. In this tutorial, we will demonstrate how to use pre-defined filtering capabilities through APIs. \n", "\n", "
\n", "Note: These capabilities are under heavy development. If you are interested in other filtering capabilities to help with your science, please open an issue.\n", "
\n", "\n", "### Goals\n", "\n", "* Use existing APIs to filter datasets according to archive types, location and variable names.\n", "* Understand the concept of a `LiPDSeries` object and how it differs from `LiPD` object.\n", "\n", "Reading Time: 5 minutes\n", "\n", "### Keywords\n", "\n", "LiPD\n", "\n", "### Pre-requisites\n", "\n", "* This tutorial assumes basic knowledge of Python and Pandas. If you are not familiar with this coding language and this particular library, check out this tutorial: http://linked.earth/ec_workshops_py/.\n", "* [Retrieving Information from LiPD files](L1_getting_information.md)\n", "\n", "### Relevant Packages\n", "\n", "pylipd\n", "\n", "## Data Description\n", "\n", "This notebook uses the following datasets, in LiPD format:\n", "\n", "- Euro2k database: PAGES2k Consortium (2017), A global multiproxy database for temperature reconstructions of the Common Era. Sci Data 4, 170088. doi:10.1038/sdata.2017.88\n", "\n", "## Demonstration\n", "\n", "### Filtering on the `LiPD` object\n", "\n", "#### Filtering by the type of archive\n", "\n", "Let's start by importing our favorite package and load our datasets. " ] }, { "cell_type": "code", "execution_count": 1, "id": "b21a893e-73d2-4709-ae55-ea5cb199564c", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Loading 16 LiPD files\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "100%|██████████████████████████████████████████████████████████████████| 16/16 [00:00<00:00, 85.90it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Loaded..\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "\n" ] } ], "source": [ "from pylipd.lipd import LiPD\n", "\n", "path = '../data/Pages2k/'\n", "\n", "D = LiPD()\n", "D.load_from_dir(path)" ] }, { "cell_type": "markdown", "id": "c51ef11a-3661-4b4c-89a0-a84469a28064", "metadata": {}, "source": [ "And let's get a list of available datasets so we can compare the results as we filter using various criteria:" ] }, { "cell_type": "code", "execution_count": 2, "id": "d4795d91-85cf-4b24-902c-7b0f3725c3e9", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['Ocn-RedSea.Felis.2000',\n", " 'Ant-WAIS-Divide.Severinghaus.2012',\n", " 'Asi-SourthAndMiddleUrals.Demezhko.2007',\n", " 'Ocn-AlboranSea436B.Nieto-Moreno.2013',\n", " 'Eur-SpannagelCave.Mangini.2005',\n", " 'Ocn-FeniDrift.Richter.2009',\n", " 'Eur-LakeSilvaplana.Trachsel.2010',\n", " 'Ocn-PedradeLume-CapeVerdeIslands.Moses.2006',\n", " 'Ocn-SinaiPeninsula_RedSea.Moustafa.2000',\n", " 'Eur-NorthernSpain.Martin-Chivelet.2011',\n", " 'Arc-Kongressvatnet.D_Andrea.2012',\n", " 'Eur-CoastofPortugal.Abrantes.2011',\n", " 'Eur-SpanishPyrenees.Dorado-Linan.2012',\n", " 'Eur-FinnishLakelands.Helama.2014',\n", " 'Eur-NorthernScandinavia.Esper.2012',\n", " 'Eur-Stockholm.Leijonhufvud.2009']" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "D.get_all_dataset_names()" ] }, { "cell_type": "markdown", "id": "a9d25b81-3dcb-458c-b85d-ebda2c7de751", "metadata": {}, "source": [ "Now let's look at the available types of archives for which we can filter:" ] }, { "cell_type": "code", "execution_count": 3, "id": "06621bc9-b289-4954-b48b-4cd8791fcd65", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['Coral',\n", " 'Borehole',\n", " 'Marine sediment',\n", " 'Speleothem',\n", " 'Lake sediment',\n", " 'Wood',\n", " 'Documents']" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "D.get_all_archiveTypes()" ] }, { "cell_type": "markdown", "id": "f029fada-3fa6-4e69-bfdf-66e0d045ef79", "metadata": {}, "source": [ "Let's first filter for speleothem records:" ] }, { "cell_type": "code", "execution_count": 4, "id": "b0ee53c0-e992-4623-895a-20454a57a09b", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['Eur-SpannagelCave.Mangini.2005', 'Eur-NorthernSpain.Martin-Chivelet.2011']" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "D_speleothem = D.filter_by_archive_type('speleothem')\n", "\n", "D_speleothem.get_all_dataset_names()" ] }, { "cell_type": "markdown", "id": "6406943e-d454-4a76-8de5-408e82077d5a", "metadata": {}, "source": [ "The function uses [regular expressions](https://learn.microsoft.com/en-us/dotnet/standard/base-types/regular-expression-language-quick-reference) to do partial matches. Therefore, you can look for all the datasets based on marine sediments using:" ] }, { "cell_type": "code", "execution_count": 5, "id": "cbea64a8-094d-4b2a-8c01-a60a75522f23", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['Eur-CoastofPortugal.Abrantes.2011',\n", " 'Ocn-AlboranSea436B.Nieto-Moreno.2013',\n", " 'Ocn-FeniDrift.Richter.2009']" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "D_marine = D.filter_by_archive_type('marine')\n", "\n", "D_marine.get_all_dataset_names()" ] }, { "cell_type": "markdown", "id": "f63e7b27-4c0f-4443-9f94-b3311f6a4656", "metadata": {}, "source": [ "However, looking for `sediment` will return records based on both marine and lake sediments:" ] }, { "cell_type": "code", "execution_count": 6, "id": "0be13599-cf87-4027-b12d-ad58e4e4791d", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['Eur-CoastofPortugal.Abrantes.2011',\n", " 'Arc-Kongressvatnet.D_Andrea.2012',\n", " 'Ocn-AlboranSea436B.Nieto-Moreno.2013',\n", " 'Eur-LakeSilvaplana.Trachsel.2010',\n", " 'Ocn-FeniDrift.Richter.2009']" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "D_sediment = D.filter_by_archive_type('sediment')\n", "\n", "D_sediment.get_all_dataset_names()" ] }, { "cell_type": "code", "execution_count": 7, "id": "129ae5fa-e124-464a-8290-73dadcb836c7", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['Ocn-FeniDrift.Richter.2009',\n", " 'Eur-CoastofPortugal.Abrantes.2011',\n", " 'Ocn-AlboranSea436B.Nieto-Moreno.2013',\n", " 'Eur-NorthernSpain.Martin-Chivelet.2011',\n", " 'Eur-SpannagelCave.Mangini.2005']" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "D_marinespeleo = D.filter_by_archive_type('(marine|speleothem)')\n", "\n", "D_marinespeleo.get_all_dataset_names()" ] }, { "cell_type": "markdown", "id": "a6a941f7-94df-4a10-a6bc-91d23fc2897f", "metadata": {}, "source": [ "If you are not comfortable with regular expression and constructing patterns as we have done above, you can always merge two `LiPD` objects as we demonstrated [previously](L0_loading_lipd_datasets.ipynb). Therefore, the filtering above can also be achieved by combining our previous objects:" ] }, { "cell_type": "code", "execution_count": 7, "id": "30e20778-66f0-4b76-91e7-2d7c6fb32e22", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['Eur-CoastofPortugal.Abrantes.2011',\n", " 'Ocn-AlboranSea436B.Nieto-Moreno.2013',\n", " 'Ocn-FeniDrift.Richter.2009',\n", " 'Eur-SpannagelCave.Mangini.2005',\n", " 'Eur-NorthernSpain.Martin-Chivelet.2011']" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "D_merged = D_marine.merge(D_speleothem)\n", "\n", "D_merged.get_all_dataset_names()" ] }, { "cell_type": "markdown", "id": "a138f8b0-1092-469c-a3b1-cda2d47a0788", "metadata": {}, "source": [ "#### Filtering by location\n", "\n", "Let's filter using a [bounding box](https://pylipd.readthedocs.io/en/latest/source/pylipd.html#pylipd.lipd.LiPD.filter_by_geo_bbox) between 40-70N and 0-90E:" ] }, { "cell_type": "code", "execution_count": 9, "id": "ddea410f-b228-475c-9a0b-7741f84fb7fe", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['Eur-SpanishPyrenees.Dorado-Linan.2012',\n", " 'Eur-NorthernScandinavia.Esper.2012',\n", " 'Eur-SpannagelCave.Mangini.2005',\n", " 'Asi-SourthAndMiddleUrals.Demezhko.2007',\n", " 'Eur-FinnishLakelands.Helama.2014',\n", " 'Eur-Stockholm.Leijonhufvud.2009',\n", " 'Eur-LakeSilvaplana.Trachsel.2010']" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "D_geo = D.filter_by_geo_bbox(lonMin=0, latMin=40, lonMax=90, latMax=70)\n", "\n", "D_geo.get_all_dataset_names()" ] }, { "cell_type": "markdown", "id": "c0eefa0b-c356-47d0-b546-c5bf5d1dc91e", "metadata": {}, "source": [ "Because `PyLiPD` uses object-oriented programming, we can take advantage of method cascading to create a series of filters. For instance, let's assume that we want all the datasets between 40-70N and 0-90E that are trees. One can write an additional query on top of the location query that we just performed:" ] }, { "cell_type": "code", "execution_count": 10, "id": "627ba50d-aa6f-4933-88fc-521867d0ba0a", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['Eur-NorthernScandinavia.Esper.2012',\n", " 'Eur-SpanishPyrenees.Dorado-Linan.2012',\n", " 'Eur-FinnishLakelands.Helama.2014']" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "D_geotree = D_geo.filter_by_archive_type('wood')\n", "\n", "D_geotree.get_all_dataset_names()" ] }, { "cell_type": "markdown", "id": "33f21606-bdbd-4f27-9fd5-40a304b76076", "metadata": {}, "source": [ "Using method cascading, you can write this in a single query:" ] }, { "cell_type": "code", "execution_count": 11, "id": "c86226a3-802e-4042-9b93-202c6ac8e963", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['Eur-NorthernScandinavia.Esper.2012',\n", " 'Eur-SpanishPyrenees.Dorado-Linan.2012',\n", " 'Eur-FinnishLakelands.Helama.2014']" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "D_filt = D.filter_by_geo_bbox(lonMin=0, latMin=40, lonMax=90, latMax=70).filter_by_archive_type('wood')\n", "\n", "D_filt.get_all_dataset_names()" ] }, { "attachments": { "4b57db62-b3ab-4f97-a602-b5918b3080ce.png": { "image/png": "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" } }, "cell_type": "markdown", "id": "6fafe5db-99c4-4f0a-9cda-a9dca508c9d9", "metadata": {}, "source": [ "#### Filtering by time interval\n", "\n", "The [`.filter_by_time`](https://pylipd.readthedocs.io/en/latest/api.html#pylipd.lipd.LiPD.filter_by_time) method allows you to filter for a specific interval and a matching record length within that interval. The function takes three arguments:\n", "- `timeBound` (*mandatory*): A list of the minimum and maximum time to consider\n", "- `timeBoundType` (*optional*): As defined by the World Data Service for Paleoclimatology and an Applied Research Service for Paleoclimatology.\n", " ![image.png](attachment:4b57db62-b3ab-4f97-a602-b5918b3080ce.png)\n", "Default is `any`. \n", "- `recordLength`(*optional*): The minimum length of the record within the time interval.\n", "\n", "
Warning

\n", "As of August 2024, the function does not reason over time representation (i.e., BP vs CE) nor units (e.g., yr vs kyr). Make sure that all LiPD in your object have the same time representation and units before using this function.\n", "
\n", "\n", "Let's filter over the period [500,1800], using default settings:" ] }, { "cell_type": "code", "execution_count": 15, "id": "91f6b267-4acc-49db-aa40-912bae931d75", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "There are 13.0 number of records matching this query.\n" ] } ], "source": [ "D_filt_time1 = D.filter_by_time([500,1800])\n", "\n", "\n", "num_records = float(len(D_filt_time1.get_all_dataset_names()))\n", "print(f\"There are {num_records} number of records matching this query.\")" ] }, { "cell_type": "markdown", "id": "91ec2072-012c-4900-8135-a4dcc27196bf", "metadata": {}, "source": [ "Let's compare to the number of records we would get if we asked for `entirely`:" ] }, { "cell_type": "code", "execution_count": 16, "id": "73e1a578-e269-421e-8e1b-65cf9b4ba8be", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "There are 5.0 number of records matching this query.\n" ] } ], "source": [ "D_filt_time2 = D.filter_by_time([500,1800], timeBoundType = 'entirely')\n", "\n", "\n", "num_records = float(len(D_filt_time2.get_all_dataset_names()))\n", "print(f\"There are {num_records} number of records matching this query.\")" ] }, { "cell_type": "markdown", "id": "03c8b38c-6d10-44e0-81a4-3ea1702c87d5", "metadata": {}, "source": [ "A lot less records match this search criteria, which is not surprising since only records fully covering the 500-1800 period are considered. Note that when `entirely` is selected, the `recordLength` parameter has no effect. " ] }, { "cell_type": "markdown", "id": "051ea2fe-8bd1-4c59-91d6-f8de03557f6b", "metadata": {}, "source": [ "### Filtering on the `LiPDSeries` object\n", "\n", "#### Filtering by variable names\n", "\n", "Most of the time, we are interested in working with specific variables in a LiPD file. To use filtering capabilities, this requires expanding the `LiPD` object into a `LiPDSeries` object, which contains individual variables. You can do so by using the following function, applied on the filtered database of tree records from high northern latitudes: " ] }, { "cell_type": "code", "execution_count": 18, "id": "4cae7cda-6099-4e68-bdea-086651e5fc79", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Creating LiPD Series...\n", "- Extracting dataset subgraphs\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "100%|███████████████████████████████████████████████████████████████████| 3/3 [00:00<00:00, 232.86it/s]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "- Extracting variable subgraphs\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "100%|████████████████████████████████████████████████████████████████████| 3/3 [00:00<00:00, 31.10it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Done..\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "\n" ] } ], "source": [ "ts = D_filt.to_lipd_series()" ] }, { "cell_type": "markdown", "id": "2d9f6c4d-6d77-4dbd-a6fb-085d878aea19", "metadata": {}, "source": [ "Let's have a look at what we have by placing essential metadata into a Pandas DataFrame. This function is the equivalent to `LiPD.get_timeseries_essentials` with slight differences:" ] }, { "cell_type": "code", "execution_count": 21, "id": "de63aa23-99fb-43d2-8cd4-8d11198a45b8", "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
dataSetNamearchiveTypenameTSIDvaluesunitsproxy
0Eur-NorthernScandinavia.Esper.2012WoodyearPYTECO66XAD[-138, -137, -136, -135, -134, -133, -132, -13...yr ADNone
1Eur-NorthernScandinavia.Esper.2012WoodMXDEur_014[0.46, 1.305, 0.755, -0.1, -0.457, 1.62, 0.765...NoneNone
2Eur-SpanishPyrenees.Dorado-Linan.2012WoodtrsgiEur_020[-1.612, -0.703, -0.36, -0.767, -0.601, -0.733...NoneNone
3Eur-SpanishPyrenees.Dorado-Linan.2012WoodyearPYT2K8MIA3N[1260, 1261, 1262, 1263, 1264, 1265, 1266, 126...yr ADNone
4Eur-FinnishLakelands.Helama.2014WoodtemperatureEur_005[14.603, 14.643, 12.074, 13.898, 13.671, 13.41...degCNone
\n", "
" ], "text/plain": [ " dataSetName archiveType name \\\n", "0 Eur-NorthernScandinavia.Esper.2012 Wood year \n", "1 Eur-NorthernScandinavia.Esper.2012 Wood MXD \n", "2 Eur-SpanishPyrenees.Dorado-Linan.2012 Wood trsgi \n", "3 Eur-SpanishPyrenees.Dorado-Linan.2012 Wood year \n", "4 Eur-FinnishLakelands.Helama.2014 Wood temperature \n", "\n", " TSID values units proxy \n", "0 PYTECO66XAD [-138, -137, -136, -135, -134, -133, -132, -13... yr AD None \n", "1 Eur_014 [0.46, 1.305, 0.755, -0.1, -0.457, 1.62, 0.765... None None \n", "2 Eur_020 [-1.612, -0.703, -0.36, -0.767, -0.601, -0.733... None None \n", "3 PYT2K8MIA3N [1260, 1261, 1262, 1263, 1264, 1265, 1266, 126... yr AD None \n", "4 Eur_005 [14.603, 14.643, 12.074, 13.898, 13.671, 13.41... degC None " ] }, "execution_count": 21, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df = ts.get_timeseries_essentials()\n", "\n", "df.head()" ] }, { "cell_type": "markdown", "id": "ca2f61e6-29b5-4852-ad1c-e2df74ac5b28", "metadata": {}, "source": [ "As you can see, the DataFrame contains much of the same information, except for location. This is because that information is stored at the Dataset level in LiPD and is, therefore, attached to the `LiPD` object. But you can merge the data using [Pandas' capabilities](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.merge.html). First, let's get the location information:" ] }, { "cell_type": "code", "execution_count": 14, "id": "d9ab7663-97f5-4ece-9b2b-1233fb5b8c9a", "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
dataSetNamegeo_meanLatgeo_meanLongeo_meanElev
0Eur-SpanishPyrenees.Dorado-Linan.201242.51.0001200.0
1Eur-NorthernScandinavia.Esper.201268.025.000300.0
2Eur-FinnishLakelands.Helama.201462.028.325130.0
\n", "
" ], "text/plain": [ " dataSetName geo_meanLat geo_meanLon \\\n", "0 Eur-SpanishPyrenees.Dorado-Linan.2012 42.5 1.000 \n", "1 Eur-NorthernScandinavia.Esper.2012 68.0 25.000 \n", "2 Eur-FinnishLakelands.Helama.2014 62.0 28.325 \n", "\n", " geo_meanElev \n", "0 1200.0 \n", "1 300.0 \n", "2 130.0 " ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df_loc = D_filt.get_all_locations()\n", "\n", "df_loc.head()" ] }, { "cell_type": "code", "execution_count": 15, "id": "99af25fd-c7a2-48be-b602-7c308535cddf", "metadata": {}, "outputs": [], "source": [ "import pandas as pd" ] }, { "cell_type": "markdown", "id": "129f62da-306a-4aad-9b0f-751f911dd726", "metadata": {}, "source": [ "We can use the [`.merge`](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.merge.html) functionality in Pandas to achieve our goal. This functionality is very similar to `join` in SQL. The main arguments are `how` which defines how the join is achieved and `on` which specifies the column:\n", "\n", "`how`: {‘left’, ‘right’, ‘outer’, ‘inner’, ‘cross’}, default ‘inner’\n", "\n", "* left: use only keys from left frame, similar to a SQL left outer join; preserve key order.\n", "* right: use only keys from right frame, similar to a SQL right outer join; preserve key order.\n", "* outer: use union of keys from both frames, similar to a SQL full outer join; sort keys lexicographically.\n", "* inner: use intersection of keys from both frames, similar to a SQL inner join; preserve the order of the left keys.\n", "* cross: creates the cartesian product from both frames, preserves the order of the left keys." ] }, { "cell_type": "code", "execution_count": 16, "id": "b8c6579c-112a-4a97-9a1b-01198685ac38", "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
dataSetNamearchiveTypenameTSIDvaluesunitsproxygeo_meanLatgeo_meanLongeo_meanElev
0Eur-NorthernScandinavia.Esper.2012treeyearPYTECO66XAD[-138, -137, -136, -135, -134, -133, -132, -13...yr ADNone68.025.000300.0
1Eur-NorthernScandinavia.Esper.2012treeMXDEur_014[0.46, 1.305, 0.755, -0.1, -0.457, 1.62, 0.765...NoneNone68.025.000300.0
2Eur-FinnishLakelands.Helama.2014treeyearPYTUSB62S0A[2000, 1999, 1998, 1997, 1996, 1995, 1994, 199...yr ADNone62.028.325130.0
3Eur-FinnishLakelands.Helama.2014treetemperatureEur_005[14.603, 14.643, 12.074, 13.898, 13.671, 13.41...degCNone62.028.325130.0
4Eur-SpanishPyrenees.Dorado-Linan.2012treeyearPYT2K8MIA3N[1260, 1261, 1262, 1263, 1264, 1265, 1266, 126...yr ADNone42.51.0001200.0
\n", "
" ], "text/plain": [ " dataSetName archiveType name \\\n", "0 Eur-NorthernScandinavia.Esper.2012 tree year \n", "1 Eur-NorthernScandinavia.Esper.2012 tree MXD \n", "2 Eur-FinnishLakelands.Helama.2014 tree year \n", "3 Eur-FinnishLakelands.Helama.2014 tree temperature \n", "4 Eur-SpanishPyrenees.Dorado-Linan.2012 tree year \n", "\n", " TSID values units \\\n", "0 PYTECO66XAD [-138, -137, -136, -135, -134, -133, -132, -13... yr AD \n", "1 Eur_014 [0.46, 1.305, 0.755, -0.1, -0.457, 1.62, 0.765... None \n", "2 PYTUSB62S0A [2000, 1999, 1998, 1997, 1996, 1995, 1994, 199... yr AD \n", "3 Eur_005 [14.603, 14.643, 12.074, 13.898, 13.671, 13.41... degC \n", "4 PYT2K8MIA3N [1260, 1261, 1262, 1263, 1264, 1265, 1266, 126... yr AD \n", "\n", " proxy geo_meanLat geo_meanLon geo_meanElev \n", "0 None 68.0 25.000 300.0 \n", "1 None 68.0 25.000 300.0 \n", "2 None 62.0 28.325 130.0 \n", "3 None 62.0 28.325 130.0 \n", "4 None 42.5 1.000 1200.0 " ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df_merged = df.merge(df_loc,how='inner', on='dataSetName')\n", "\n", "df_merged.head()" ] }, { "cell_type": "markdown", "id": "ffb12f98-221a-48a7-ba60-3083262f19b7", "metadata": {}, "source": [ "The second difference is that the variables representing time are only present as rows, which means that time will need to be associated with the variables. To do so, you can use the filtering capabilities. First, let's filter for `temperature` and `trsgi`:" ] }, { "cell_type": "code", "execution_count": 17, "id": "b7cae044-ce43-4ac5-9421-ac065d98ee56", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "2\n" ] }, { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
dataSetNamearchiveTypenameTSIDvaluesunitsproxy
0Eur-SpanishPyrenees.Dorado-Linan.2012treetrsgiEur_020[-1.612, -0.703, -0.36, -0.767, -0.601, -0.733...NoneNone
1Eur-FinnishLakelands.Helama.2014treetemperatureEur_005[14.603, 14.643, 12.074, 13.898, 13.671, 13.41...degCNone
\n", "
" ], "text/plain": [ " dataSetName archiveType name TSID \\\n", "0 Eur-SpanishPyrenees.Dorado-Linan.2012 tree trsgi Eur_020 \n", "1 Eur-FinnishLakelands.Helama.2014 tree temperature Eur_005 \n", "\n", " values units proxy \n", "0 [-1.612, -0.703, -0.36, -0.767, -0.601, -0.733... None None \n", "1 [14.603, 14.643, 12.074, 13.898, 13.671, 13.41... degC None " ] }, "execution_count": 17, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ts_filter = ts.filter_by_name('(temperature|trsgi)')\n", "\n", "df_paleo = ts_filter.get_timeseries_essentials()\n", "df_paleo.head()" ] }, { "cell_type": "markdown", "id": "e34d45c1-3872-470b-aa81-efdbb975ee61", "metadata": {}, "source": [ "Our next task is to get all the information regarding time. Let's use method chaining to get the DataFrame directly:" ] }, { "cell_type": "code", "execution_count": 18, "id": "14840800-69d7-450f-bc7b-c8d3a337c278", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "3\n" ] }, { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
dataSetNamearchiveTypenameTSIDvaluesunitsproxy
0Eur-SpanishPyrenees.Dorado-Linan.2012treeyearPYT2K8MIA3N[1260, 1261, 1262, 1263, 1264, 1265, 1266, 126...yr ADNone
1Eur-FinnishLakelands.Helama.2014treeyearPYTUSB62S0A[2000, 1999, 1998, 1997, 1996, 1995, 1994, 199...yr ADNone
2Eur-NorthernScandinavia.Esper.2012treeyearPYTECO66XAD[-138, -137, -136, -135, -134, -133, -132, -13...yr ADNone
\n", "
" ], "text/plain": [ " dataSetName archiveType name TSID \\\n", "0 Eur-SpanishPyrenees.Dorado-Linan.2012 tree year PYT2K8MIA3N \n", "1 Eur-FinnishLakelands.Helama.2014 tree year PYTUSB62S0A \n", "2 Eur-NorthernScandinavia.Esper.2012 tree year PYTECO66XAD \n", "\n", " values units proxy \n", "0 [1260, 1261, 1262, 1263, 1264, 1265, 1266, 126... yr AD None \n", "1 [2000, 1999, 1998, 1997, 1996, 1995, 1994, 199... yr AD None \n", "2 [-138, -137, -136, -135, -134, -133, -132, -13... yr AD None " ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df_time = ts.filter_by_name('year').get_timeseries_essentials()\n", "\n", "df_time.head()" ] }, { "cell_type": "markdown", "id": "377da43a-7072-4614-bdb0-0b31c3f11f93", "metadata": {}, "source": [ "Now, we can use Pandas to merge the two DataFrames. In this case, we would expect that the DataFrame containing the time information would have more datasets associated with them (since not all datasets have a temoerature or trsgi value). Therefore, we want to perform a left join, dropping the unnecessary age information:" ] }, { "cell_type": "code", "execution_count": 19, "id": "cff534d5-38d1-406b-9ef7-4106a9087e71", "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
dataSetNamearchiveType_xname_xTSID_xvalues_xunits_xproxy_xarchiveType_yname_yTSID_yvalues_yunits_yproxy_y
0Eur-SpanishPyrenees.Dorado-Linan.2012treetrsgiEur_020[-1.612, -0.703, -0.36, -0.767, -0.601, -0.733...NoneNonetreeyearPYT2K8MIA3N[1260, 1261, 1262, 1263, 1264, 1265, 1266, 126...yr ADNone
1Eur-FinnishLakelands.Helama.2014treetemperatureEur_005[14.603, 14.643, 12.074, 13.898, 13.671, 13.41...degCNonetreeyearPYTUSB62S0A[2000, 1999, 1998, 1997, 1996, 1995, 1994, 199...yr ADNone
\n", "
" ], "text/plain": [ " dataSetName archiveType_x name_x TSID_x \\\n", "0 Eur-SpanishPyrenees.Dorado-Linan.2012 tree trsgi Eur_020 \n", "1 Eur-FinnishLakelands.Helama.2014 tree temperature Eur_005 \n", "\n", " values_x units_x proxy_x \\\n", "0 [-1.612, -0.703, -0.36, -0.767, -0.601, -0.733... None None \n", "1 [14.603, 14.643, 12.074, 13.898, 13.671, 13.41... degC None \n", "\n", " archiveType_y name_y TSID_y \\\n", "0 tree year PYT2K8MIA3N \n", "1 tree year PYTUSB62S0A \n", "\n", " values_y units_y proxy_y \n", "0 [1260, 1261, 1262, 1263, 1264, 1265, 1266, 126... yr AD None \n", "1 [2000, 1999, 1998, 1997, 1996, 1995, 1994, 199... yr AD None " ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df_filt_merge=df_paleo.merge(df_time,how='left',on='dataSetName')\n", "\n", "df_filt_merge" ] }, { "cell_type": "markdown", "id": "583cd412-1fc7-4415-a1d8-2633a07b9135", "metadata": {}, "source": [ "Notice the Pandas automatically changed the names of the columns to accomodate the fact that both our DataFrames had the same column names. Now let's add the location information with another left join:" ] }, { "cell_type": "code", "execution_count": 20, "id": "895ab59f-42ff-4b93-a0fc-2fb6fafa030b", "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
dataSetNamearchiveType_xname_xTSID_xvalues_xunits_xproxy_xarchiveType_yname_yTSID_yvalues_yunits_yproxy_ygeo_meanLatgeo_meanLongeo_meanElev
0Eur-SpanishPyrenees.Dorado-Linan.2012treetrsgiEur_020[-1.612, -0.703, -0.36, -0.767, -0.601, -0.733...NoneNonetreeyearPYT2K8MIA3N[1260, 1261, 1262, 1263, 1264, 1265, 1266, 126...yr ADNone42.51.0001200.0
1Eur-FinnishLakelands.Helama.2014treetemperatureEur_005[14.603, 14.643, 12.074, 13.898, 13.671, 13.41...degCNonetreeyearPYTUSB62S0A[2000, 1999, 1998, 1997, 1996, 1995, 1994, 199...yr ADNone62.028.325130.0
\n", "
" ], "text/plain": [ " dataSetName archiveType_x name_x TSID_x \\\n", "0 Eur-SpanishPyrenees.Dorado-Linan.2012 tree trsgi Eur_020 \n", "1 Eur-FinnishLakelands.Helama.2014 tree temperature Eur_005 \n", "\n", " values_x units_x proxy_x \\\n", "0 [-1.612, -0.703, -0.36, -0.767, -0.601, -0.733... None None \n", "1 [14.603, 14.643, 12.074, 13.898, 13.671, 13.41... degC None \n", "\n", " archiveType_y name_y TSID_y \\\n", "0 tree year PYT2K8MIA3N \n", "1 tree year PYTUSB62S0A \n", "\n", " values_y units_y proxy_y \\\n", "0 [1260, 1261, 1262, 1263, 1264, 1265, 1266, 126... yr AD None \n", "1 [2000, 1999, 1998, 1997, 1996, 1995, 1994, 199... yr AD None \n", "\n", " geo_meanLat geo_meanLon geo_meanElev \n", "0 42.5 1.000 1200.0 \n", "1 62.0 28.325 130.0 " ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df_filt_merge_loc=df_filt_merge.merge(df_loc,how='left',on='dataSetName')\n", "\n", "df_filt_merge_loc.head()" ] }, { "cell_type": "markdown", "id": "0001359a-9cab-4422-9cec-d89ac262256f", "metadata": {}, "source": [ "#### Filtering by proxy\n", "\n", "LiPD files have a `proxy` field that can be used to associate the proxy used for the inference or measurements. On the LiPDVerse, this field is [standardized](https://lipdverse.org/vocabulary/paleodata_proxy/).\n", "\n", "To get a list of all proxies available in the `LiPDSeries` object, first use the [`.get_all_proxy`](https://pylipd.readthedocs.io/en/latest/api.html#pylipd.lipd_series.LiPDSeries.get_all_proxy) method:" ] }, { "cell_type": "code", "execution_count": 24, "id": "42c550c4-42df-499b-b5fd-49639beb9565", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Creating LiPD Series...\n", "- Extracting dataset subgraphs\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "100%|█████████████████████████████████████████████████████████████████| 16/16 [00:00<00:00, 330.78it/s]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "- Extracting variable subgraphs\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "100%|██████████████████████████████████████████████████████████████████| 16/16 [00:00<00:00, 31.02it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Done..\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "\n" ] }, { "data": { "text/plain": [ "['ring width',\n", " 'maximum latewood density',\n", " 'd18O',\n", " 'alkenone',\n", " 'borehole',\n", " 'historical',\n", " 'reflectance',\n", " 'Mg/Ca']" ] }, "execution_count": 24, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ts_all = D.to_lipd_series()\n", "ts_all.get_all_proxy()" ] }, { "cell_type": "markdown", "id": "bd6e7972-39c4-4c2a-88cd-523a46cad097", "metadata": {}, "source": [ "Let's filter for the `ring width` proxy:" ] }, { "cell_type": "code", "execution_count": 25, "id": "781600c3-0fa6-4f66-ba99-5f4dc1badfbe", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['ring width']" ] }, "execution_count": 25, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ts_filt_proxy = ts_all.filter_by_proxy('ring width')\n", "\n", "ts_filt_proxy.get_all_proxy()" ] }, { "cell_type": "markdown", "id": "943fe0cf-aedd-4ef4-a81c-e94171e7c284", "metadata": {}, "source": [ "#### Filtering by resolution\n", "\n", "When a LiPD file is created the resolution is automatically calculated for each variable. This can be used to filter the records by either the mean, median, minimum and maximum resolution. To do so, you can use the [`.filter_by_resolution`](https://pylipd.readthedocs.io/en/latest/api.html#pylipd.lipd_series.LiPDSeries.filter_by_resolution) method. The `stats` parameter allows to set which one. " ] }, { "cell_type": "code", "execution_count": 26, "id": "7dd82f29-9245-4164-bf72-4fd2511ca7f4", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "There are 41 variables in this LiPDSeries object.\n" ] } ], "source": [ "print(f\"There are {len(ts_all.get_timeseries_essentials())} variables in this LiPDSeries object.\")" ] }, { "cell_type": "markdown", "id": "b0c70e01-ccf5-4be8-83ca-3b356c9ae8e9", "metadata": {}, "source": [ "Let's filter for a mean resolution of at least 10 years:" ] }, { "cell_type": "code", "execution_count": 29, "id": "9f029821-e87a-418c-9524-8a13eaad0a9e", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "There are 25 variables in this LiPDSeries object.\n" ] } ], "source": [ "ts_filt_meanres = ts_all.filter_by_resolution(10)\n", "\n", "print(f\"There are {len(ts_filt_meanres.get_timeseries_essentials())} variables in this LiPDSeries object.\")" ] }, { "cell_type": "markdown", "id": "bdb4ff72-f14e-40b9-85c3-915432088a3e", "metadata": {}, "source": [ "Let's redo this query with a median resolution of 10 years:" ] }, { "cell_type": "code", "execution_count": 31, "id": "ebf9d875-e444-4df1-808e-eb4e46ef3223", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "There are 25 variables in this LiPDSeries object.\n" ] } ], "source": [ "ts_filt_medres = ts_all.filter_by_resolution(10, stats = 'Median')\n", "\n", "print(f\"There are {len(ts_filt_medres.get_timeseries_essentials())} variables in this LiPDSeries object.\")" ] }, { "cell_type": "markdown", "id": "2916192a-e18b-4159-9be6-939c96a4cb9f", "metadata": {}, "source": [ "In this case, the mean or median did not seem to matter. " ] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.11.5" } }, "nbformat": 4, "nbformat_minor": 5 }