anta-database 0.3.4__tar.gz → 0.3.5__tar.gz

{anta_database-0.3.4 → anta_database-0.3.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: anta_database
-Version: 0.3.4
+Version: 0.3.5
 Summary: SQLite database for the AntArchitecture Community Data
 Author: Antoine Hermant
 Author-email: antoine.hermant@etik.com

{anta_database-0.3.4 → anta_database-0.3.5}/anta_database/database/database.py

@@ -717,6 +717,7 @@ class Database:
         data_dir: Optional[str] = None,
         downsampling_factor: Optional[str] = None,
         disable_tqdm: bool = False,
+        fraction_depth: Optional[bool] = False,
     ) -> Generator[Tuple[pd.DataFrame, Dict]]:
         """
         Generates xarray Datasets from HDF5 files, one at a time, with lazy loading.
@@ -770,13 +771,21 @@ class Database:
                         irh_index = irh_index[0]
                         age_impl.append(age)
 
-                        df[int(age)] = ds[var][::downsampling_factor, irh_index]
+                        df[age] = ds[var][::downsampling_factor, irh_index]
+                        if fraction_depth:
+                            if 'ICE_THK' in ds.keys():
+                                df[age] *= 100/ds['ICE_THK'][::downsampling_factor]
+                            else:
+                                df[age] = np.nan
+                                # print(f'WARNING: flight line {file_md['flight_id']} in {file_md['dataset']} does not have ICE_THK, cannot compute fraction depth, will return NaN')
 
                 else:
                     if var in ds.keys():
                         var_impl.append(var)
                         df[var] = ds[var][::downsampling_factor]
 
+            if 0 < len(age_impl) <= 1:
+                age_impl = list(age_impl)[0]
             metadata = {
                 'dataset': file_md['dataset'],
                 'var': var_impl,

{anta_database-0.3.4 → anta_database-0.3.5}/anta_database/plotting/plotting.py

@@ -177,6 +177,7 @@ class Plotting:
             self,
             metadata: Union[None, Dict, 'MetadataResult'] = None,
             downsampling_factor: Optional[int] = None,
+            fraction_depth: Optional[bool] = False,
             title: Optional[str] = None,
             xlim: Optional[tuple] = (None, None),
             ylim: Optional[tuple] = (None, None),
@@ -197,6 +198,7 @@ class Plotting:
             color_by='var',
             metadata=metadata,
             downsampling_factor=downsampling_factor,
+            fraction_depth=fraction_depth,
             title=title,
             xlim=xlim,
             ylim=ylim,
@@ -261,6 +263,7 @@ class Plotting:
             self,
             metadata: Union[None, Dict, 'MetadataResult'] = None,
             elevation: Optional[bool] = False,
+            fraction_depth: Optional[bool] = False,
             downsampling_factor: Optional[int] = None,
             title: Optional[str] = None,
             xlim: Optional[tuple] = (None, None),
@@ -402,9 +405,8 @@ class Plotting:
             else:
                 var = var[0]
 
-
             all_dfs = []
-            for ds, _ in tqdm(self._db.data_generator(metadata, downsampling_factor=downsampling_factor, disable_tqdm=True), desc="Plotting", total=total_traces, unit='trace', disable=self._disable_tqdm):
+            for ds, _ in tqdm(self._db.data_generator(metadata, downsampling_factor=downsampling_factor, disable_tqdm=True, fraction_depth=fraction_depth), desc="Plotting", total=total_traces, unit='trace', disable=self._disable_tqdm):
                 all_dfs.append(ds)
             df = pd.concat(all_dfs)
 
@@ -478,37 +480,31 @@ class Plotting:
                         title = f'AntADatabase Basal Unit'
                 scatter = plt.scatter(df['PSX']/1000, df['PSY']/1000, c=df[var], cmap=cmap, s=marker_size, vmin=vmin, vmax=vmax, linewidths=0, rasterized=True)
 
-            elif var in ['IRH_DEPTH', 'IRH_FRAC_DEPTH']:
-                if var == 'IRH_DEPTH':
-                    label = f'IRH Depth [m]'
-                    if cmap == None:
-                        cmap = cmaps.torch_r
-                    extend = 'both'
-                    age = list(metadata['age'])
-                    if not title:
+            elif var in ['IRH_DEPTH']:
+                if cmap == None:
+                    cmap = cmaps.torch_r
+                extend = 'both'
+                age = list(metadata['age'])
+                if not title:
+                    if fraction_depth:
+                        title = f'AntADatabase IRH Fraction Depth'
+                    else:
                         title = f'AntADatabase IRH Depth'
-                    if len(age) > 1:
-                        print('WARNING: Multiple layers provided: ', age,
-                            '\nSelect a unique age for better results')
-                    elif len(age) == 0:
-                        print('No layer provided, please provide a valid age.')
-                        return
-                elif var == 'IRH_FRAC_DEPTH':
-                    if cmap == None:
-                        cmap = cmaps.torch_r
-                    extend = 'both'
-                    age = list(metadata['age'])
-                    if len(age) > 1:
-                        print('WARNING: Multiple layers provided: ', age,
-                            '\nSelect a unique age for better results')
-                    elif len(age) == 0:
-                        print('No layer provided, please provide a valid age.')
-                        return
-                    age = age[0]
+                if len(age) > 1:
+                    print('WARNING: Multiple layers provided: ', age,
+                        '\nSelect a unique age for better results')
+                elif len(age) == 0:
+                    print('No layer provided, please provide a valid age.')
+                    return
+                if fraction_depth:
                     label = r'IRH Fractional Depth [\%]'
+                    if vmin is None: vmin = 0
+                    if vmax is None: vmax = 100
+                else:
+                    label = f'IRH Depth [m]'
 
                 for age in metadata['age']:
-                    scatter = plt.scatter(df['PSX']/1000, df['PSY']/1000, c=df[int(age)], cmap=cmap, s=marker_size, vmin=vmin, vmax=vmax, linewidths=0, rasterized=True)
+                    scatter = plt.scatter(df['PSX']/1000, df['PSY']/1000, c=df[age], cmap=cmap, s=marker_size, vmin=vmin, vmax=vmax, linewidths=0, rasterized=True)
 
         if color_by == 'transect_1D':
             flight_id = list(metadata['flight_id'])

{anta_database-0.3.4 → anta_database-0.3.5}/anta_database.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: anta_database
-Version: 0.3.4
+Version: 0.3.5
 Summary: SQLite database for the AntArchitecture Community Data
 Author: Antoine Hermant
 Author-email: antoine.hermant@etik.com

{anta_database-0.3.4 → anta_database-0.3.5}/anta_database.egg-info/SOURCES.txt

@@ -41,6 +41,7 @@ book/contact.md
 book/contribute.md
 book/intro.md
 book/logo.png
+book/pism_example.ipynb
 book/quick_start.ipynb
 book/references.bib
 book/requirements.txt

{anta_database-0.3.4 → anta_database-0.3.5}/book/_toc.yml

@@ -5,6 +5,7 @@ format: jb-book
 root: intro
 chapters:
 - file: quick_start
+- file: pism_example
 - file: advanced
 - file: contact
 - file: contribute

anta_database-0.3.5/book/pism_example.ipynb

@@ -0,0 +1,299 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "356c8b16",
+   "metadata": {},
+   "source": [
+    "# Model-data comparison (ex: PISM)\n",
+    "Example using the Parallel Ice Sheet Model\n",
+    "\n",
+    "PISM includes an englacial layer tracing scheme [(Born and Robinson 2021)](https://doi.org/10.5194/tc-15-4539-2021) since its version 2.1 [(PISM docs)](https://www.pism.io/docs/manual/modeling-choices/dynamics/age.html)\n",
+    "\n",
+    "This notebook shows how to make direct use of the AntADatabase and the anta_database module for comparing a model run with PISM and IRH data. It is not meant to be very efficient, but descriptive, and people should be able to take parts of the code to implement it in there diagnostic routines."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e050b262",
+   "metadata": {},
+   "source": [
+    "# 2D Layer mismatch"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "516011f7",
+   "metadata": {},
+   "source": [
+    "## PISM output\n",
+    "\n",
+    "This example is using output from a regional domain setup around Dome C, East Antarctica. Layers were traced to match the Cavitte et al. 2020 dataset.\n",
+    "Note that PISM time is in second since year 0, while the dated IRHs are in years before 1950. So one has to be careful with the time reference between the dated IRH and the model time.\n",
+    "PISM outputs the 'isochronal_layer_thickness' variable, which needs to be converted to isochronal depth. Then we select the layer of interest. \n",
+    "Here is with xarray, but one can use netCDF4:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "aaaef681",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import xarray as xr\n",
+    "import numpy as np\n",
+    "\n",
+    "pism_out = xr.open_dataset('/home/anthe/documents/data/isochrones/pism_output_example/edc_pism_output.nc', engine='netcdf4', decode_times=False).squeeze()\n",
+    "pism_out['isochronal_layer_depth'] = pism_out['isochronal_layer_thickness'].copy() # creating a new variable for layer depths of same shape of layer thicknesses\n",
+    "\n",
+    "for i in range(pism_out.deposition_time.size):\n",
+    "    pism_out['isochronal_layer_depth'][:,:,i] = pism_out.isochronal_layer_thickness.isel(deposition_time=slice(i, None)).sum(dim='deposition_time').values\n",
+    "\n",
+    "age = 38000 # note the age is different from the one used in Cavitte et al. 2020 due to different ice core age scale, please ignore\n",
+    "age_offset = -1950 # to account for difference between model time and age scale used for IRHs, the isochrones were seeded at age+1950, and the simulation ran until year 1950.\n",
+    "age_seconds = -(age+age_offset)*3600*24*365\n",
+    "pism_layer = pism_out.isochronal_layer_depth.sel(deposition_time=age_seconds).values.flatten()\n",
+    "X_pism, Y_pism = np.meshgrid(pism_out.x, pism_out.y)\n",
+    "pism_points = np.column_stack((X_pism.flatten(), Y_pism.flatten()))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d4ec0831",
+   "metadata": {},
+   "source": [
+    "## Query the AntADatabase\n",
+    "\n",
+    "One can query the Database and fetch the files containing the data to compare with:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8fc030f2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from anta_database import Database\n",
+    "\n",
+    "db = Database('/home/anthe/documents/data/isochrones/AntADatabase/')\n",
+    "db.filter_out(flight_id=['%RAID%', '2H%', '2V%', 'HR%', 'BH%', 'H4%'])\n",
+    "query = db.query(dataset='Cavitte_2020', age='38100') # compare with 38.1 ka layer\n",
+    "\n",
+    "irh_files = db.get_files()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "851e80e6",
+   "metadata": {},
+   "source": [
+    "## Interpolate PISM\n",
+    "\n",
+    "Next we loop through the IRH flight line files, interpolate the PISM isochronal layer depth on each flight line coordinates and compute the difference in depth. We concatenate the results in a DataFrame for plotting. Here we show both with xarray, which is provides a convenient interface with the data, and with h5py, which is much faster:"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f23c5879",
+   "metadata": {},
+   "source": [
+    "### xarray"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5a4db052",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from scipy.interpolate import griddata\n",
+    "import pandas as pd\n",
+    "\n",
+    "all_psx = []\n",
+    "all_psy = []\n",
+    "all_depth_diff = []\n",
+    "\n",
+    "for f in irh_files:\n",
+    "    irh = xr.open_dataset(f, engine='h5netcdf')\n",
+    "    for age in query['age']:\n",
+    "        irh_layer = irh.IRH_DEPTH.sel(IRH_AGE=int(age))\n",
+    "        fl_line_xy = np.column_stack((irh.PSX, irh.PSY))\n",
+    "        pism_depth_interp = griddata(pism_points, pism_layer, fl_line_xy, method='linear')\n",
+    "        depth_diff = pism_depth_interp - irh_layer\n",
+    "\n",
+    "        all_psx.extend(irh.PSX.values)\n",
+    "        all_psy.extend(irh.PSY.values)\n",
+    "        all_depth_diff.extend(depth_diff)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "92f4ea4c",
+   "metadata": {},
+   "source": [
+    "### h5py"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1001994c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import h5py\n",
+    "\n",
+    "all_psx = []\n",
+    "all_psy = []\n",
+    "all_depth_diff = []\n",
+    "\n",
+    "for f in irh_files:\n",
+    "    with h5py.File(f, 'r') as irh:\n",
+    "        irh_values = irh['IRH_AGE'][:]\n",
+    "        for age in query['age']:\n",
+    "            irh_index = np.where(irh_values == int(age))[0]\n",
+    "            irh_index = irh_index[0]\n",
+    "            irh_layer = irh['IRH_DEPTH'][:, irh_index]\n",
+    "\n",
+    "            fl_line_xy = np.column_stack((irh['PSX'][:], irh['PSY'][:]))\n",
+    "            pism_depth_interp = griddata(pism_points, pism_layer, fl_line_xy, method='linear')\n",
+    "            depth_diff = pism_depth_interp - irh_layer\n",
+    "\n",
+    "            all_psx.extend(irh['PSX'][:])\n",
+    "            all_psy.extend(irh['PSY'][:])\n",
+    "            all_depth_diff.extend(depth_diff)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d384310a",
+   "metadata": {},
+   "source": [
+    "## Plotting"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2850b8a0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "# Create DataFrame\n",
+    "df = pd.DataFrame({\n",
+    "    'PSX': all_psx,\n",
+    "    'PSY': all_psy,\n",
+    "    'Depth_diff': all_depth_diff\n",
+    "})\n",
+    "\n",
+    "plt.figure(figsize=(10, 6))\n",
+    "sc = plt.scatter(\n",
+    "    df['PSX']/1000,\n",
+    "    df['PSY']/1000,\n",
+    "    c=df['Depth_diff'],\n",
+    "    cmap='RdBu_r',\n",
+    "    s=1,\n",
+    "    vmin=-100,\n",
+    "    vmax=100\n",
+    ")\n",
+    "plt.colorbar(sc, label='Iso Depth Difference (m)', extend='both')\n",
+    "plt.title('PISM vs Cavitte et al. 2020 Isochronal Depth Difference at 38.1 ka')\n",
+    "plt.xlabel('PSX [km]')\n",
+    "plt.ylabel('PSY [km]')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0fc0b7f0",
+   "metadata": {},
+   "source": [
+    "# 1D Transect mismatch \n",
+    "\n",
+    "It is also useful to simply plot the absolute isochronal layer depth in both PISM and the dataset as well as respective bed resolutions.\n",
+    "First we select a specific transect:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c5129bb3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "db.query(dataset='Cavitte_2020', flight_id='DC_LDC_DIVIDE')\n",
+    "\n",
+    "f = db.get_files()[0] \n",
+    "irh = xr.open_dataset(f, engine='h5netcdf')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6c3cc5de",
+   "metadata": {},
+   "source": [
+    "We select a few layers we want to plot for comparison (one can plot everything, but here there is a lot)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c64d8111",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "cavitte_ages = [10000, 29400, 38100, 46400, 73400, 96500, 121100, 166400, 277900]\n",
+    "irh_layers = irh.sel(IRH_AGE=cavitte_ages)\n",
+    "fl_line_xy = np.column_stack((irh.PSX, irh.PSY))\n",
+    "\n",
+    "pism_ages = [10000, 29300, 38000, 46600, 73100, 97400, 122800, 165200, 278000] # PISM ages differ slightly since I used a different ice core chronology for the dating than in the original Cavitte et al. 2020 paper\n",
+    "\n",
+    "plt.plot(irh.Distance/1000, irh_layers.IRH_DEPTH, label=irh_layers.IRH_AGE.values)\n",
+    "plt.plot(irh.Distance/1000, irh_layers.ICE_THK, color='gray', label='Bed Depth')\n",
+    "\n",
+    "for age in pism_ages:\n",
+    "    age = -(age+age_offset)*(3600*24*365)\n",
+    "    pism_layer = pism_out.isochronal_layer_depth.sel(deposition_time=age).values.flatten()\n",
+    "    pism_depth_interp = griddata(pism_points, pism_layer, fl_line_xy, method='linear')\n",
+    "    plt.plot(irh.Distance/1000, pism_depth_interp, linestyle='--', color='k')\n",
+    "plt.plot(0,0, color='black', linestyle='--', label='PISM Isochronal Layers')    \n",
+    "\n",
+    "pism_bed_depth_interp = griddata(pism_points, pism_out.thk.values.flatten(), fl_line_xy, method='linear')\n",
+    "plt.plot(irh.Distance/1000, pism_bed_depth_interp, color='gray', linestyle='--', label='PISM Bed Depth')    \n",
+    "\n",
+    "plt.ylim(3500, 0)\n",
+    "plt.xlabel('Distance along flight line [km]')\n",
+    "plt.ylabel('Isochronal Layer Depth [m]')\n",
+    "plt.title('Isochronal Layer Depth Comparison along Transect')\n",
+    "plt.legend(title='Cavitte et al. 2020 Ages [yr BP]', bbox_to_anchor=(1.05, 1), loc='upper left')\n",
+    "plt.show()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "processing",
+   "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.13.2"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

{anta_database-0.3.4 → anta_database-0.3.5}/book/quick_start.ipynb

@@ -22,7 +22,7 @@
    },
    "source": [
     "\n",
-    "This Python module is designed to query and visualized data in a AntADatabase folder. The latter has to be first compiled using published IRH datasets, or you can contact for downloading it.\n",
+    "This Python module is designed to query and visualized data in a AntADatabase folder. The latter is not published yet, but you can contact me for access.\n",
     "You can already have a look at this guide to have an idea of the features of this tool. This Jupyter Notebook can be directly downloaded (top bar) and ran locally (assuming you had downloaded or compiled the AntADatabase folder).\n"
    ]
   },
@@ -53,7 +53,7 @@
    "id": "867679c7",
    "metadata": {},
    "source": [
-    "Use the query() function to browse the database. 'query()' without argument will return all metadata contained in the database:"
+    "Use the query() function to browse the database. 'query()' without argument will return all the metadata from the database:"
    ]
   },
   {
@@ -79,7 +79,7 @@
     "- age: age(s) in yrs before present of the layer(s) of interest\n",
     "- region: region(s) of interest. E.g.: 'EAIS', 'WAIS'\n",
     "- IMBIE_basin: IMBIE basin(s) of interest. E.g.: 'G-H', 'Ap-B'.\n",
-    "- var: variables(s) of interest. Possible variables currently are: 'IRH_DEPTH', 'IRH_DENS', 'ICE_THK', 'BED_ELEV', 'SURF_ELEV'\n",
+    "- var: variables(s) of interest. Possible variables currently are: 'IRH_DEPTH', 'IRH_NUM', 'ICE_THK', 'BED_ELEV', 'SURF_ELEV'\n",
     "- flight_id: ID of a particular flight line. This is useful for explicit flight IDs such as 'DC_LDC_DIVIDE'\n",
     "\n",
     "One can also combine field queries as well as providing lists. Use '%' for searching by regular expressions. Here are a few examples:"
@@ -94,8 +94,10 @@
    "source": [
     "#Examples of queries:\n",
     "db.query(dataset='Cavitte_2020') # all data from Cavitte et al. 2020\n",
+    "db.query(institute='BAS') # all data that was acquired by BAS\n",
+    "db.query(project='OIB') # all data that was acquired during OIB campaigns\n",
     "db.query(age='38100') # all datasets with the 38.1ka isochrone\n",
-    "db.query(var='ICE_THK') # all datasets with IceThk variable\n",
+    "db.query(var='ICE_THK') # all datasets with ICE_THK variable\n",
     "db.query(IMBIE_basin='G-H') # all flight lines that cross the G-H basin\n",
     "db.query(flight_id='DC_LDC_DIVIDE') # all layers with the flight ID DC_LDC_DIVIDE\n",
     "db.query(flight_id='%WSB%') # all flight lines with WSB in the flight ID\n",
@@ -141,9 +143,9 @@
    "metadata": {},
    "source": [
     "Current implemented plotting functions are:\n",
-    "- plot.dataset(): plots locations of the data, with different colors for the different datasets (example above)\n",
+    "- plot.dataset(): plots locations of the data, with different colors for the different datasets\n",
     "- plot.institute(): plots locations of the data, with different colors for the different institutes\n",
-    "- plot.var(): color-coded scatter plot of the variable of insterest.\n",
+    "- plot.var(): color-coded scatter plot of the variable of interest.\n",
     "- plot.flight_id(): color-coded trace IDs. Useful for identifying specific traces of interest.\n",
     "- plot.transect_1D(): plots depths of the IRH and Bed along a single flight line \n",
     "\n",
@@ -166,6 +168,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
+    "# %matplotlib widget\n",
+    "%matplotlib inline\n",
     "results = db.query(IMBIE_basin='G-H')\n",
     "db.plot.dataset(results,\n",
     "                title='IRH data crossing the G-H IMBIE basin',\n",
@@ -188,7 +192,8 @@
    "id": "e735309e",
    "metadata": {},
    "source": [
-    "### Plot variables"
+    "### Plot variables\n",
+    "Example of plotting the IRH depth of a specific layer found across multiple datasets. Here we still select multiple ages close from each other, which could be attributed to the same layer (but different dating method used maybe). Note the warning in the case, but we can ignore it:"
    ]
   },
   {
@@ -199,11 +204,39 @@
     "lines_to_next_cell": 2
    },
    "outputs": [],
+   "source": [
+    "results = db.query(age=['37600', '38000', '38100', '38200', '38500'], var='IRH_DEPTH')\n",
+    "db.plot.var(results, title='AntArchitecture 38ka isochrone depth',\n",
+    "                downsampling_factor=10, # downscale the datasets n times, which makes little visual difference but lighter to plot\n",
+    "                xlim=(-500, 2400),\n",
+    "                ylim=(-2200, 2200),\n",
+    "                scale_factor=0.7, # adjust the size of the plot \n",
+    "                marker_size=1.2,\n",
+    "                # save='AntA_38ka_depth.png'\n",
+    "                )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e5ada192",
+   "metadata": {},
+   "source": [
+    "The above plot shows the absolute IRH depth relative to the ice surface as it is traced. It is often more informative to look at the IRH fraction depth: the depth of a layer relative to the ice thickness (IRH_DEPTH/ICE_THK*100). The fraction depth variable is not directly stored in the database to reduce disk usage. It is probably more efficient to compute it when needed. For this, use the option fraction_depth=True:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f29343c3",
+   "metadata": {},
+   "outputs": [],
    "source": [
     "# %matplotlib widget\n",
     "%matplotlib inline\n",
     "results = db.query(age=['37600', '38000', '38100', '38200', '38500'], var='IRH_DEPTH')\n",
-    "db.plot.var(results, title='AntArchitecture 38(.1)ka isochrone depth',\n",
+    "db.plot.var(results, \n",
+    "            fraction_depth=True,\n",
+    "            title='AntArchitecture 38ka isochrone fractional depth',\n",
     "                downsampling_factor=10, # downscale the datasets n times, which makes little visual difference but lighter to plot\n",
     "                xlim=(-500, 2400),\n",
     "                ylim=(-2200, 2200),\n",
@@ -213,6 +246,24 @@
     "                )"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "16b53478",
+   "metadata": {},
+   "source": [
+    "Note that if the variable ICE_THK is not present in a dataset, the fractional depth cannot be computed. In the case, NaN values will be generated instead without warning. So if you get a blank plot, please check if the dataset you queried contains the ICE_THK with db.query(dataset='Author_YYYY')."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ee330fa6",
+   "metadata": {},
+   "source": [
+    "### Plot datasets\n",
+    "\n",
+    "The IRH_NUM variable shows the number of traced isochrones (layers) per data point:"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -233,7 +284,9 @@
    "id": "9185b390",
    "metadata": {},
    "source": [
-    "### Plot flight IDs"
+    "### Plot flight IDs\n",
+    "\n",
+    "This plot is useful when we want to identify a specific flight line. One can then identify a flight line of interest on the 2D map, then plot the traced IRHs along the transect (see below):"
    ]
   },
   {
@@ -380,7 +433,7 @@
    "source": [
     "## Generate data from the database\n",
     "\n",
-    "Note: This part could be developed further in the future if there is the need. But for now, I am designing a separate Python module for constraining my ice sheet model of use, which is tailored to this database and other parallel processing libraries.\n",
+    "Note: This part could be developed further in the future if there is the need. But for now, I am designing a separate Python module for constraining my ice sheet model of use, which is tailored to this database and other parallel processing libraries. However, the [Model-comparison](https://antoinehermant.github.io/anta_database/pism_example.html) section already give some bits of code about it.\n",
     "\n",
     "The data_generator() function reads the query and 'yield' the dataframes for later use. It uses h5py to read all the data efficiently, and creates pandas dataframes, including all the variables and ages from the query. Columns for IRH DEPTH are named after the age. Basically, it reads the data with h5py as shown above and restructure it as bit, which can be easier to manage layers than with h5py dimensions.\n",
     "Here is a quick example of how this can be used for computing the mean layer depth:"
@@ -401,63 +454,24 @@
     "min_depth = float('inf')\n",
     "max_depth = float('-inf')\n",
     "for df, md in lazy_dfs:\n",
-    "    depth_values = df[int(md['age'][0])].values\n",
-    "    mean_depth_trs.append(np.mean(depth_values))\n",
-    "    min_depth = min(min_depth, min(depth_values))\n",
-    "    max_depth = max(max_depth, max(depth_values))\n",
+    "    depth_values = df[md['age']].values\n",
+    "    mean_depth_trs.append(np.nanmean(depth_values))\n",
+    "    min_depth = min(min_depth, np.nanmin(depth_values))\n",
+    "    max_depth = max(max_depth, np.nanmax(depth_values))\n",
     "\n",
     "\n",
-    "mean_depth = np.mean(mean_depth_trs)\n",
-    "std_dev = np.std(mean_depth_trs, ddof=1)\n",
+    "mean_depth = np.nanmean(mean_depth_trs)\n",
+    "std_dev = np.nanstd(mean_depth_trs, ddof=1)\n",
     "print(f\"The mean depth of the 38ka isochrone across East Antarctica is {round(mean_depth, 2)} m ranging from {round(min_depth, 2)} m to {round(max_depth, 2)} m.\")"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "6eb6930d",
+   "id": "04e0f078",
    "metadata": {},
    "source": [
-    "In the for loop, 'df' is an individual dataframe from the database, corresponding to a single layer of a single trace from a single dataset. The 'md' stores the unique metadata from the current 'df'. One can then associate the metadata with the current df, for example:"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "1051a179",
-   "metadata": {},
-   "source": [
-    "### Downscale the data\n",
-    "\n",
-    "The downsampling_factor argument in the data_generator reduces the size of the generated data by n times. This is useful when dealing with large data where the downscaling has a neglectable influence on the results.\n",
-    "Another solution, probably more straightforward, is the downsample_distance option, which allows to provide a distance in meters by which the data should be average along the transects:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "11bbf439",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import matplotlib.pyplot as plt\n",
-    "\n",
-    "results = db.query(dataset='Cavitte_2020', age='277900', flight_id='DC_LDC_DIVIDE')\n",
-    "original = db.data_generator(results)\n",
-    "downscale_10 = db.data_generator(results, downsampling_factor=100)\n",
-    "# downsampled_by_distance = db.data_generator(results, downsample_distance=5000)\n",
-    "\n",
-    "list = [original, downscale_10] #, downsampled_by_distance]\n",
-    "labels = ['original', 'downscale 100'] #, 'downsample 5km']\n",
-    "\n",
-    "for i, lazy_dfs in enumerate(list):\n",
-    "    for df, md in lazy_dfs:\n",
-    "        plt.plot(df.Distance, df[277900],label=labels[i], linestyle='--')\n",
-    "\n",
-    "plt.ylim(2600, 1800)\n",
-    "plt.xlabel('Distance along DC_LDC_DIVIDE (km)')\n",
-    "plt.ylabel('Depth (m)')\n",
-    "plt.legend()\n",
-    "plt.title('Different downscaling methods for Cavitte 2020 278ka along DC_LDC_DIVIDE')\n",
-    "plt.show()"
+    "Note that the data_generator returns a simple pandas DataFrame for each flight line, containing all queried variables and ages (if exist). The IRH depth of each layer is stored by columns named by age (so the IRH_DEPTH of the layer 38000 is df['38000']). As shown above, one can use the metadata (md) of the current dataframe (df) to get its age (md['age']).\n",
+    "Furthermore, if one needs the fraction depth, one can compute it using the ICE_THK (has to be included in the query), or the data_generator has this option: db.data_generator(results, fraction_depth=True). With this option, the layer columns will now be IRH fraction depth instead of absolute IRH_DEPTH."
    ]
   },
   {