diff --git a/ci/environment.yml b/ci/environment.yml index fcb0e3ff..c299c98e 100644 --- a/ci/environment.yml +++ b/ci/environment.yml @@ -11,6 +11,7 @@ dependencies: - h5netcdf>=0.8.1 - intake>=0.6.0 - ipython + - matplotlib - netcdf4>=1.5.5 - pip - pooch diff --git a/docs/environment.yml b/docs/environment.yml index bb00625d..0e1e3eaa 100644 --- a/docs/environment.yml +++ b/docs/environment.yml @@ -13,6 +13,7 @@ dependencies: - sphinx-copybutton - sqlalchemy==1.3.12 - watermark + - python-graphviz - zarr - pip: - gcsfs diff --git a/docs/source/user-guide/ecgtools-history-files-example.ipynb b/docs/source/user-guide/ecgtools-history-files-example.ipynb new file mode 100644 index 00000000..4197dd4a --- /dev/null +++ b/docs/source/user-guide/ecgtools-history-files-example.ipynb @@ -0,0 +1,841 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "starting-spokesman", + "metadata": { + "tags": [] + }, + "source": [ + "# Building an Intake-esm catalog from CESM2 History Files\n", + "\n", + "In this example, we will cover how to build a data catalog from Community Earth System Model (CESM) output. One of the requirements for using intake-esm is having a catalog which is comprised of two pieces:\n", + "* A table of the relevant metadata (ex. file path, variable, stream, etc.)\n", + "* A json describing the dataset, including how to aggregate the variables\n", + "\n", + "Typically, these pieces are constructed \"manually\" using information within the file path, on a very ad-hoc basis. Also, these catalogs are typically only created for \"larger\", community datasets, not neccessarily used within smaller model runs/daily workflows. A new package (currently a prototype), called [ecgtools](https://ecgtools.readthedocs.io/en/latest/) works to solve the issues of generating these intake-esm catalogs. Ecgtools stands for Earth System Model (ESM) Catalog Generation tools. The current catalog generation tools supported are:\n", + "* CMIP6 models\n", + "* CESM \"history\" files\n", + "* CESM \"timeseries\" files\n", + "\n", + "This example provides an overview of using [ecgtools](https://ecgtools.readthedocs.io/en/latest/) for parsing CESM timeseries file model output, and reading in the data using \n", + "[Intake-ESM](https://intake-esm.readthedocs.io/en/latest/). In this example, we use sample CESM data within the test directory for Intake-ESM.\n", + "\n", + "## Downloading ecgtools\n", + "You can install [ecgtools](https://github.com/NCAR/ecgtools) through [PyPI](https://pypi.org/project/docs/) or [conda-forge](https://conda-forge.org/docs/). Examples of the syntax are provided below:\n", + "\n", + "\n", + "### Installing with Conda-Forge\n", + "\n", + "Within your [conda environment](https://docs.conda.io/projects/conda/en/latest/user-guide/tasks/manage-environments.html), run the following: \n", + "\n", + "\n", + "```bash\n", + "conda install -c conda-forge ecgtools\n", + "```\n", + "\n", + "\n", + "### Installing with Pip\n", + "Alternatively, you could use [PyPI](https://pypi.org/project/docs/), with the `pip install` command shown provided below.\n", + "\n", + "```bash\n", + "pip install ecgtools\n", + "```\n", + "\n", + "## Imports\n", + "The only parts of ecgtools we need are the `Builder` object and the `parse_cesm_history` parser from the CESM parsers! We import `glob` to take a look at the files we are parsing." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "nominated-battle", + "metadata": {}, + "outputs": [], + "source": [ + "import glob\n", + "\n", + "import intake\n", + "from ecgtools import Builder\n", + "from ecgtools.parsers.cesm import parse_cesm_timeseries" + ] + }, + { + "cell_type": "markdown", + "id": "czech-stylus", + "metadata": {}, + "source": [ + "### Understanding the Directory Structure\n", + "\n", + "The first step to setting up the `Builder` object is determining where your files are stored. As mentioned previously, we have a sample dataset of CESM2 model output, which is stored in test directory `/tests/sample_data` directory of this repository.\n", + "\n", + "Taking a look at that directory, we see that there is a single case `g.e11_LENS.GECOIAF.T62_g16.009`" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "south-nancy", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['../../../tests/sample_data/cesm/g.e11_LENS.GECOIAF.T62_g16.009.pop.h.ECOSYS_XKW.024901-031612.nc',\n", + " '../../../tests/sample_data/cesm/g.e11_LENS.GECOIAF.T62_g16.009.pop.h.sigma.O2.024901-031612.nc',\n", + " '../../../tests/sample_data/cesm/g.e11_LENS.GECOIAF.T62_g16.009.pop.h.ecosys.nday1.CaCO3_form_zint.02490101-03161231.nc']" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "glob.glob('../../../tests/sample_data/cesm/*')" + ] + }, + { + "cell_type": "markdown", + "id": "sunset-animation", + "metadata": {}, + "source": [ + "Now that we understand the directory structure, let's make the catalog." + ] + }, + { + "cell_type": "markdown", + "id": "growing-anthony", + "metadata": {}, + "source": [ + "## Build the catalog!\n", + "\n", + "Let's start by inspecting the builder object" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "promising-installation", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\u001b[0;31mInit signature:\u001b[0m\n", + "\u001b[0mBuilder\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mroot_path\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mUnion\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mpydantic\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtypes\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mDirectoryPath\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mList\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mpydantic\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtypes\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mDirectoryPath\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mextension\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mstr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'.nc'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mdepth\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mint\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mexclude_patterns\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mList\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mstr\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mnjobs\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mint\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mDocstring:\u001b[0m \n", + "Generates a catalog from a list of files.\n", + "\n", + "Parameters\n", + "----------\n", + "root_path : str or list\n", + " Path(s) of root directory.\n", + "extension : str, optional\n", + " File extension, by default None. If None, the builder will look for files with\n", + " \"*.nc\" extension.\n", + "depth : int, optional\n", + " Recursion depth. Recursively crawl `root_path` up to a specified depth, by default 0\n", + "exclude_patterns : list, optional\n", + " Directory, file patterns to exclude during catalog generation.\n", + " These could be substring or regular expressions. by default None\n", + "njobs : int, optional\n", + " The maximum number of concurrently running jobs,\n", + " by default -1 meaning all CPUs are used.\n", + "\u001b[0;31mFile:\u001b[0m ~/anaconda3/envs/intake-esm-dev/lib/python3.9/site-packages/ecgtools/builder.py\n", + "\u001b[0;31mType:\u001b[0m type\n", + "\u001b[0;31mSubclasses:\u001b[0m \n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "?Builder" + ] + }, + { + "cell_type": "markdown", + "id": "ccf85513-d76a-4b31-9908-dc6af39afc12", + "metadata": {}, + "source": [ + "
\n", + "

Info

\n", + " Note that as of 21 June, 2021, the parsing_func parameter is now used in the .build() method!\n", + "
" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "abroad-taxation", + "metadata": {}, + "outputs": [], + "source": [ + "b = Builder(\n", + " # Directory with the output\n", + " '../../../tests/sample_data/cesm/',\n", + " # Depth of 1 since we are sending it to the case output directory\n", + " depth=1,\n", + " # Exclude the timeseries and restart directories\n", + " exclude_patterns=[\"*/tseries/*\", \"*/rest/*\"],\n", + " # Number of jobs to execute - should be equal to # threads you are using\n", + " njobs=5,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "painful-syria", + "metadata": {}, + "source": [ + "Double check the object is set up..." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "studied-jersey", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Builder(root_path=PosixPath('../../../tests/sample_data/cesm'), extension='.nc', depth=1, exclude_patterns=['*/tseries/*', '*/rest/*'], njobs=5)" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "b" + ] + }, + { + "cell_type": "markdown", + "id": "american-exhibit", + "metadata": {}, + "source": [ + "We are good to go! Let's build the catalog by calling `.build()` on the object, passing in the `parse_cesm_history` parser! By default, it will use the `LokyBackend` which is described in the [Joblib documentation](https://joblib.readthedocs.io/en/latest/parallel.html)." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "false-bristol", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Parallel(n_jobs=5)]: Using backend LokyBackend with 5 concurrent workers.\n", + "[Parallel(n_jobs=5)]: Done 1 out of 1 | elapsed: 0.4s finished\n", + "[Parallel(n_jobs=5)]: Using backend LokyBackend with 5 concurrent workers.\n", + "/Users/mgrover/anaconda3/envs/intake-esm-dev/lib/python3.9/site-packages/ecgtools/parsers/cesm.py:240: UserWarning: Using the default frequency definitions\n", + " warnings.warn('Using the default frequency definitions')\n", + "/Users/mgrover/anaconda3/envs/intake-esm-dev/lib/python3.9/site-packages/ecgtools/parsers/cesm.py:240: UserWarning: Using the default frequency definitions\n", + " warnings.warn('Using the default frequency definitions')\n", + "/Users/mgrover/anaconda3/envs/intake-esm-dev/lib/python3.9/site-packages/ecgtools/parsers/cesm.py:240: UserWarning: Using the default frequency definitions\n", + " warnings.warn('Using the default frequency definitions')\n", + "[Parallel(n_jobs=5)]: Done 3 out of 3 | elapsed: 1.2s remaining: 0.0s\n", + "[Parallel(n_jobs=5)]: Done 3 out of 3 | elapsed: 1.2s finished\n" + ] + } + ], + "source": [ + "b = b.build(parse_cesm_timeseries)" + ] + }, + { + "cell_type": "markdown", + "id": "caring-harrison", + "metadata": {}, + "source": [ + "## Inspect the Catalog" + ] + }, + { + "cell_type": "markdown", + "id": "hydraulic-developer", + "metadata": {}, + "source": [ + "Now that the catalog is built, we can inspect the dataframe which is used to create the catalog by calling `.df` on the builder object" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "composite-insider", + "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", + "
componentstreamcasemember_idvariablestart_timeend_timetime_rangelong_nameunitsvertical_levelsfrequencypath
0ocnpop.hg.e11_LENS.GECOIAF.T62_g16.009009ECOSYS_XKW0249-010316-12024901-031612XKW for ecosys fluxescm/s1month_1../../../tests/sample_data/cesm/g.e11_LENS.GEC...
1ocnpop.h.ecosys.nday1g.e11_LENS.GECOIAF.T62_g16.009009CaCO3_form_zint0249-01-010316-12-3102490101-03161231CaCO3 Formation Vertical Integralmmol/m^3 cm/s1day_1../../../tests/sample_data/cesm/g.e11_LENS.GEC...
2ocnpop.hg.e11_LENS.GECOIAF.T62_g16.009009O20249-010316-12024901-031612Dissolved Oxygenmmol/m^31month_1../../../tests/sample_data/cesm/g.e11_LENS.GEC...
\n", + "
" + ], + "text/plain": [ + " component stream case member_id \\\n", + "0 ocn pop.h g.e11_LENS.GECOIAF.T62_g16.009 009 \n", + "1 ocn pop.h.ecosys.nday1 g.e11_LENS.GECOIAF.T62_g16.009 009 \n", + "2 ocn pop.h g.e11_LENS.GECOIAF.T62_g16.009 009 \n", + "\n", + " variable start_time end_time time_range \\\n", + "0 ECOSYS_XKW 0249-01 0316-12 024901-031612 \n", + "1 CaCO3_form_zint 0249-01-01 0316-12-31 02490101-03161231 \n", + "2 O2 0249-01 0316-12 024901-031612 \n", + "\n", + " long_name units vertical_levels \\\n", + "0 XKW for ecosys fluxes cm/s 1 \n", + "1 CaCO3 Formation Vertical Integral mmol/m^3 cm/s 1 \n", + "2 Dissolved Oxygen mmol/m^3 1 \n", + "\n", + " frequency path \n", + "0 month_1 ../../../tests/sample_data/cesm/g.e11_LENS.GEC... \n", + "1 day_1 ../../../tests/sample_data/cesm/g.e11_LENS.GEC... \n", + "2 month_1 ../../../tests/sample_data/cesm/g.e11_LENS.GEC... " + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "b.df" + ] + }, + { + "cell_type": "markdown", + "id": "fitted-audio", + "metadata": {}, + "source": [ + "The resultant dataframe includes the:\n", + "* Component\n", + "* Stream\n", + "* Case\n", + "* Date\n", + "* Frequency\n", + "* Variables\n", + "* Path" + ] + }, + { + "cell_type": "markdown", + "id": "single-storm", + "metadata": {}, + "source": [ + "## Save the Catalog" + ] + }, + { + "cell_type": "markdown", + "id": "b182c26e-4455-476b-ba09-eae29f78599f", + "metadata": {}, + "source": [ + "We can also check to see which files ***were not*** parsed by calling `.invalid_assets`" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "d0560280-113c-464d-928b-071780cf2b92", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + "
" + ], + "text/plain": [ + "Empty DataFrame\n", + "Columns: []\n", + "Index: []" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "b.invalid_assets" + ] + }, + { + "cell_type": "markdown", + "id": "5faf9882-566d-4106-ae3a-a1ae9e5b1be4", + "metadata": {}, + "source": [ + "This is empty, as expected!" + ] + }, + { + "cell_type": "markdown", + "id": "b5bd5184-3892-4032-971d-dd3245d33490", + "metadata": {}, + "source": [ + "## Save the Catalog\n", + "Now that we have our data catalog, we can save it, by specifying the path to the comma separated values file (`csv`) or compressed csv (`csv.gz`)." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "5a984e10-1704-467f-869b-43ba0b67b2c0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Saved catalog location: cesm_sample_data.json and cesm_sample_data.csv\n" + ] + } + ], + "source": [ + "b.save(\n", + " 'cesm_sample_data.csv',\n", + " # Column name including filepath\n", + " path_column_name='path',\n", + " # Column name including variables\n", + " variable_column_name='variable',\n", + " # Data file format - could be netcdf or zarr (in this case, netcdf)\n", + " data_format=\"netcdf\",\n", + " # Which attributes to groupby when reading in variables using intake-esm\n", + " groupby_attrs=[\"component\", \"stream\", \"case\"],\n", + " # Aggregations which are fed into xarray when reading in data using intake\n", + " aggregations=[\n", + " {'type': 'union', 'attribute_name': 'variable'},\n", + " {\n", + " \"type\": \"join_existing\",\n", + " \"attribute_name\": \"time_range\",\n", + " \"options\": {\"dim\": \"time\", \"coords\": \"minimal\", \"compat\": \"override\"},\n", + " },\n", + " ],\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "naval-external", + "metadata": {}, + "source": [ + "### Use the catalog to read in data" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "equal-ordering", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "

catalog with 2 dataset(s) from 3 asset(s):

\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
unique
component1
stream2
case1
member_id1
variable3
start_time2
end_time2
time_range2
long_name3
units3
vertical_levels1
frequency2
path3
derived_variable0
\n", + "
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "data_catalog = intake.open_esm_datastore(\n", + " \"cesm_sample_data.json\",\n", + ")\n", + "data_catalog" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "insured-conviction", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "--> The keys in the returned dictionary of datasets are constructed as follows:\n", + "\t'component.stream.case'\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + "
\n", + " \n", + " \n", + " 100.00% [2/2 00:00<00:00]\n", + "
\n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "dsets = data_catalog.to_dataset_dict()" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "meaningful-journalism", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'ocn.pop.h.ecosys.nday1.g.e11_LENS.GECOIAF.T62_g16.009': \n", + " Dimensions: (nlat: 5, nlon: 5, time: 12)\n", + " Coordinates:\n", + " ULONG (nlat, nlon) float64 dask.array\n", + " TLONG (nlat, nlon) float64 dask.array\n", + " ULAT (nlat, nlon) float64 dask.array\n", + " TLAT (nlat, nlon) float64 dask.array\n", + " * time (time) object 0249-01-02 00:00:00 ... 0249-01-13 00:00:00\n", + " Dimensions without coordinates: nlat, nlon\n", + " Data variables:\n", + " CaCO3_form_zint (time, nlat, nlon) float32 dask.array\n", + " Attributes: (12/15)\n", + " intake_esm_vars: ['CaCO3_form_zint']\n", + " intake_esm_attrs/component: ocn\n", + " intake_esm_attrs/stream: pop.h.ecosys.nday1\n", + " intake_esm_attrs/case: g.e11_LENS.GECOIAF.T62_g16.009\n", + " intake_esm_attrs/member_id: 9\n", + " intake_esm_attrs/variable: CaCO3_form_zint\n", + " ... ...\n", + " intake_esm_attrs/long_name: CaCO3 Formation Vertical Integral\n", + " intake_esm_attrs/units: mmol/m^3 cm/s\n", + " intake_esm_attrs/vertical_levels: 1\n", + " intake_esm_attrs/frequency: day_1\n", + " intake_esm_attrs/path: ../../../tests/sample_data/cesm/g.e11_...\n", + " intake_esm_dataset_key: ocn.pop.h.ecosys.nday1.g.e11_LENS.GECO...,\n", + " 'ocn.pop.h.g.e11_LENS.GECOIAF.T62_g16.009': \n", + " Dimensions: (nlat: 5, nlon: 5, time: 12, sigma: 5)\n", + " Coordinates:\n", + " TLAT (nlat, nlon) float64 dask.array\n", + " ULONG (nlat, nlon) float64 dask.array\n", + " ULAT (nlat, nlon) float64 dask.array\n", + " TLONG (nlat, nlon) float64 dask.array\n", + " * time (time) object 0249-02-01 00:00:00 ... 0250-01-01 00:00:00\n", + " * sigma (sigma) float64 23.4 23.45 23.5 23.55 23.6\n", + " Dimensions without coordinates: nlat, nlon\n", + " Data variables:\n", + " ECOSYS_XKW (time, nlat, nlon) float32 dask.array\n", + " O2 (time, sigma, nlat, nlon) float32 dask.array\n", + " Attributes:\n", + " intake_esm_attrs/component: ocn\n", + " intake_esm_attrs/stream: pop.h\n", + " intake_esm_attrs/case: g.e11_LENS.GECOIAF.T62_g16.009\n", + " intake_esm_attrs/member_id: 9\n", + " intake_esm_attrs/start_time: 0249-01\n", + " intake_esm_attrs/end_time: 0316-12\n", + " intake_esm_attrs/time_range: 024901-031612\n", + " intake_esm_attrs/vertical_levels: 1\n", + " intake_esm_attrs/frequency: month_1\n", + " intake_esm_dataset_key: ocn.pop.h.g.e11_LENS.GECOIAF.T62_g16.009}" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dsets" + ] + }, + { + "cell_type": "markdown", + "id": "center-orbit", + "metadata": {}, + "source": [ + "Let's plot a quick figure from the dataset!" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "comic-hampshire", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "dsets['ocn.pop.h.ecosys.nday1.g.e11_LENS.GECOIAF.T62_g16.009'].CaCO3_form_zint.isel(time=0).plot();" + ] + }, + { + "cell_type": "markdown", + "id": "facial-picking", + "metadata": {}, + "source": [ + "## Conclusion\n", + "Having the ability to easily create intake-esm catalogs from history files can be a powerful tool in your analysis toolkit. These data can be read in relatively quickly, easing the ability to quickly take a look at model output or even share your data with others! For more updates on [ecgtools](https://github.com/NCAR/ecgtools), be sure to follow [the ecgtools repository](https://github.com/NCAR/ecgtools) on Github! Have an idea for another helpful parser? Submit an issue!" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "documentary-cable", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "author": "Max Grover", + "date": "2021-06-04", + "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.9.6" + }, + "tags": "intake,cesm", + "title": "Building an Intake-esm catalog from CESM2 History Files" + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/source/user-guide/graphviz_example.ipynb b/docs/source/user-guide/graphviz_example.ipynb new file mode 100644 index 00000000..49cac058 --- /dev/null +++ b/docs/source/user-guide/graphviz_example.ipynb @@ -0,0 +1,1870 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "6834b397-d190-4214-a0d4-b91b202517eb", + "metadata": {}, + "source": [ + "# Creating Visualizations of Intake-ESM Catalogs" + ] + }, + { + "cell_type": "markdown", + "id": "88f5fad0-c002-4e58-858a-378af84fa961", + "metadata": {}, + "source": [ + "A common initial task when working with a new dataset is figuring out what data is available. This is especially true when working with climate ensembles with several components and time-frequency output (ex. Community Earth System Model Large Ensemble, CESM-LE). Here, we will examine different methods of investigating this catalog." + ] + }, + { + "cell_type": "markdown", + "id": "d244a6a4-dea7-4872-b2ae-ee9ce82fcdd4", + "metadata": {}, + "source": [ + "## Imports\n", + "\n", + "Here, we will use [intake-esm](https://intake-esm.readthedocs.io/en/latest/) and [graphviz](https://graphviz.readthedocs.io/en/stable/manual.html), which can be installed using the following (including jupyterlab too!)\n", + "\n", + "```\n", + "conda install -c conda-forge jupyterlab intake-esm graphviz\n", + "```\n", + "\n", + "Once you install these packages, open jupyterlab!" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "234fbcdc-68d3-48e1-ac7d-3719b87fd95d", + "metadata": {}, + "outputs": [], + "source": [ + "import intake\n", + "from graphviz import Digraph" + ] + }, + { + "cell_type": "markdown", + "id": "feef9176-0cee-4879-8a64-5eab032de164", + "metadata": {}, + "source": [ + "## Read in intake-esm catalog" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "909babf1-c9dc-4e43-b2cf-cd0f15e455ca", + "metadata": {}, + "outputs": [], + "source": [ + "col = intake.open_esm_datastore(\n", + " 'https://raw.githubusercontent.com/NCAR/cesm-lens-aws/master/intake-catalogs/aws-cesm1-le.json'\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "da14d8ea-06c0-4992-9a0a-e44c971779aa", + "metadata": {}, + "source": [ + "Typically, the process is to read in the dataframe containing the metadata, but this can be tough to read/understand what data is all there" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "cefeb1cb-79a8-4b31-bf8b-89de56818841", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
variablelong_namecomponentexperimentfrequencyvertical_levelsspatial_domainunitsstart_timeend_timepath
0FLNSnet longwave flux at surfaceatm20Cdaily1.0globalW/m21920-01-01 12:00:002005-12-31 12:00:00s3://ncar-cesm-lens/atm/daily/cesmLE-20C-FLNS....
1FLNSCclearsky net longwave flux at surfaceatm20Cdaily1.0globalW/m21920-01-01 12:00:002005-12-31 12:00:00s3://ncar-cesm-lens/atm/daily/cesmLE-20C-FLNSC...
2FLUTupwelling longwave flux at top of modelatm20Cdaily1.0globalW/m21920-01-01 12:00:002005-12-31 12:00:00s3://ncar-cesm-lens/atm/daily/cesmLE-20C-FLUT....
3FSNSnet solar flux at surfaceatm20Cdaily1.0globalW/m21920-01-01 12:00:002005-12-31 12:00:00s3://ncar-cesm-lens/atm/daily/cesmLE-20C-FSNS....
4FSNSCclearsky net solar flux at surfaceatm20Cdaily1.0globalW/m21920-01-01 12:00:002005-12-31 12:00:00s3://ncar-cesm-lens/atm/daily/cesmLE-20C-FSNSC...
....................................
437WVELvertical velocityocnRCP85monthly60.0global_oceancentimeter/s2006-01-16 12:00:002100-12-16 12:00:00s3://ncar-cesm-lens/ocn/monthly/cesmLE-RCP85-W...
438NaNNaNocnCTRLstaticNaNglobal_oceanNaNNaNNaNs3://ncar-cesm-lens/ocn/static/grid.zarr
439NaNNaNocnHISTstaticNaNglobal_oceanNaNNaNNaNs3://ncar-cesm-lens/ocn/static/grid.zarr
440NaNNaNocnRCP85staticNaNglobal_oceanNaNNaNNaNs3://ncar-cesm-lens/ocn/static/grid.zarr
441NaNNaNocn20CstaticNaNglobal_oceanNaNNaNNaNs3://ncar-cesm-lens/ocn/static/grid.zarr
\n", + "

442 rows × 11 columns

\n", + "
" + ], + "text/plain": [ + " variable long_name component experiment \\\n", + "0 FLNS net longwave flux at surface atm 20C \n", + "1 FLNSC clearsky net longwave flux at surface atm 20C \n", + "2 FLUT upwelling longwave flux at top of model atm 20C \n", + "3 FSNS net solar flux at surface atm 20C \n", + "4 FSNSC clearsky net solar flux at surface atm 20C \n", + ".. ... ... ... ... \n", + "437 WVEL vertical velocity ocn RCP85 \n", + "438 NaN NaN ocn CTRL \n", + "439 NaN NaN ocn HIST \n", + "440 NaN NaN ocn RCP85 \n", + "441 NaN NaN ocn 20C \n", + "\n", + " frequency vertical_levels spatial_domain units \\\n", + "0 daily 1.0 global W/m2 \n", + "1 daily 1.0 global W/m2 \n", + "2 daily 1.0 global W/m2 \n", + "3 daily 1.0 global W/m2 \n", + "4 daily 1.0 global W/m2 \n", + ".. ... ... ... ... \n", + "437 monthly 60.0 global_ocean centimeter/s \n", + "438 static NaN global_ocean NaN \n", + "439 static NaN global_ocean NaN \n", + "440 static NaN global_ocean NaN \n", + "441 static NaN global_ocean NaN \n", + "\n", + " start_time end_time \\\n", + "0 1920-01-01 12:00:00 2005-12-31 12:00:00 \n", + "1 1920-01-01 12:00:00 2005-12-31 12:00:00 \n", + "2 1920-01-01 12:00:00 2005-12-31 12:00:00 \n", + "3 1920-01-01 12:00:00 2005-12-31 12:00:00 \n", + "4 1920-01-01 12:00:00 2005-12-31 12:00:00 \n", + ".. ... ... \n", + "437 2006-01-16 12:00:00 2100-12-16 12:00:00 \n", + "438 NaN NaN \n", + "439 NaN NaN \n", + "440 NaN NaN \n", + "441 NaN NaN \n", + "\n", + " path \n", + "0 s3://ncar-cesm-lens/atm/daily/cesmLE-20C-FLNS.... \n", + "1 s3://ncar-cesm-lens/atm/daily/cesmLE-20C-FLNSC... \n", + "2 s3://ncar-cesm-lens/atm/daily/cesmLE-20C-FLUT.... \n", + "3 s3://ncar-cesm-lens/atm/daily/cesmLE-20C-FSNS.... \n", + "4 s3://ncar-cesm-lens/atm/daily/cesmLE-20C-FSNSC... \n", + ".. ... \n", + "437 s3://ncar-cesm-lens/ocn/monthly/cesmLE-RCP85-W... \n", + "438 s3://ncar-cesm-lens/ocn/static/grid.zarr \n", + "439 s3://ncar-cesm-lens/ocn/static/grid.zarr \n", + "440 s3://ncar-cesm-lens/ocn/static/grid.zarr \n", + "441 s3://ncar-cesm-lens/ocn/static/grid.zarr \n", + "\n", + "[442 rows x 11 columns]" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "col.df" + ] + }, + { + "cell_type": "markdown", + "id": "5288fa3a-d226-4254-98c4-37e6f01e8aa0", + "metadata": {}, + "source": [ + "You can search via intake-esm, using the following syntax" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "8381f59a-13c0-412f-adb9-2a7a1bf991bd", + "metadata": {}, + "outputs": [], + "source": [ + "cat = col.search(experiment='20C', frequency='monthly')" + ] + }, + { + "cell_type": "markdown", + "id": "0508624e-9815-4d98-a985-9ec93aa567a1", + "metadata": {}, + "source": [ + "Here again, it is tough to see everything that is here, also it requires knowing which experiments are in the dataset, and which frequency you are looking for" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "8257f661-747d-47c9-95fb-4bfc140f2a7e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
variablelong_namecomponentexperimentfrequencyvertical_levelsspatial_domainunitsstart_timeend_timepath
0FLNSnet longwave flux at surfaceatm20Cmonthly1.0globalW/m21920-01-16 12:00:002005-12-16 12:00:00s3://ncar-cesm-lens/atm/monthly/cesmLE-20C-FLN...
1FLNSCclearsky net longwave flux at surfaceatm20Cmonthly1.0globalW/m21920-01-16 12:00:002005-12-16 12:00:00s3://ncar-cesm-lens/atm/monthly/cesmLE-20C-FLN...
2FLUTupwelling longwave flux at top of modelatm20Cmonthly1.0globalW/m21920-01-16 12:00:002005-12-16 12:00:00s3://ncar-cesm-lens/atm/monthly/cesmLE-20C-FLU...
3FSNSnet solar flux at surfaceatm20Cmonthly1.0globalW/m21920-01-16 12:00:002005-12-16 12:00:00s3://ncar-cesm-lens/atm/monthly/cesmLE-20C-FSN...
4FSNSCclearsky net solar flux at surfaceatm20Cmonthly1.0globalW/m21920-01-16 12:00:002005-12-16 12:00:00s3://ncar-cesm-lens/atm/monthly/cesmLE-20C-FSN...
....................................
61VNTflux of heat in grid-y directionocn20Cmonthly60.0global_oceandegC/s1920-01-16 12:00:002005-12-16 12:00:00s3://ncar-cesm-lens/ocn/monthly/cesmLE-20C-VNT...
62VVELvelocity in grid-y directionocn20Cmonthly60.0global_oceancentimeter/s1920-01-16 12:00:002005-12-16 12:00:00s3://ncar-cesm-lens/ocn/monthly/cesmLE-20C-VVE...
63WTSsalt flux across top faceocn20Cmonthly60.0global_oceangram/kilogram/s1920-01-16 12:00:002005-12-16 12:00:00s3://ncar-cesm-lens/ocn/monthly/cesmLE-20C-WTS...
64WTTheat flux across top faceocn20Cmonthly60.0global_oceandegC/s1920-01-16 12:00:002005-12-16 12:00:00s3://ncar-cesm-lens/ocn/monthly/cesmLE-20C-WTT...
65WVELvertical velocityocn20Cmonthly60.0global_oceancentimeter/s1920-01-16 12:00:002005-12-16 12:00:00s3://ncar-cesm-lens/ocn/monthly/cesmLE-20C-WVE...
\n", + "

66 rows × 11 columns

\n", + "
" + ], + "text/plain": [ + " variable long_name component experiment \\\n", + "0 FLNS net longwave flux at surface atm 20C \n", + "1 FLNSC clearsky net longwave flux at surface atm 20C \n", + "2 FLUT upwelling longwave flux at top of model atm 20C \n", + "3 FSNS net solar flux at surface atm 20C \n", + "4 FSNSC clearsky net solar flux at surface atm 20C \n", + ".. ... ... ... ... \n", + "61 VNT flux of heat in grid-y direction ocn 20C \n", + "62 VVEL velocity in grid-y direction ocn 20C \n", + "63 WTS salt flux across top face ocn 20C \n", + "64 WTT heat flux across top face ocn 20C \n", + "65 WVEL vertical velocity ocn 20C \n", + "\n", + " frequency vertical_levels spatial_domain units \\\n", + "0 monthly 1.0 global W/m2 \n", + "1 monthly 1.0 global W/m2 \n", + "2 monthly 1.0 global W/m2 \n", + "3 monthly 1.0 global W/m2 \n", + "4 monthly 1.0 global W/m2 \n", + ".. ... ... ... ... \n", + "61 monthly 60.0 global_ocean degC/s \n", + "62 monthly 60.0 global_ocean centimeter/s \n", + "63 monthly 60.0 global_ocean gram/kilogram/s \n", + "64 monthly 60.0 global_ocean degC/s \n", + "65 monthly 60.0 global_ocean centimeter/s \n", + "\n", + " start_time end_time \\\n", + "0 1920-01-16 12:00:00 2005-12-16 12:00:00 \n", + "1 1920-01-16 12:00:00 2005-12-16 12:00:00 \n", + "2 1920-01-16 12:00:00 2005-12-16 12:00:00 \n", + "3 1920-01-16 12:00:00 2005-12-16 12:00:00 \n", + "4 1920-01-16 12:00:00 2005-12-16 12:00:00 \n", + ".. ... ... \n", + "61 1920-01-16 12:00:00 2005-12-16 12:00:00 \n", + "62 1920-01-16 12:00:00 2005-12-16 12:00:00 \n", + "63 1920-01-16 12:00:00 2005-12-16 12:00:00 \n", + "64 1920-01-16 12:00:00 2005-12-16 12:00:00 \n", + "65 1920-01-16 12:00:00 2005-12-16 12:00:00 \n", + "\n", + " path \n", + "0 s3://ncar-cesm-lens/atm/monthly/cesmLE-20C-FLN... \n", + "1 s3://ncar-cesm-lens/atm/monthly/cesmLE-20C-FLN... \n", + "2 s3://ncar-cesm-lens/atm/monthly/cesmLE-20C-FLU... \n", + "3 s3://ncar-cesm-lens/atm/monthly/cesmLE-20C-FSN... \n", + "4 s3://ncar-cesm-lens/atm/monthly/cesmLE-20C-FSN... \n", + ".. ... \n", + "61 s3://ncar-cesm-lens/ocn/monthly/cesmLE-20C-VNT... \n", + "62 s3://ncar-cesm-lens/ocn/monthly/cesmLE-20C-VVE... \n", + "63 s3://ncar-cesm-lens/ocn/monthly/cesmLE-20C-WTS... \n", + "64 s3://ncar-cesm-lens/ocn/monthly/cesmLE-20C-WTT... \n", + "65 s3://ncar-cesm-lens/ocn/monthly/cesmLE-20C-WVE... \n", + "\n", + "[66 rows x 11 columns]" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cat.df" + ] + }, + { + "cell_type": "markdown", + "id": "6ebcf22f-3ce9-4d65-82d4-4f1405fcf100", + "metadata": {}, + "source": [ + "## Using Graphviz in a Jupyter Notebook\n", + "\n", + "[Graphviz](https://graphviz.readthedocs.io/en/stable/manual.html) offers an interface to create network graphs\n", + "\n", + "### Main \"components\" of [Graphviz](https://graphviz.readthedocs.io/en/stable/manual.html)\n", + "* Digraph class\n", + " * This is the main class that is used to build the visualization - typically assign to a variable `dot`, but you can use any variable you like! \n", + "* Node\n", + " * The \"bubbles\" which contain a numbered label (ex. '1') and a label (ex. 'HIST')\n", + " * These can be connected together - the **numbered label must be a unique integer**\n", + "* Edge\n", + " * Edges connect the different nodes, using the numbered indices (ex. `.edge('1', '3')` would connect the first and third nodes" + ] + }, + { + "cell_type": "markdown", + "id": "de2bee88-ecc5-4d3b-8233-5edd6e6d7879", + "metadata": {}, + "source": [ + "### Example of case visualization" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "ff030012-2a8c-4eef-be01-e5bb5c4a4ac6", + "metadata": {}, + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "1\n", + "\n", + "HIST\n", + "\n", + "\n", + "\n", + "2\n", + "\n", + "ocn\n", + "\n", + "\n", + "\n", + "1->2\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "5\n", + "\n", + "atm\n", + "\n", + "\n", + "\n", + "1->5\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "3\n", + "\n", + "monthly\n", + "\n", + "\n", + "\n", + "2->3\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "4\n", + "\n", + "daily\n", + "\n", + "\n", + "\n", + "2->4\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "6\n", + "\n", + "monthly\n", + "\n", + "\n", + "\n", + "5->6\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "7\n", + "\n", + "weekly\n", + "\n", + "\n", + "\n", + "5->7\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Create Digraph object\n", + "dot = Digraph()\n", + "\n", + "# Create the first node which serves as the main parent\n", + "dot.node('1', label='HIST')\n", + "\n", + "dot.node('2', label='ocn')\n", + "dot.edge('1', '2')\n", + "\n", + "# Add a monthly child from the ocn component parent\n", + "dot.node('3', label='monthly')\n", + "dot.edge('2', '3')\n", + "\n", + "# Add a daily child from the ocn component parent\n", + "dot.node('4', label='daily')\n", + "dot.edge('2', '4')\n", + "\n", + "# Add an atm component node and connect to experiment parent\n", + "dot.node('5', label='atm')\n", + "dot.edge('1', '5')\n", + "\n", + "# Add a monthly child from the atm component parent\n", + "dot.node('6', label='monthly')\n", + "dot.edge('5', '6')\n", + "\n", + "# Add a weekly child from the atm component parent\n", + "dot.node('7', label='weekly')\n", + "dot.edge('5', '7')\n", + "\n", + "# Visualize the graph\n", + "dot" + ] + }, + { + "cell_type": "markdown", + "id": "990b2f8c-aaf2-43d3-99c0-fd8298d6a61a", + "metadata": {}, + "source": [ + "### Looping through the CESM-LE catalog" + ] + }, + { + "cell_type": "markdown", + "id": "c84eb005-b283-49e5-bb6b-52b33d73f1f1", + "metadata": {}, + "source": [ + "Let's apply this to our data catalog, assigning the dataframe with dataset attributes to `df`" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "0fdc759e-9f3a-488d-8c95-40ccbe6938e4", + "metadata": {}, + "outputs": [], + "source": [ + "df = col.df" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "3dd39b0a-bac1-4104-a0fd-d4762dcabd93", + "metadata": {}, + "outputs": [], + "source": [ + "# Create Digraph object - use the left to right orientation instead of vertical\n", + "dot = Digraph(graph_attr={'rankdir': 'LR'})\n", + "\n", + "# Start counting at one for node numbers\n", + "num_node = 1\n", + "\n", + "# Loop through the different experiments\n", + "for experiment in df.experiment.unique():\n", + " exp_i = num_node\n", + " dot.node(str(exp_i), label=experiment)\n", + " num_node += 1\n", + "\n", + " # Loop through the different components in each experiment\n", + " for component in df.loc[df.experiment == experiment].component.unique():\n", + " comp_i = num_node\n", + " dot.node(str(comp_i), label=component)\n", + " dot.edge(str(exp_i), str(comp_i))\n", + " num_node += 1\n", + "\n", + " # Loop through the frequency in each component within each experiment\n", + " for frequency in df.loc[\n", + " (df.experiment == experiment) & (df.component == component)\n", + " ].frequency.unique():\n", + " freq_i = num_node\n", + " dot.node(str(freq_i), label=frequency)\n", + " dot.edge(str(comp_i), str(freq_i))\n", + " num_node += 1\n", + " comp_i += 1\n", + " exp_i += 1" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "b6de404f-1160-4c8a-8b23-585330c3489b", + "metadata": {}, + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "1\n", + "\n", + "20C\n", + "\n", + "\n", + "\n", + "2\n", + "\n", + "atm\n", + "\n", + "\n", + "\n", + "1->2\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "7\n", + "\n", + "ice_nh\n", + "\n", + "\n", + "\n", + "1->7\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "10\n", + "\n", + "ice_sh\n", + "\n", + "\n", + "\n", + "1->10\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "13\n", + "\n", + "lnd\n", + "\n", + "\n", + "\n", + "1->13\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "16\n", + "\n", + "ocn\n", + "\n", + "\n", + "\n", + "1->16\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "3\n", + "\n", + "daily\n", + "\n", + "\n", + "\n", + "2->3\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "4\n", + "\n", + "hourly6-1990-2005\n", + "\n", + "\n", + "\n", + "2->4\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "5\n", + "\n", + "monthly\n", + "\n", + "\n", + "\n", + "2->5\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "6\n", + "\n", + "static\n", + "\n", + "\n", + "\n", + "2->6\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "8\n", + "\n", + "monthly\n", + "\n", + "\n", + "\n", + "7->8\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "9\n", + "\n", + "static\n", + "\n", + "\n", + "\n", + "7->9\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "11\n", + "\n", + "monthly\n", + "\n", + "\n", + "\n", + "10->11\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "12\n", + "\n", + "static\n", + "\n", + "\n", + "\n", + "10->12\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "14\n", + "\n", + "monthly\n", + "\n", + "\n", + "\n", + "13->14\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "15\n", + "\n", + "static\n", + "\n", + "\n", + "\n", + "13->15\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "17\n", + "\n", + "monthly\n", + "\n", + "\n", + "\n", + "16->17\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "18\n", + "\n", + "static\n", + "\n", + "\n", + "\n", + "16->18\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "19\n", + "\n", + "CTRL\n", + "\n", + "\n", + "\n", + "20\n", + "\n", + "atm\n", + "\n", + "\n", + "\n", + "19->20\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "24\n", + "\n", + "ice_nh\n", + "\n", + "\n", + "\n", + "19->24\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "28\n", + "\n", + "ice_sh\n", + "\n", + "\n", + "\n", + "19->28\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "32\n", + "\n", + "lnd\n", + "\n", + "\n", + "\n", + "19->32\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "36\n", + "\n", + "ocn\n", + "\n", + "\n", + "\n", + "19->36\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "21\n", + "\n", + "daily\n", + "\n", + "\n", + "\n", + "20->21\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "22\n", + "\n", + "monthly\n", + "\n", + "\n", + "\n", + "20->22\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "23\n", + "\n", + "static\n", + "\n", + "\n", + "\n", + "20->23\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "25\n", + "\n", + "daily\n", + "\n", + "\n", + "\n", + "24->25\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "26\n", + "\n", + "monthly\n", + "\n", + "\n", + "\n", + "24->26\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "27\n", + "\n", + "static\n", + "\n", + "\n", + "\n", + "24->27\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "29\n", + "\n", + "daily\n", + "\n", + "\n", + "\n", + "28->29\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "30\n", + "\n", + "monthly\n", + "\n", + "\n", + "\n", + "28->30\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "31\n", + "\n", + "static\n", + "\n", + "\n", + "\n", + "28->31\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "33\n", + "\n", + "daily\n", + "\n", + "\n", + "\n", + "32->33\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "34\n", + "\n", + "monthly\n", + "\n", + "\n", + "\n", + "32->34\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "35\n", + "\n", + "static\n", + "\n", + "\n", + "\n", + "32->35\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "37\n", + "\n", + "monthly\n", + "\n", + "\n", + "\n", + "36->37\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "38\n", + "\n", + "static\n", + "\n", + "\n", + "\n", + "36->38\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "39\n", + "\n", + "HIST\n", + "\n", + "\n", + "\n", + "40\n", + "\n", + "atm\n", + "\n", + "\n", + "\n", + "39->40\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "44\n", + "\n", + "ice_nh\n", + "\n", + "\n", + "\n", + "39->44\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "48\n", + "\n", + "ice_sh\n", + "\n", + "\n", + "\n", + "39->48\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "52\n", + "\n", + "lnd\n", + "\n", + "\n", + "\n", + "39->52\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "56\n", + "\n", + "ocn\n", + "\n", + "\n", + "\n", + "39->56\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "41\n", + "\n", + "daily\n", + "\n", + "\n", + "\n", + "40->41\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "42\n", + "\n", + "monthly\n", + "\n", + "\n", + "\n", + "40->42\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "43\n", + "\n", + "static\n", + "\n", + "\n", + "\n", + "40->43\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "45\n", + "\n", + "daily\n", + "\n", + "\n", + "\n", + "44->45\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "46\n", + "\n", + "monthly\n", + "\n", + "\n", + "\n", + "44->46\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "47\n", + "\n", + "static\n", + "\n", + "\n", + "\n", + "44->47\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "49\n", + "\n", + "daily\n", + "\n", + "\n", + "\n", + "48->49\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "50\n", + "\n", + "monthly\n", + "\n", + "\n", + "\n", + "48->50\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "51\n", + "\n", + "static\n", + "\n", + "\n", + "\n", + "48->51\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "53\n", + "\n", + "daily\n", + "\n", + "\n", + "\n", + "52->53\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "54\n", + "\n", + "monthly\n", + "\n", + "\n", + "\n", + "52->54\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "55\n", + "\n", + "static\n", + "\n", + "\n", + "\n", + "52->55\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "57\n", + "\n", + "monthly\n", + "\n", + "\n", + "\n", + "56->57\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "58\n", + "\n", + "static\n", + "\n", + "\n", + "\n", + "56->58\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "59\n", + "\n", + "RCP85\n", + "\n", + "\n", + "\n", + "60\n", + "\n", + "atm\n", + "\n", + "\n", + "\n", + "59->60\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "66\n", + "\n", + "ice_nh\n", + "\n", + "\n", + "\n", + "59->66\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "70\n", + "\n", + "ice_sh\n", + "\n", + "\n", + "\n", + "59->70\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "74\n", + "\n", + "lnd\n", + "\n", + "\n", + "\n", + "59->74\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "78\n", + "\n", + "ocn\n", + "\n", + "\n", + "\n", + "59->78\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "61\n", + "\n", + "daily\n", + "\n", + "\n", + "\n", + "60->61\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "62\n", + "\n", + "hourly6-2026-2035\n", + "\n", + "\n", + "\n", + "60->62\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "63\n", + "\n", + "hourly6-2071-2080\n", + "\n", + "\n", + "\n", + "60->63\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "64\n", + "\n", + "monthly\n", + "\n", + "\n", + "\n", + "60->64\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "65\n", + "\n", + "static\n", + "\n", + "\n", + "\n", + "60->65\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "67\n", + "\n", + "daily\n", + "\n", + "\n", + "\n", + "66->67\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "68\n", + "\n", + "monthly\n", + "\n", + "\n", + "\n", + "66->68\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "69\n", + "\n", + "static\n", + "\n", + "\n", + "\n", + "66->69\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "71\n", + "\n", + "daily\n", + "\n", + "\n", + "\n", + "70->71\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "72\n", + "\n", + "monthly\n", + "\n", + "\n", + "\n", + "70->72\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "73\n", + "\n", + "static\n", + "\n", + "\n", + "\n", + "70->73\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "75\n", + "\n", + "daily\n", + "\n", + "\n", + "\n", + "74->75\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "76\n", + "\n", + "monthly\n", + "\n", + "\n", + "\n", + "74->76\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "77\n", + "\n", + "static\n", + "\n", + "\n", + "\n", + "74->77\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "79\n", + "\n", + "monthly\n", + "\n", + "\n", + "\n", + "78->79\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "80\n", + "\n", + "static\n", + "\n", + "\n", + "\n", + "78->80\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dot" + ] + }, + { + "cell_type": "markdown", + "id": "34fbf1b7-7d1d-4e0e-8b33-523df9bd10cb", + "metadata": {}, + "source": [ + "## Conclusion\n", + "[Graphviz](https://graphviz.readthedocs.io/en/stable/manual.html) can be a helpful tool when visualizing what data is within your data catalog - I hope this provides a good starting point in terms of using this with [intake-esm](https://intake-esm.readthedocs.io/en/latest/) catalogs!" + ] + } + ], + "metadata": { + "author": "Max Grover", + "date": "2021-06-11", + "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.9.6" + }, + "tags": "visualization,intake,cesm", + "title": "Creating Visualizations of Intake-ESM Catalogs" + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/source/user-guide/index.md b/docs/source/user-guide/index.md index ba8d0e57..0b088a09 100644 --- a/docs/source/user-guide/index.md +++ b/docs/source/user-guide/index.md @@ -8,8 +8,10 @@ maxdepth: 2 caption: Core Guide --- overview.ipynb +ecgtools-history-files-example.ipynb search.ipynb multi-variable-assets.ipynb +intake-esm-derived-variables.ipynb ``` ```{toctree} @@ -19,4 +21,7 @@ caption: Tutorials & Examples --- cmip6-tutorial.ipynb manipulating-dataframe.ipynb +intake_cmip6_debug.md +graphviz_example.ipynb + ``` diff --git a/docs/source/user-guide/intake-esm-derived-variables.ipynb b/docs/source/user-guide/intake-esm-derived-variables.ipynb new file mode 100644 index 00000000..f6c1f9e5 --- /dev/null +++ b/docs/source/user-guide/intake-esm-derived-variables.ipynb @@ -0,0 +1,568 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "29947174", + "metadata": {}, + "source": [ + "# Using [Intake-ESM's](https://intake-esm.readthedocs.io/en/latest/) Derived Variable Functionality\n", + "\n", + "## What is a \"Derived Variable\"\n", + "A \"derived variable\" in this case is a variable that doesn't itself exist in an [intake-esm](https://intake-esm.readthedocs.io/en/latest/) catalog, but can be computed (i.e., \"derived\") from variables that do exist in the catalog. \n", + "Currently, the derived variable implementation requires variables on the same grid, etc.; i.e., it assumes that all variables involved can be merged within **the same dataset**. \n", + "\n", + "An example of a derived variable could be temperature in degrees Fahrenheit. Often times, climate model models write temperature in Celsius or Kelvin, but the user may want degrees Fahrenheit!\n", + "This is a really simple example; derived variables could include more sophsticated diagnostic output like aggregations of terms in a tracer budget or gradients in a particular field.\n", + "\n", + "A traditional workflow for \"derived variables\" might consist of the following:\n", + "* Load the data\n", + "* Apply some function to the loaded datasets\n", + "* Plot the output\n", + "\n", + "\n", + "But what if we could couple those first two steps? What if we could have some set of **variable definitions**, consisting of variable requirements, such as `dependent variables`, and a function which derives the quantity. This is what the `derived_variable` funtionality offers in `intake-esm`! This enables users to share a \"registry\" of derived variables across catalogs!\n", + "\n", + "Let's get started with an example!" + ] + }, + { + "cell_type": "markdown", + "id": "fa009c07", + "metadata": {}, + "source": [ + "## Imports" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "bd9f0efc", + "metadata": {}, + "outputs": [], + "source": [ + "import intake\n", + "import numpy as np\n", + "\n", + "from intake_esm.derived import DerivedVariableRegistry" + ] + }, + { + "cell_type": "markdown", + "id": "0f372c63", + "metadata": { + "tags": [] + }, + "source": [ + "## How to add a Derived Variable\n", + "Let's compute a derived variable - wind speed! This can be derived from using the zonal (`U`) and meridional (`V`) components of the wind." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "30117abd", + "metadata": {}, + "outputs": [], + "source": [ + "def calc_wind_speed(u, v):\n", + " return np.sqrt(u ** 2 + v ** 2)" + ] + }, + { + "cell_type": "markdown", + "id": "5cbba3cf", + "metadata": {}, + "source": [ + "### Creating our Derived Variable Registry\n", + "We need to instantiate our derived variable registry, which will store our derived variable information! We use the variable `dvr` for this (**D**erived**V**ariable**R**egistry)." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "7e9ed122", + "metadata": {}, + "outputs": [], + "source": [ + "dvr = DerivedVariableRegistry()" + ] + }, + { + "cell_type": "markdown", + "id": "bb3379f6", + "metadata": {}, + "source": [ + "In order to register this derived variable we need to add a [decorator](https://www.python.org/dev/peps/pep-0318/) for our function, as seen below. This allows us to define our derived variable, dependent variables, and the function associated with the calculation." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "430894dd", + "metadata": {}, + "outputs": [], + "source": [ + "@dvr.register(variable='wind_speed', query={'variable': ['U', 'V']})\n", + "def calc_wind_speed(ds):\n", + " ds['wind_speed'] = np.sqrt(ds.U ** 2 + ds.V ** 2)\n", + " return ds" + ] + }, + { + "cell_type": "markdown", + "id": "1a316f5a", + "metadata": {}, + "source": [ + "You'll notice `dvr` now has a registered variable, `wind_speed`, which was defined in the cell above!" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "6166f217", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "DerivedVariableRegistry({'wind_speed': DerivedVariable(func=, variable='wind_speed', query={'variable': ['U', 'V']})})" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dvr" + ] + }, + { + "cell_type": "markdown", + "id": "6604a1ce-df45-4e93-a212-769648ed4d68", + "metadata": {}, + "source": [ + "### Loading in a Derived Variable Registry from File\n", + "You can load your derived variables from a module as well!\n", + "\n", + "Within the file `my_registry.py`, we have the following, which mirrors the previous few cells:\n", + "\n", + "```python\n", + "from intake_esm.derived import DerivedVariableRegistry\n", + "\n", + "dvr = DerivedVariableRegistry()\n", + "\n", + "@dvr.register(variable='wind_speed', query={'variable': ['U', 'V']})\n", + "def calc_wind_speed(ds):\n", + " ds['wind_speed'] = np.sqrt(ds.U ** 2 + ds.V ** 2)\n", + " return ds\n", + "```\n", + "\n", + "We can now load `my_registry.py` into our notebook! We use the following syntax to load in that registry:\n", + "\n", + "```python\n", + "dvr = DerivedVariableRegistry.load('my_registry')\n", + "dvr\n", + "```\n", + "\n", + "```\n", + "DerivedVariableRegistry({'wind_speed': DerivedVariable(func=, variable='wind_speed', query={'variable': ['U', 'V']})})\n", + "```" + ] + }, + { + "cell_type": "markdown", + "id": "14b2049b", + "metadata": {}, + "source": [ + "## Read in Data with our Registry\n", + "In this case, we will use data from the CESM Large Ensemble (LENS). This is a climate model ensemble, a subset of which is hosted on the AWS Cloud. If you are interested in learning more about this dataset, check out the [LENS on AWS documentation page](https://ncar.github.io/cesm-lens-aws/).\n", + "\n", + "We load in our derived variable catalog using the `registry` argument." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "08eb271e", + "metadata": {}, + "outputs": [], + "source": [ + "data_catalog = intake.open_esm_datastore(\n", + " 'https://raw.githubusercontent.com/NCAR/cesm-lens-aws/master/intake-catalogs/aws-cesm1-le.json',\n", + " registry=dvr,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "16ed4f25", + "metadata": {}, + "source": [ + "You'll notice we have a new field - `derived_variable` which has 1 unique value." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "f511212e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "

aws-cesm1-le catalog with 56 dataset(s) from 442 asset(s):

\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
unique
variable78
long_name75
component5
experiment4
frequency6
vertical_levels3
spatial_domain5
units25
start_time12
end_time13
path427
derived_variable1
\n", + "
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "data_catalog" + ] + }, + { + "cell_type": "markdown", + "id": "d16014fa", + "metadata": {}, + "source": [ + "Let's also subset for monthly frequency, as well as the 20th century (20C) and RCP 8.5 (RCP85) experiments." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "3c4f6206", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "

aws-cesm1-le catalog with 7 dataset(s) from 14 asset(s):

\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
unique
variable2
long_name2
component1
experiment4
frequency4
vertical_levels1
spatial_domain1
units1
start_time7
end_time7
path14
derived_variable1
\n", + "
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "catalog_subset = data_catalog.search(\n", + " variable=['wind_speed'], frequency='monthly', experiment='RCP85'\n", + ")\n", + "\n", + "catalog_subset" + ] + }, + { + "cell_type": "markdown", + "id": "b8669c17", + "metadata": { + "tags": [] + }, + "source": [ + "### Calling `to_dataset_dict` to Load in the Data\n", + "We load in the data, which lazily adds our calculation for `wind_speed` to the datasets!" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "id": "03cb05ad-2a8c-44eb-9a91-91d9bb467ecb", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "--> The keys in the returned dictionary of datasets are constructed as follows:\n", + "\t'component.experiment.frequency'\n", + "█\r" + ] + }, + { + "data": { + "text/plain": [ + "dict_keys(['atm.RCP85.monthly', 'atm.HIST.monthly', 'atm.20C.monthly', 'atm.RCP85.hourly6-2071-2080', 'atm.CTRL.monthly', 'atm.RCP85.hourly6-2026-2035', 'atm.20C.hourly6-1990-2005'])" + ] + }, + "execution_count": 45, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dsets = catalog_subset.to_dataset_dict(\n", + " xarray_open_kwargs={'backend_kwargs': {'storage_options': {'anon': True}}}\n", + ")\n", + "dsets.keys()" + ] + }, + { + "cell_type": "markdown", + "id": "cd5a1adc-382d-452d-9fd7-e049ea5fd40d", + "metadata": {}, + "source": [ + "Let's look at single dataset from this dictionary of datasets... using the key `atm.CTRL.monthly`" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "id": "c947191f-a7fe-4e69-9ceb-61e084a02db2", + "metadata": {}, + "outputs": [], + "source": [ + "ds = dsets['atm.CTRL.monthly']" + ] + }, + { + "cell_type": "markdown", + "id": "41aa48af", + "metadata": {}, + "source": [ + "## Apply an Annual Mean Calculation\n", + "Let's apply an annual average to the data - since all the years are 365 days long, we do not need any special weighting" + ] + }, + { + "cell_type": "markdown", + "id": "16a70995-1b55-47b0-9874-4a3761ee7503", + "metadata": {}, + "source": [ + "You'll notice upon reading in the dataset, we have three variables:\n", + "* `U`\n", + "* `V`\n", + "* `wind_speed`" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "id": "51d57505", + "metadata": {}, + "outputs": [], + "source": [ + "annual_mean = ds.groupby('time.year').mean('time')" + ] + }, + { + "cell_type": "markdown", + "id": "4d1197a2", + "metadata": { + "tags": [] + }, + "source": [ + "### Plot the Output\n", + "We can use the plotting functions within [`Xarray`](http://xarray.pydata.org/en/stable/) to view the output!" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "id": "18ad9e8f", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "ds.wind_speed.isel(member_id=0, time=0, lev=-1).plot();" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6d8aba00", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "author": "Max Grover", + "date": "2021-10-22", + "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.9.7" + }, + "tags": "intake,diagnostics,cesm", + "title": "Using Intake-ESM's New Derived Variable Functionality" + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/source/user-guide/intake_cmip6_debug.md b/docs/source/user-guide/intake_cmip6_debug.md new file mode 100644 index 00000000..3030a433 --- /dev/null +++ b/docs/source/user-guide/intake_cmip6_debug.md @@ -0,0 +1,131 @@ +--- +author: Max Grover +date: 2021-5-14 +tags: intake, cmip6, debug +--- + +# Debugging Intake-ESM Process for Reading in CMIP6 + +This post was motivated by a post from Steve Yeager [@sgyeager](https://github.com/sgyeager), who ran into an error when attempting to read in CMIP6 data via intake-esm. + +For those who are unfamiliar with intake-esm, be sure to read over [the documentation](https://intake-esm.readthedocs.io/en/latest/index.html)! The user guide even includes [an entire portion of their site](https://intake-esm.readthedocs.io/en/latest/user-guide/cmip6-tutorial.html) on looking at CMIP6 data. These resources would be a great place to start. + +The specific workflow of using this package for reading in Sea Water Silinity (`so`) and +Sea Water Potential Temperature (`thetao`) are given below + +## Reproducing the Error + +```python +import intake +``` + +Set a path to the CMIP catalog - in this case, since we using the glade file system, use this and open the catalog using the intake-esm extension. + +```python +# Set the path for the catalog file +catalog_file = '/glade/collections/cmip/catalog/intake-esm-datastore/catalogs/glade-cmip6.json' + +# Open the catalog using intake +col = intake.open_esm_datastore(catalog_file) +``` + +Now, we set which experiment to use. In this case, we are interested in the Ocean Model Intercomparison Project (OMIP) since we are looking at ocean data, setting + +```python +experiment_id = ['omip1'] +``` + +In terms of the variables of interest, we are interested in Sea Water Silinity (`so`) and Sea Water Potential Temperature (`thetao`), so we set + +```python +variable_id = ['so', 'thetao'] +``` + +The last variable to change is the table_id which corresponds to the temporal frequency. Since we are interested in monthly data, we set + +```python +table_id = 'Omon' +``` + +Putting all that together, we setup the catalog and call `to_dataset_dict` which assembles a dictionary of datasets + +```python +cat = col.search( + experiment_id=['omip1'], + variable_id=['thetao', 'so'], + table_id='Omon' +) +dset_dict = cat.to_dataset_dict() +``` + +But this returns an error of: + +``` +AggregationError: + Failed to merge multiple datasets in group with key=OMIP.CNRM-CERFACS.CNRM-CM6-1.omip1.Omon.gn into a single xarray Dataset as variables. + + *** Arguments passed to xarray.merge() ***: + + - objs: a list of 2 datasets + - kwargs: {} + + ******************************************** +``` + +## Determining the Cause of the Error + +At this point, let's go back and inspect the subset catalog we have, calling the `catalog.df` + +```python +cat.df +``` + +Notice how in the error, the source_id which triggered the error is `CNRM-CM6-1`, so let's subset for that and investigate the problem... + +```python +cat.df[cat.df.source_id == 'CNRM-CM6-1'] +``` + +Another option for looking at the subset for problematic key would be (returns a pandas dataframe): + +```python +cat['OMIP.CNRM-CERFACS.CNRM-CM6-1.omip1.Omon.gn'] +``` + +Here, we focus on the `time_range` column - noticing that the last time step for `so` is `194912` while the last timestep for datasets with `thetao` is `199912`, with the dates formatted `YYYYMM`. + +Some of the files are missing here which is the fundamental issue. + +When `intake` attempts to concatenate these two datasets, it struggles and return an error, since the data is missing on the system. There is missing data here - reading variables separately is workaround, although it should be noted that at the end of the day, the missing files are the core problem. + +## Applying our "Workaround" + +To work around this problem, If you would still like to work with the data, you will need to read in datasets using separate queries as shown below + +```python +# Search and read in dataset for so +cat_so = col.search( + experiment_id=['omip1'], + variable_id=['so'], + table_id='Omon' +) +dset_dict_so = cat_so.to_dataset_dict() + +# Search and read in dataset for thetao +cat_thetao = col.search( + experiment_id=['omip1'], + variable_id=['thetao'], + table_id='Omon' +) +dset_dict_thetao = cat_thetao.to_dataset_dict() +``` + +Another option is to turn off aggregation within `to_dataset_dict()`, using the following syntax + +```python +dsets = cat.to_dataset_dict(aggregate=False) +``` + +This will return a dataset for **every** file in the archive and the keys in `dset_dict` will be constructed using all the fields in the catalog. + +Since `aggregate=False` will yield a large number of individual datasets, it might be overwhelming and difficult to determine the problem.