From 914de5cc659df728f16fab76537a4794ba9901c4 Mon Sep 17 00:00:00 2001
From: ctena <carles.tena@bsc.es>
Date: Wed, 6 Mar 2024 12:15:37 +0100
Subject: [PATCH 1/5] Added new tutorial 6.5.Add_new_variables.ipynb

---
 .../6.Others/6.5.Add_new_variables.ipynb      | 192 ++++++++++++++++++
 1 file changed, 192 insertions(+)
 create mode 100644 tutorials/6.Others/6.5.Add_new_variables.ipynb

diff --git a/tutorials/6.Others/6.5.Add_new_variables.ipynb b/tutorials/6.Others/6.5.Add_new_variables.ipynb
new file mode 100644
index 0000000..04c5c48
--- /dev/null
+++ b/tutorials/6.Others/6.5.Add_new_variables.ipynb
@@ -0,0 +1,192 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# How to add new variables"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from nes import *\n",
+    "import numpy as np\n",
+    "import matplotlib\n",
+    "import matplotlib.pyplot as plt\n",
+    "import geopandas as gpd"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%matplotlib inline"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "original_file_path = \"/gpfs/projects/bsc32/models/NES_tutorial_data/MONARCH_d01_2022111512.nc\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 1. Open original file"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Open file with only the metadata\n",
+    "nessy = open_netcdf(original_file_path, parallel_method='Y')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Load variables data\n",
+    "nessy.keep_vars(['NO2'])  # If you avoid this part all variables will be loaded\n",
+    "nessy.load()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 2. Create new variables"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 2.1. Create variable my modifying an existen one"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from copy import deepcopy\n",
+    "\n",
+    "# Copy the base variable and all the metadata\n",
+    "nessy.variables['new_var1'] = deepcopy(nessy.variables['NO2'])\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Modify the data and the metadata\n",
+    "nessy.variables['new_var1']['data'] *= 2\n",
+    "nessy.variables['new_var1']['long_name'] = 'Double NO2'\n",
+    "nessy.variables['new_var1']['standard_name'] = 'Invented_name'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Create the new file\n",
+    "nessy.to_netcdf('new_var1.nc')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 2.1. Create variable from scratch"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "nessy = open_netcdf(original_file_path, parallel_method='Y')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Remove all variables information to keep only the metadata\n",
+    "nessy.variables = {}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Create metadata\n",
+    "nessy.variables['new_var2'] = {'data': None,\n",
+    "                               'units': 'kg.m-2',\n",
+    "                               'description': 'new variable from scratch',\n",
+    "                               'short_name': 'newvar2',\n",
+    "                              }\n",
+    "\n",
+    "# Fill the data\n",
+    "shape = (len(nessy.time), len(nessy.lev['data']), nessy.lat['data'].shape[0], nessy.lon['data'].shape[-1])\n",
+    "nessy.variables['new_var2']['data'] = np.random.rand(*shape)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "nessy.to_netcdf('new_var2.nc')"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "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.7.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
-- 
GitLab


From 368b54c36596bed75e91f57d2b48dd15a559690c Mon Sep 17 00:00:00 2001
From: ctena <carles.tena@bsc.es>
Date: Fri, 15 Mar 2024 12:56:04 +0100
Subject: [PATCH 2/5] Added new functionalities for vertical extrapolation

---
 CHANGELOG.rst                                 |   1 +
 nes/methods/vertical_interpolation.py         | 179 +++++++++--
 nes/nc_projections/default_nes.py             |  27 +-
 ...ynb => 4.1.1.Vertical_Interpolation.ipynb} |   0
 ...Vertical_Interpolation_Extrapolation.ipynb | 294 ++++++++++++++++++
 5 files changed, 470 insertions(+), 31 deletions(-)
 rename tutorials/4.Interpolation/{4.1.Vertical_Interpolation.ipynb => 4.1.1.Vertical_Interpolation.ipynb} (100%)
 create mode 100644 tutorials/4.Interpolation/4.1.2.Vertical_Interpolation_Extrapolation.ipynb

diff --git a/CHANGELOG.rst b/CHANGELOG.rst
index 9979f7a..b163242 100644
--- a/CHANGELOG.rst
+++ b/CHANGELOG.rst
@@ -17,6 +17,7 @@ CHANGELOG
   * Documentation
   * Removed negative values on the horizontal interpolation due to unmapped NaNs values.
   * Improved load_nes.py removing redundant code
+  * New functionalities for vertical extrapolation. (`#74 <https://earth.bsc.es/gitlab/es/NES/-/issues/74>`_)
   * Bugfix:
 
     * Vertical interpolation for descendant level values (Pressure) (`#71 <https://earth.bsc.es/gitlab/es/NES/-/issues/71>`_)
diff --git a/nes/methods/vertical_interpolation.py b/nes/methods/vertical_interpolation.py
index 1605ed7..55f9389 100644
--- a/nes/methods/vertical_interpolation.py
+++ b/nes/methods/vertical_interpolation.py
@@ -26,7 +26,69 @@ def add_4d_vertical_info(self, info_to_add):
     return None
 
 
-def interpolate_vertical(self, new_levels, new_src_vertical=None, kind='linear', extrapolate=None, info=None,
+def parse_extrapolate(extrapolate) -> tuple:
+    """
+    Parses the 'extrapolate' parameter and returns a tuple representing the extrapolation options.
+
+    Parameters
+    ----------
+    extrapolate : bool or tuple or None or number or NaN
+        If bool:
+            - If True, both extrapolation options are set to 'extrapolate'.
+            - If False, extrapolation options are set to ('min', 'max').
+        If tuple:
+            - The first element represents the extrapolation option for the lower bound.
+            - The second element represents the extrapolation option for the upper bound.
+            - If any element is bool:
+                - If True, it represents 'extrapolate'.
+                - If False:
+                    - If it's the first element, it represents 'min'.
+                    - If it's the second element, it represents 'max'.
+            - If any element is None, it is replaced with numpy.nan.
+            - Other numeric values are kept as they are.
+            - If any element is NaN, it is kept as NaN.
+        If None:
+            - Both extrapolation options are set to ('min', 'max').
+        If number:
+            - Both extrapolation options are set to the provided number.
+        If NaN:
+            - Both extrapolation options are set to NaN.
+
+    Returns
+    -------
+    tuple
+        A tuple representing the extrapolation options. If the input is invalid, it returns ('extrapolate', 'extrapolate').
+    """
+    if isinstance(extrapolate, bool):
+        if extrapolate:
+            extrapolate_options = ('extrapolate', 'extrapolate')
+        else:
+            extrapolate_options = ('min', 'max')
+    elif isinstance(extrapolate, tuple):
+        extrapolate_options = [None, None]
+        for i in range(len(extrapolate)):
+            if isinstance(extrapolate[i], bool):
+                if extrapolate[i]:
+                    extrapolate_options[i] = 'extrapolate'
+                else:
+                    if i == 0:
+                        extrapolate_options[i] = 'min'
+                    else:
+                        extrapolate_options[i] = 'max'
+            elif extrapolate[i] is None:
+                extrapolate_options[i] = np.nan
+            else:
+                extrapolate_options[i] = extrapolate[i]
+        extrapolate_options = tuple(extrapolate_options)
+    elif extrapolate is None:
+        extrapolate_options = ('min', 'max')
+    else:
+        extrapolate_options = (extrapolate, extrapolate)
+
+    return extrapolate_options
+
+
+def interpolate_vertical(self, new_levels, new_src_vertical=None, kind='linear', extrapolate_options=False, info=None,
                          overwrite=False):
     """
     Vertical interpolation.
@@ -42,14 +104,35 @@ def interpolate_vertical(self, new_levels, new_src_vertical=None, kind='linear',
         the vertical data.
     kind : str
         Vertical methods type.
-    extrapolate : None, tuple, str
-        Extrapolate method (for non linear operations).
+    extrapolate_options : bool or tuple or None or number or NaN
+        If bool:
+            - If True, both extrapolation options are set to 'extrapolate'.
+            - If False, extrapolation options are set to ('min', 'max').
+        If tuple:
+            - The first element represents the extrapolation option for the lower bound.
+            - The second element represents the extrapolation option for the upper bound.
+            - If any element is bool:
+                - If True, it represents 'extrapolate'.
+                - If False:
+                    - If it's the first element, it represents 'min'.
+                    - If it's the second element, it represents 'max'.
+            - If any element is None, it is replaced with numpy.nan.
+            - Other numeric values are kept as they are.
+            - If any element is NaN, it is kept as NaN.
+        If None:
+            - Both extrapolation options are set to ('min', 'max').
+        If number:
+            - Both extrapolation options are set to the provided number.
+        If NaN:
+            - Both extrapolation options are set to NaN.
     info: None, bool
         Indicates if you want to print extra information.
     overwrite: bool
         Indicates if you want to compute the vertical interpolation in the same object or not.
     """
-    
+    extrapolate_options = parse_extrapolate(extrapolate_options)
+    do_extrapolation = 'extrapolate' in extrapolate_options
+
     if len(self.lev) == 1:
         raise RuntimeError("1D data cannot be vertically interpolated.")
     if not overwrite:
@@ -126,7 +209,12 @@ def interpolate_vertical(self, new_levels, new_src_vertical=None, kind='linear',
                     sys.stdout.flush()
                 for j in range(ny):
                     for i in range(nx):
-                        curr_level_values = src_levels[t, :, j, i]
+                        if len(src_levels.shape) == 1:
+                            # To use 1D level information
+                            curr_level_values = src_levels
+                        else:
+                            # To use 4D level data
+                            curr_level_values = src_levels[t, :, j, i]
                         try:
                             # Check if all values are identical or masked
                             if ((isinstance(curr_level_values, np.ndarray) and
@@ -136,15 +224,24 @@ def interpolate_vertical(self, new_levels, new_src_vertical=None, kind='linear',
                                 kind = 'slinear'
                             else:
                                 kind = kind  # 'cubic'
-                            if extrapolate is None:
+
+                            # Filtering filling values to extrapolation
+                            fill_value = [np.nan, np.nan]
+                            if 'min' in extrapolate_options:
+                                if ascendant:
+                                    fill_value[0] = np.float64(self.variables[var_name]['data'][t, 0, j, i])
+                                else:
+                                    fill_value[0] = np.float64(self.variables[var_name]['data'][t, -1, j, i])
+                            else:
+                                fill_value[0] = extrapolate_options[0]
+                            if 'max' in extrapolate_options:
                                 if ascendant:
-                                    fill_value = (np.float64(self.variables[var_name]['data'][t, 0, j, i]),
-                                                  np.float64(self.variables[var_name]['data'][t, -1, j, i]))
+                                    fill_value[1] = np.float64(self.variables[var_name]['data'][t, -1, j, i])
                                 else:
-                                    fill_value = (np.float64(self.variables[var_name]['data'][t, -1, j, i]),
-                                                  np.float64(self.variables[var_name]['data'][t, 0, j, i]))
+                                    fill_value[1] = np.float64(self.variables[var_name]['data'][t, 0, j, i])
                             else:
-                                fill_value = extrapolate
+                                fill_value[1] = extrapolate_options[1]
+                            fill_value = tuple(fill_value)
 
                             # We force the methods with float64 to avoid negative values
                             # We don't know why the negatives appears with float34
@@ -155,24 +252,50 @@ def interpolate_vertical(self, new_levels, new_src_vertical=None, kind='linear',
                                 # 4D vertical component
                                 src_levels_aux = src_levels[t, :, j, i]
 
-                            if kind == 'linear' and ascendant:
+                            if kind == 'linear' and ascendant and not do_extrapolation:
                                 dst_data[t, :, j, i] = np.array(
                                     np.interp(new_levels,
                                               np.array(src_levels_aux, dtype=np.float64),
-                                              np.array(self.variables[var_name]['data'][t, :, j, i], dtype=np.float64)),
+                                              np.array(self.variables[var_name]['data'][t, :, j, i], dtype=np.float64),
+                                              left=fill_value[0], right=fill_value[1]),
                                     dtype=self.variables[var_name]['data'].dtype)
                             else:
-                                dst_data[t, :, j, i] = np.array(
-                                    interp1d(np.array(src_levels_aux, dtype=np.float64),
-                                             np.array(self.variables[var_name]['data'][t, :, j, i], dtype=np.float64),
-                                             kind=kind,
-                                             bounds_error=False,
-                                             fill_value=fill_value)(new_levels),
-                                    dtype=self.variables[var_name]['data'].dtype)
+                                if not do_extrapolation:
+                                    dst_data[t, :, j, i] = np.array(
+                                        interp1d(np.array(src_levels_aux, dtype=np.float64),
+                                                 np.array(self.variables[var_name]['data'][t, :, j, i], dtype=np.float64),
+                                                 kind=kind,
+                                                 bounds_error=False,
+                                                 fill_value=fill_value)(new_levels),
+                                        dtype=self.variables[var_name]['data'].dtype)
+                                else:
+                                    # If extrapolation first we need to extrapolate all (below & above)
+                                    dst_data[t, :, j, i] = np.array(
+                                        interp1d(np.array(src_levels_aux, dtype=np.float64),
+                                                 np.array(self.variables[var_name]['data'][t, :, j, i],
+                                                          dtype=np.float64),
+                                                 kind=kind,
+                                                 bounds_error=False,
+                                                 fill_value='extrapolate')(new_levels),
+                                        dtype=self.variables[var_name]['data'].dtype)
+                                    # Check values below the lower vertical level
+                                    if fill_value[0] != 'extrapolate':
+                                        if ascendant:
+                                            idx_bellow = np.where(new_levels < src_levels_aux[0])
+                                        else:
+                                            idx_bellow = np.where(new_levels > src_levels_aux[0])
+                                        dst_data[t, idx_bellow, j, i] = fill_value[0]
+                                    # Check values above the upper vertical level
+                                    if fill_value[1] != 'extrapolate':
+                                        if ascendant:
+                                            idx_above = np.where(new_levels > src_levels_aux[-1])
+                                        else:
+                                            idx_above = np.where(new_levels < src_levels_aux[-1])
+                                        dst_data[t, idx_above, j, i] = fill_value[1]
                         except Exception as e:
                             print("time lat lon", t, j, i)
                             print("***********************")
-                            print("LEVELS", np.array(src_levels[t, :, j, i], dtype=np.float64))
+                            print("LEVELS", src_levels_aux)
                             print("DATA", np.array(self.variables[var_name]['data'][t, :, j, i], dtype=np.float64))
                             print("METHOD", kind)
                             print("FILL_VALUE", fill_value)
@@ -191,13 +314,15 @@ def interpolate_vertical(self, new_levels, new_src_vertical=None, kind='linear',
         if flip:
             self.reverse_level_direction()
         new_lev_info['positive'] = self._lev['positive']
-    for var_attr, attr_info in self.variables[self.vertical_var_name].items():
-        if var_attr not in ['data', 'dimensions', 'crs', 'grid_mapping']:
-            new_lev_info[var_attr] = copy(attr_info)
-    self.set_levels(new_lev_info)
 
-    self.free_vars(self.vertical_var_name)
-    self.vertical_var_name = None
+    if self.vertical_var_name is not None:
+        for var_attr, attr_info in self.variables[self.vertical_var_name].items():
+            if var_attr not in ['data', 'dimensions', 'crs', 'grid_mapping']:
+                new_lev_info[var_attr] = copy(attr_info)
+        self.free_vars(self.vertical_var_name)
+        self.vertical_var_name = None
+
+    self.set_levels(new_lev_info)
 
     # Remove original file information
     self.__ini_path = None
diff --git a/nes/nc_projections/default_nes.py b/nes/nc_projections/default_nes.py
index 6c4ad49..8536af4 100644
--- a/nes/nc_projections/default_nes.py
+++ b/nes/nc_projections/default_nes.py
@@ -3608,14 +3608,33 @@ class Nes(object):
         self : Nes
             Source Nes object.
         new_levels : List
-            New vertical levels.
+            List of new vertical levels.
         new_src_vertical : nes.Nes, str
             Nes object with the vertical information as variable or str with the path to the NetCDF file that contains
             the vertical data.
         kind : str
             Vertical methods type.
-        extrapolate : None, tuple, str
-            Extrapolate method (for non linear operations).
+        extrapolate : bool or tuple or None or number or NaN
+            If bool:
+                - If True, both extrapolation options are set to 'extrapolate'.
+                - If False, extrapolation options are set to ('min', 'max').
+            If tuple:
+                - The first element represents the extrapolation option for the lower bound.
+                - The second element represents the extrapolation option for the upper bound.
+                - If any element is bool:
+                    - If True, it represents 'extrapolate'.
+                    - If False:
+                        - If it's the first element, it represents 'min'.
+                        - If it's the second element, it represents 'max'.
+                - If any element is None, it is replaced with numpy.nan.
+                - Other numeric values are kept as they are.
+                - If any element is NaN, it is kept as NaN.
+            If None:
+                - Both extrapolation options are set to ('min', 'max').
+            If number:
+                - Both extrapolation options are set to the provided number.
+            If NaN:
+                - Both extrapolation options are set to NaN.
         info: None, bool
             Indicates if you want to print extra information.
         overwrite: bool
@@ -3623,7 +3642,7 @@ class Nes(object):
         """
 
         return vertical_interpolation.interpolate_vertical(
-            self, new_levels, new_src_vertical=new_src_vertical, kind=kind, extrapolate=extrapolate, info=info,
+            self, new_levels, new_src_vertical=new_src_vertical, kind=kind, extrapolate_options=extrapolate, info=info,
             overwrite=overwrite)
 
     def interpolate_horizontal(self, dst_grid, weight_matrix_path=None, kind='NearestNeighbour', n_neighbours=4,
diff --git a/tutorials/4.Interpolation/4.1.Vertical_Interpolation.ipynb b/tutorials/4.Interpolation/4.1.1.Vertical_Interpolation.ipynb
similarity index 100%
rename from tutorials/4.Interpolation/4.1.Vertical_Interpolation.ipynb
rename to tutorials/4.Interpolation/4.1.1.Vertical_Interpolation.ipynb
diff --git a/tutorials/4.Interpolation/4.1.2.Vertical_Interpolation_Extrapolation.ipynb b/tutorials/4.Interpolation/4.1.2.Vertical_Interpolation_Extrapolation.ipynb
new file mode 100644
index 0000000..8b3f5e6
--- /dev/null
+++ b/tutorials/4.Interpolation/4.1.2.Vertical_Interpolation_Extrapolation.ipynb
@@ -0,0 +1,294 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Vertical interpolation - Extrapolation options"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from nes import *\n",
+    "import matplotlib.pyplot as plt\n",
+    "from datetime import datetime\n",
+    "import numpy as np\n",
+    "\n",
+    "%matplotlib inline"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ascendant = True"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Creating base"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "var_name = 'var1'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "lat_orig = 33.0\n",
+    "lon_orig = -15.0\n",
+    "inc_lat = 1.0\n",
+    "inc_lon = 1.0\n",
+    "n_lat = 13\n",
+    "n_lon = 25\n",
+    "\n",
+    "nessy = create_nes(info=False, projection='regular', \n",
+    "                   lat_orig=lat_orig, lon_orig=lon_orig, \n",
+    "                   inc_lat=inc_lat, inc_lon=inc_lon, \n",
+    "                   n_lat=n_lat, n_lon=n_lon)\n",
+    "\n",
+    "nessy.set_time([datetime(year=1986, month=11, day=29)])\n",
+    "nessy.set_levels({'data': (np.linspace(0, 2*np.pi, 10) * 10) + 100, 'units': 'm'})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if not ascendant:\n",
+    "    nessy.lev['data'] = np.flip(nessy.lev['data'] )\n",
+    "    print(nessy.lev)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "nessy.variables[var_name] = {'data': None,\n",
+    "                             'units': 'kg.m-2',\n",
+    "                             'description': 'new variable from scratch',\n",
+    "                             'short_name': 'newvar2',\n",
+    "                            }\n",
+    "\n",
+    "# Fill the data\n",
+    "shape = (len(nessy.time), len(nessy.lev['data']), nessy.lat['data'].shape[0], nessy.lon['data'].shape[-1])\n",
+    "nessy.variables[var_name]['data'] = np.zeros(shape)\n",
+    "\n",
+    "for y in range(nessy.lat['data'].shape[0]):\n",
+    "    for x in range(nessy.lon['data'].shape[-1]):\n",
+    "        nessy.variables[var_name]['data'][0,:,y,x] = np.sin(nessy.lev['data'] -100) +1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig = plt.figure()\n",
+    "ax = fig.add_subplot(111)\n",
+    "\n",
+    "ax.plot(nessy.variables[var_name]['data'][0, :, 5, 5], \n",
+    "        nessy.lev['data'], \n",
+    "        color='black', marker='o', linestyle='--')\n",
+    "\n",
+    "ax.xaxis.tick_top()\n",
+    "ax.set_ylabel(\"Vertical Levels ({0})\".format(nessy.lev['units']))\n",
+    "ax.set_xlabel(var_name + \" ({0})\".format(nessy.variables[var_name]['units']))\n",
+    "\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Extrapolation options"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Do extrapolation below and avobe\n",
+    "# extrapolate = True  \n",
+    "\n",
+    "# Do not extrapolate -> below (min); avobe (max)\n",
+    "# extrapolate = False\n",
+    "# extrapolate = ('min', 'max')  # Same behaviour as extrapolate = False\n",
+    "\n",
+    "# Only avobe extrapolation:\n",
+    "# extrapolate = ('min', 'extrapolate')  # (False, True)\n",
+    "# extrapolate = (False, True)\n",
+    "extrapolate = (np.nan, 'extrapolate')  # (None, True)\n",
+    "# extrapolate = (None, True)\n",
+    "# extrapolate = (0, 'extrapolate')\n",
+    "\n",
+    "# Only below extrapolation:\n",
+    "# extrapolate = ('extrapolate', 'max')  # (False, True)\n",
+    "# extrapolate = (np.nan, 'extrapolate')  # (None, True)\n",
+    "# extrapolate = (0, 'extrapolate')\n",
+    "\n",
+    "# No extrapolation\n",
+    "# extrapolate = 0  # (0, 0)\n",
+    "# extrapolate = np.nan  # (np.nan, np.nan)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([  0,  10,  20,  30,  40,  50,  60,  70,  80,  90, 100, 110, 120,\n",
+       "       130, 140, 150, 160, 170, 180, 190, 200])"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "level_list = np.arange(0, 210, 10)\n",
+    "if not ascendant:\n",
+    "    level_list = np.flip(level_list)\n",
+    "level_list"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "interp_linear = nessy.interpolate_vertical(level_list, kind='linear', extrapolate=extrapolate)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "CPU times: user 134 ms, sys: 1.63 ms, total: 136 ms\n",
+      "Wall time: 134 ms\n"
+     ]
+    }
+   ],
+   "source": [
+    "%time interp_quad = nessy.interpolate_vertical(level_list, kind='quadratic', extrapolate=extrapolate)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig = plt.figure()\n",
+    "ax = fig.add_subplot(111)\n",
+    "\n",
+    "ax.plot(nessy.variables[var_name]['data'][0, :, 5, 5], \n",
+    "        nessy.lev['data'], \n",
+    "        color='black', marker='o', linestyle='--', label='original')\n",
+    "\n",
+    "ax.plot(interp_linear.variables[var_name]['data'][0, :, 5, 5], \n",
+    "        level_list, \n",
+    "        color='green', marker='o', label = 'linear')\n",
+    "\n",
+    "ax.plot(interp_quad.variables[var_name]['data'][0, :, 5, 5], \n",
+    "        level_list, \n",
+    "        color='yellow', marker='o', label = 'quadratic')\n",
+    "\n",
+    "ax.xaxis.tick_top()\n",
+    "ax.set_ylabel(\"Vertical Levels ({0})\".format(nessy.lev['units']))\n",
+    "ax.set_xlabel(var_name + \" ({0})\".format(nessy.variables[var_name]['units']))\n",
+    "\n",
+    "ax.legend()\n",
+    "plt.show()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "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.7.4"
+  },
+  "toc-autonumbering": true,
+  "vscode": {
+   "interpreter": {
+    "hash": "31f2aee4e71d21fbe5cf8b01ff0e069b9275f58929596ceb00d14d90e3e16cd6"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
-- 
GitLab


From 954d0384c2a5dcc5da246828d3abd8ecd7540a48 Mon Sep 17 00:00:00 2001
From: ctena <carles.tena@bsc.es>
Date: Fri, 15 Mar 2024 13:01:43 +0100
Subject: [PATCH 3/5] Update tutorial for the new functionalities for vertical
 extrapolation

---
 ...1.2.Vertical_Interpolation_Extrapolation.ipynb | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

diff --git a/tutorials/4.Interpolation/4.1.2.Vertical_Interpolation_Extrapolation.ipynb b/tutorials/4.Interpolation/4.1.2.Vertical_Interpolation_Extrapolation.ipynb
index 8b3f5e6..6174b1d 100644
--- a/tutorials/4.Interpolation/4.1.2.Vertical_Interpolation_Extrapolation.ipynb
+++ b/tutorials/4.Interpolation/4.1.2.Vertical_Interpolation_Extrapolation.ipynb
@@ -148,6 +148,7 @@
    "source": [
     "# Do extrapolation below and avobe\n",
     "# extrapolate = True  \n",
+    "# extrapolate = ('extrapolate', 'extrapolate')\n",
     "\n",
     "# Do not extrapolate -> below (min); avobe (max)\n",
     "# extrapolate = False\n",
@@ -156,14 +157,14 @@
     "# Only avobe extrapolation:\n",
     "# extrapolate = ('min', 'extrapolate')  # (False, True)\n",
     "# extrapolate = (False, True)\n",
-    "extrapolate = (np.nan, 'extrapolate')  # (None, True)\n",
+    "# extrapolate = (np.nan, 'extrapolate')  # (None, True)\n",
     "# extrapolate = (None, True)\n",
     "# extrapolate = (0, 'extrapolate')\n",
     "\n",
     "# Only below extrapolation:\n",
-    "# extrapolate = ('extrapolate', 'max')  # (False, True)\n",
-    "# extrapolate = (np.nan, 'extrapolate')  # (None, True)\n",
-    "# extrapolate = (0, 'extrapolate')\n",
+    "# extrapolate = ('extrapolate', 'max')  # (True, False)\n",
+    "# extrapolate = ('extrapolate', np.nan)  # (True, None)\n",
+    "# extrapolate = ('extrapolate', 0)\n",
     "\n",
     "# No extrapolation\n",
     "# extrapolate = 0  # (0, 0)\n",
@@ -212,8 +213,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "CPU times: user 134 ms, sys: 1.63 ms, total: 136 ms\n",
-      "Wall time: 134 ms\n"
+      "CPU times: user 120 ms, sys: 874 µs, total: 121 ms\n",
+      "Wall time: 121 ms\n"
      ]
     }
    ],
@@ -228,7 +229,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
-- 
GitLab


From f4398592c3b530b5b7706774eb08179df400a47e Mon Sep 17 00:00:00 2001
From: ctena <carles.tena@bsc.es>
Date: Fri, 15 Mar 2024 13:23:37 +0100
Subject: [PATCH 4/5] Added test for the new functionalities for vertical
 extrapolation

---
 tests/3.1-test_vertical_interp.py | 46 ++++++++++++++++++++++++++++++-
 1 file changed, 45 insertions(+), 1 deletion(-)

diff --git a/tests/3.1-test_vertical_interp.py b/tests/3.1-test_vertical_interp.py
index a285675..bbee578 100644
--- a/tests/3.1-test_vertical_interp.py
+++ b/tests/3.1-test_vertical_interp.py
@@ -15,7 +15,7 @@ parallel_method = 'T'
 
 result_path = "Times_test_3.1_vertical_interp_{0}_{1:03d}.csv".format(parallel_method, size)
 result = pd.DataFrame(index=['read', 'calculate'],
-                      columns=['3.1.1.Interp'])
+                      columns=['3.1.1.Interp', '3.1.1.Exterp'])
 
 # ======================================================================================================================
 # ===============================================  VERTICAL INTERPOLATION  =============================================
@@ -61,6 +61,50 @@ if rank == 0:
     print(result.loc[:, test_name])
 sys.stdout.flush()
 
+# ======================================================================================================================
+# ===============================================  VERTICAL INTERPOLATION  =============================================
+# ======================================================================================================================
+
+test_name = '3.1.1.Exterp'
+if rank == 0:
+    print(test_name)
+
+# READ
+st_time = timeit.default_timer()
+
+# Original path: /esarchive/exp/monarch/a4dd/original_files/000/2022111512/MONARCH_d01_2022111512.nc
+# Rotated grid from MONARCH
+source_path = '/gpfs/projects/bsc32/models/NES_tutorial_data/MONARCH_d01_2022111512.nc'
+
+# Read source data
+source_data = open_netcdf(path=source_path, info=True)
+
+# Select time and load variables
+source_data.keep_vars(['O3', 'mid_layer_height_agl'])
+source_data.load()
+
+comm.Barrier()
+result.loc['read', test_name] = timeit.default_timer() - st_time
+
+# INTERPOLATE
+st_time = timeit.default_timer()
+source_data.vertical_var_name = 'mid_layer_height_agl'
+level_list = [0., 50., 100., 250., 500., 750., 1000., 2000., 3000., 5000., 21000, 25000, 30000, 40000, 50000]
+interp_nes = source_data.interpolate_vertical(level_list, info=True, kind='linear', extrapolate=True)
+comm.Barrier()
+result.loc['calculate', test_name] = timeit.default_timer() - st_time
+
+# WRITE
+st_time = timeit.default_timer()
+interp_nes.to_netcdf(test_name.replace(' ', '_') + "_{0:03d}.nc".format(size))
+comm.Barrier()
+result.loc['write', test_name] = timeit.default_timer() - st_time
+
+comm.Barrier()
+if rank == 0:
+    print(result.loc[:, test_name])
+sys.stdout.flush()
+
 if rank == 0:
     result.to_csv(result_path)
     print("TEST PASSED SUCCESSFULLY!!!!!")
-- 
GitLab


From 0c6b45e3ec1777b19307f418772deedc05f299cc Mon Sep 17 00:00:00 2001
From: ctena <carles.tena@bsc.es>
Date: Wed, 20 Mar 2024 10:04:20 +0100
Subject: [PATCH 5/5] Vert_Extrapolation: min to bottom and max to top

---
 nes/methods/vertical_interpolation.py         | 31 ++++++++---------
 nes/nc_projections/default_nes.py             |  8 ++---
 ...Vertical_Interpolation_Extrapolation.ipynb | 33 +++++++++++--------
 3 files changed, 40 insertions(+), 32 deletions(-)

diff --git a/nes/methods/vertical_interpolation.py b/nes/methods/vertical_interpolation.py
index 55f9389..7260fdb 100644
--- a/nes/methods/vertical_interpolation.py
+++ b/nes/methods/vertical_interpolation.py
@@ -35,20 +35,20 @@ def parse_extrapolate(extrapolate) -> tuple:
     extrapolate : bool or tuple or None or number or NaN
         If bool:
             - If True, both extrapolation options are set to 'extrapolate'.
-            - If False, extrapolation options are set to ('min', 'max').
+            - If False, extrapolation options are set to ('bottom', 'top').
         If tuple:
             - The first element represents the extrapolation option for the lower bound.
             - The second element represents the extrapolation option for the upper bound.
             - If any element is bool:
                 - If True, it represents 'extrapolate'.
                 - If False:
-                    - If it's the first element, it represents 'min'.
-                    - If it's the second element, it represents 'max'.
+                    - If it's the first element, it represents 'bottom'.
+                    - If it's the second element, it represents 'top'.
             - If any element is None, it is replaced with numpy.nan.
             - Other numeric values are kept as they are.
             - If any element is NaN, it is kept as NaN.
         If None:
-            - Both extrapolation options are set to ('min', 'max').
+            - Both extrapolation options are set to (NaN, NaN).
         If number:
             - Both extrapolation options are set to the provided number.
         If NaN:
@@ -57,13 +57,14 @@ def parse_extrapolate(extrapolate) -> tuple:
     Returns
     -------
     tuple
-        A tuple representing the extrapolation options. If the input is invalid, it returns ('extrapolate', 'extrapolate').
+        A tuple representing the extrapolation options. If the input is invalid, it returns
+        ('extrapolate', 'extrapolate').
     """
     if isinstance(extrapolate, bool):
         if extrapolate:
             extrapolate_options = ('extrapolate', 'extrapolate')
         else:
-            extrapolate_options = ('min', 'max')
+            extrapolate_options = ('bottom', 'top')
     elif isinstance(extrapolate, tuple):
         extrapolate_options = [None, None]
         for i in range(len(extrapolate)):
@@ -72,16 +73,16 @@ def parse_extrapolate(extrapolate) -> tuple:
                     extrapolate_options[i] = 'extrapolate'
                 else:
                     if i == 0:
-                        extrapolate_options[i] = 'min'
+                        extrapolate_options[i] = 'bottom'
                     else:
-                        extrapolate_options[i] = 'max'
+                        extrapolate_options[i] = 'top'
             elif extrapolate[i] is None:
                 extrapolate_options[i] = np.nan
             else:
                 extrapolate_options[i] = extrapolate[i]
         extrapolate_options = tuple(extrapolate_options)
     elif extrapolate is None:
-        extrapolate_options = ('min', 'max')
+        extrapolate_options = ('bottom', 'top')
     else:
         extrapolate_options = (extrapolate, extrapolate)
 
@@ -107,20 +108,20 @@ def interpolate_vertical(self, new_levels, new_src_vertical=None, kind='linear',
     extrapolate_options : bool or tuple or None or number or NaN
         If bool:
             - If True, both extrapolation options are set to 'extrapolate'.
-            - If False, extrapolation options are set to ('min', 'max').
+            - If False, extrapolation options are set to ('bottom', 'top').
         If tuple:
             - The first element represents the extrapolation option for the lower bound.
             - The second element represents the extrapolation option for the upper bound.
             - If any element is bool:
                 - If True, it represents 'extrapolate'.
                 - If False:
-                    - If it's the first element, it represents 'min'.
-                    - If it's the second element, it represents 'max'.
+                    - If it's the first element, it represents 'bottom'.
+                    - If it's the second element, it represents 'top'.
             - If any element is None, it is replaced with numpy.nan.
             - Other numeric values are kept as they are.
             - If any element is NaN, it is kept as NaN.
         If None:
-            - Both extrapolation options are set to ('min', 'max').
+            - Both extrapolation options are set to (NaN, NaN).
         If number:
             - Both extrapolation options are set to the provided number.
         If NaN:
@@ -227,14 +228,14 @@ def interpolate_vertical(self, new_levels, new_src_vertical=None, kind='linear',
 
                             # Filtering filling values to extrapolation
                             fill_value = [np.nan, np.nan]
-                            if 'min' in extrapolate_options:
+                            if 'bottom' in extrapolate_options:
                                 if ascendant:
                                     fill_value[0] = np.float64(self.variables[var_name]['data'][t, 0, j, i])
                                 else:
                                     fill_value[0] = np.float64(self.variables[var_name]['data'][t, -1, j, i])
                             else:
                                 fill_value[0] = extrapolate_options[0]
-                            if 'max' in extrapolate_options:
+                            if 'top' in extrapolate_options:
                                 if ascendant:
                                     fill_value[1] = np.float64(self.variables[var_name]['data'][t, -1, j, i])
                                 else:
diff --git a/nes/nc_projections/default_nes.py b/nes/nc_projections/default_nes.py
index 8536af4..f81b8fe 100644
--- a/nes/nc_projections/default_nes.py
+++ b/nes/nc_projections/default_nes.py
@@ -3617,20 +3617,20 @@ class Nes(object):
         extrapolate : bool or tuple or None or number or NaN
             If bool:
                 - If True, both extrapolation options are set to 'extrapolate'.
-                - If False, extrapolation options are set to ('min', 'max').
+                - If False, extrapolation options are set to ('bottom', 'top').
             If tuple:
                 - The first element represents the extrapolation option for the lower bound.
                 - The second element represents the extrapolation option for the upper bound.
                 - If any element is bool:
                     - If True, it represents 'extrapolate'.
                     - If False:
-                        - If it's the first element, it represents 'min'.
-                        - If it's the second element, it represents 'max'.
+                        - If it's the first element, it represents 'bottom'.
+                        - If it's the second element, it represents 'top'.
                 - If any element is None, it is replaced with numpy.nan.
                 - Other numeric values are kept as they are.
                 - If any element is NaN, it is kept as NaN.
             If None:
-                - Both extrapolation options are set to ('min', 'max').
+                - Both extrapolation options are set to (NaN, NaN).
             If number:
                 - Both extrapolation options are set to the provided number.
             If NaN:
diff --git a/tutorials/4.Interpolation/4.1.2.Vertical_Interpolation_Extrapolation.ipynb b/tutorials/4.Interpolation/4.1.2.Vertical_Interpolation_Extrapolation.ipynb
index 6174b1d..128ba78 100644
--- a/tutorials/4.Interpolation/4.1.2.Vertical_Interpolation_Extrapolation.ipynb
+++ b/tutorials/4.Interpolation/4.1.2.Vertical_Interpolation_Extrapolation.ipynb
@@ -142,7 +142,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 11,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -150,19 +150,19 @@
     "# extrapolate = True  \n",
     "# extrapolate = ('extrapolate', 'extrapolate')\n",
     "\n",
-    "# Do not extrapolate -> below (min); avobe (max)\n",
+    "# Do not extrapolate -> below (bottom); avobe (top)\n",
     "# extrapolate = False\n",
-    "# extrapolate = ('min', 'max')  # Same behaviour as extrapolate = False\n",
+    "# extrapolate = ('bottom', 'top')  # Same behaviour as extrapolate = False\n",
     "\n",
     "# Only avobe extrapolation:\n",
-    "# extrapolate = ('min', 'extrapolate')  # (False, True)\n",
+    "extrapolate = ('bottom', 'extrapolate')  # (False, True)\n",
     "# extrapolate = (False, True)\n",
     "# extrapolate = (np.nan, 'extrapolate')  # (None, True)\n",
     "# extrapolate = (None, True)\n",
     "# extrapolate = (0, 'extrapolate')\n",
     "\n",
     "# Only below extrapolation:\n",
-    "# extrapolate = ('extrapolate', 'max')  # (True, False)\n",
+    "# extrapolate = ('extrapolate', 'top')  # (True, False)\n",
     "# extrapolate = ('extrapolate', np.nan)  # (True, None)\n",
     "# extrapolate = ('extrapolate', 0)\n",
     "\n",
@@ -173,7 +173,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 12,
    "metadata": {},
    "outputs": [
     {
@@ -183,7 +183,7 @@
        "       130, 140, 150, 160, 170, 180, 190, 200])"
       ]
      },
-     "execution_count": 9,
+     "execution_count": 12,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -197,7 +197,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 13,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -206,15 +206,15 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 14,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "CPU times: user 120 ms, sys: 874 µs, total: 121 ms\n",
-      "Wall time: 121 ms\n"
+      "CPU times: user 135 ms, sys: 2.57 ms, total: 138 ms\n",
+      "Wall time: 137 ms\n"
      ]
     }
    ],
@@ -224,12 +224,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 15,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -263,6 +263,13 @@
     "ax.legend()\n",
     "plt.show()"
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {
-- 
GitLab