{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "### **Description**\n", "\n", "Recipe showing how to conservatively transform the vertical coordinate system on which a variable is stored using annual-mean outputs from the National Oceanography Centre Near-Present-Day global eORCA1 configuration of NEMO forced using ERA-5 climatologically adjusted atmospheric forcing from 1976-2024.\n", "\n", "For more details on this model configuration and the available outputs, users can explore the Near-Present-Day documentation [here](https://noc-msm.github.io/NOC_Near_Present_Day/).\n", "\n", "---" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# -- Import required packages -- #\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", "import xarray as xr\n", "\n", "from nemo_cookbook import NEMODataTree\n", "\n", "xr.set_options(display_style=\"text\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### **Using Dask**\n", "\n", "**Optional: Connect Client to Dask Local Cluster to run analysis in parallel.**\n", "\n", "**Note:** Although using Dask is not strictly necessary for this simple example using eORCA1, if we wanted to generalise this recipe to eORCA025 or eORCA12 outputs, using Dask would be essential to avoid unnecessary slow calculations using only a single process." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# -- Initialise Dask Local Cluster -- #\n", "import os\n", "\n", "import dask\n", "from dask.distributed import Client, LocalCluster\n", "\n", "# Update temporary directory for Dask workers:\n", "dask.config.set({'temporary_directory': f\"{os.getcwd()}/dask_tmp\",\n", " 'local_directory': f\"{os.getcwd()}/dask_tmp\"\n", " })\n", "\n", "# Create Local Cluster:\n", "cluster = LocalCluster(n_workers=4, threads_per_worker=3, memory_limit='5GB')\n", "client = Client(cluster)\n", "client" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### **Accessing NEMO Model Data**\n", "**Let's begin by loading the grid variables for our eORCA1 NEMO model from the [JASMIN Object Store](https://help.jasmin.ac.uk/docs/short-term-project-storage/using-the-jasmin-object-store/)**. \n", "\n", "**Alternatively, you can replace the ``domain_filepath`` below with a file path to your domain_cfg.nc file and read this with xarray's ``open_dataset()`` function.**" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "text/html": [ "

<xarray.Dataset> Size: 709MB\n",
       "Dimensions:       (y: 331, x: 360, nav_lev: 75)\n",
       "Coordinates:\n",
       "  * nav_lev       (nav_lev) int64 600B 0 1 2 3 4 5 6 7 ... 68 69 70 71 72 73 74\n",
       "  * x             (x) int64 3kB 0 1 2 3 4 5 6 7 ... 353 354 355 356 357 358 359\n",
       "  * y             (y) int64 3kB 0 1 2 3 4 5 6 7 ... 324 325 326 327 328 329 330\n",
       "Data variables: (12/49)\n",
       "    atlmsk        (y, x) int8 119kB dask.array<chunksize=(331, 360), meta=np.ndarray>\n",
       "    bathy_metry   (y, x) float32 477kB dask.array<chunksize=(331, 360), meta=np.ndarray>\n",
       "    bottom_level  (y, x) int32 477kB dask.array<chunksize=(331, 360), meta=np.ndarray>\n",
       "    e1f           (y, x) float64 953kB dask.array<chunksize=(331, 360), meta=np.ndarray>\n",
       "    e1t           (y, x) float64 953kB dask.array<chunksize=(331, 360), meta=np.ndarray>\n",
       "    e1u           (y, x) float64 953kB dask.array<chunksize=(331, 360), meta=np.ndarray>\n",
       "    ...            ...\n",
       "    top_level     (y, x) int32 477kB dask.array<chunksize=(331, 360), meta=np.ndarray>\n",
       "    umask         (nav_lev, y, x) int8 9MB dask.array<chunksize=(75, 331, 360), meta=np.ndarray>\n",
       "    umaskutil     (y, x) int8 119kB dask.array<chunksize=(331, 360), meta=np.ndarray>\n",
       "    vmask         (nav_lev, y, x) int8 9MB dask.array<chunksize=(75, 331, 360), meta=np.ndarray>\n",
       "    vmaskutil     (y, x) int8 119kB dask.array<chunksize=(331, 360), meta=np.ndarray>\n",
       "    wmask         (nav_lev, y, x) int8 9MB dask.array<chunksize=(75, 331, 360), meta=np.ndarray>\n",
       "Attributes:\n",
       "    CfgName:    UNKNOWN\n",
       "    CfgIndex:   -999\n",
       "    Iperio:     1\n",
       "    Jperio:     0\n",
       "    NFold:      1\n",
       "    NFtype:     F\n",
       "    VertCoord:  zps\n",
       "    IsfCav:     0\n",
       "    file_name:  mesh_mask.nc\n",
       "    TimeStamp:  01/03/2025 22:19:49 -0000

" ], "text/plain": [ " Size: 709MB\n", "Dimensions: (y: 331, x: 360, nav_lev: 75)\n", "Coordinates:\n", " * nav_lev (nav_lev) int64 600B 0 1 2 3 4 5 6 7 ... 68 69 70 71 72 73 74\n", " * x (x) int64 3kB 0 1 2 3 4 5 6 7 ... 353 354 355 356 357 358 359\n", " * y (y) int64 3kB 0 1 2 3 4 5 6 7 ... 324 325 326 327 328 329 330\n", "Data variables: (12/49)\n", " atlmsk (y, x) int8 119kB dask.array\n", " bathy_metry (y, x) float32 477kB dask.array\n", " bottom_level (y, x) int32 477kB dask.array\n", " e1f (y, x) float64 953kB dask.array\n", " e1t (y, x) float64 953kB dask.array\n", " e1u (y, x) float64 953kB dask.array\n", " ... ...\n", " top_level (y, x) int32 477kB dask.array\n", " umask (nav_lev, y, x) int8 9MB dask.array\n", " umaskutil (y, x) int8 119kB dask.array\n", " vmask (nav_lev, y, x) int8 9MB dask.array\n", " vmaskutil (y, x) int8 119kB dask.array\n", " wmask (nav_lev, y, x) int8 9MB dask.array\n", "Attributes:\n", " CfgName: UNKNOWN\n", " CfgIndex: -999\n", " Iperio: 1\n", " Jperio: 0\n", " NFold: 1\n", " NFtype: F\n", " VertCoord: zps\n", " IsfCav: 0\n", " file_name: mesh_mask.nc\n", " TimeStamp: 01/03/2025 22:19:49 -0000" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Define directory path to ancillary files:\n", "domain_filepath = \"https://noc-msm-o.s3-ext.jc.rl.ac.uk/npd-eorca1-jra55v1/domain_cfg\"\n", "\n", "# Open eORCA1 NEMO model domain_cfg:\n", "ds_domain = xr.open_zarr(domain_filepath, consolidated=True, chunks={})\n", "\n", "ds_domain" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Next, we need to import the sea water conservative temperature and absolute salinity stored at T-points in a single dataset.**" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "text/html": [ "

<xarray.Dataset> Size: 9GB\n",
       "Dimensions:                (time_counter: 11, y: 331, x: 360, deptht: 75,\n",
       "                            axis_nbounds: 2)\n",
       "Coordinates:\n",
       "  * deptht                 (deptht) float32 300B 0.5058 1.556 ... 5.902e+03\n",
       "    nav_lat                (y, x) float64 953kB dask.array<chunksize=(331, 360), meta=np.ndarray>\n",
       "    nav_lon                (y, x) float64 953kB dask.array<chunksize=(331, 360), meta=np.ndarray>\n",
       "    time_centered          (time_counter) datetime64[ns] 88B dask.array<chunksize=(1,), meta=np.ndarray>\n",
       "  * time_counter           (time_counter) datetime64[ns] 88B 2000-07-02 ... 2...\n",
       "Dimensions without coordinates: y, x, axis_nbounds\n",
       "Data variables: (12/74)\n",
       "    berg_latent_heat_flux  (time_counter, y, x) float32 5MB dask.array<chunksize=(1, 331, 360), meta=np.ndarray>\n",
       "    deptht_bounds          (deptht, axis_nbounds) float32 600B dask.array<chunksize=(75, 2), meta=np.ndarray>\n",
       "    e3t                    (time_counter, deptht, y, x) float32 393MB dask.array<chunksize=(1, 75, 331, 360), meta=np.ndarray>\n",
       "    empmr                  (time_counter, y, x) float32 5MB dask.array<chunksize=(1, 331, 360), meta=np.ndarray>\n",
       "    evs                    (time_counter, y, x) float32 5MB dask.array<chunksize=(1, 331, 360), meta=np.ndarray>\n",
       "    ficeberg               (time_counter, y, x) float32 5MB dask.array<chunksize=(1, 331, 360), meta=np.ndarray>\n",
       "    ...                     ...\n",
       "    ttrd_qns_li            (time_counter, y, x) float32 5MB dask.array<chunksize=(1, 331, 360), meta=np.ndarray>\n",
       "    vohfcisf               (time_counter, deptht, y, x) float32 393MB dask.array<chunksize=(1, 75, 331, 360), meta=np.ndarray>\n",
       "    vohflisf               (time_counter, deptht, y, x) float32 393MB dask.array<chunksize=(1, 75, 331, 360), meta=np.ndarray>\n",
       "    vowflisf               (time_counter, deptht, y, x) float32 393MB dask.array<chunksize=(1, 75, 331, 360), meta=np.ndarray>\n",
       "    zos                    (time_counter, y, x) float32 5MB dask.array<chunksize=(1, 331, 360), meta=np.ndarray>\n",
       "    zossq                  (time_counter, y, x) float32 5MB dask.array<chunksize=(1, 331, 360), meta=np.ndarray>\n",
       "Attributes:\n",
       "    name:         OUTPUT/eORCA1_1y_grid_T\n",
       "    description:  ocean T grid variables\n",
       "    title:        ocean T grid variables\n",
       "    Conventions:  CF-1.6\n",
       "    timeStamp:    2024-Dec-09 10:28:01 GMT\n",
       "    uuid:         89824b34-5d44-4531-8344-fe1ce39fbb7b

" ], "text/plain": [ " Size: 9GB\n", "Dimensions: (time_counter: 11, y: 331, x: 360, deptht: 75,\n", " axis_nbounds: 2)\n", "Coordinates:\n", " * deptht (deptht) float32 300B 0.5058 1.556 ... 5.902e+03\n", " nav_lat (y, x) float64 953kB dask.array\n", " nav_lon (y, x) float64 953kB dask.array\n", " time_centered (time_counter) datetime64[ns] 88B dask.array\n", " * time_counter (time_counter) datetime64[ns] 88B 2000-07-02 ... 2...\n", "Dimensions without coordinates: y, x, axis_nbounds\n", "Data variables: (12/74)\n", " berg_latent_heat_flux (time_counter, y, x) float32 5MB dask.array\n", " deptht_bounds (deptht, axis_nbounds) float32 600B dask.array\n", " e3t (time_counter, deptht, y, x) float32 393MB dask.array\n", " empmr (time_counter, y, x) float32 5MB dask.array\n", " evs (time_counter, y, x) float32 5MB dask.array\n", " ficeberg (time_counter, y, x) float32 5MB dask.array\n", " ... ...\n", " ttrd_qns_li (time_counter, y, x) float32 5MB dask.array\n", " vohfcisf (time_counter, deptht, y, x) float32 393MB dask.array\n", " vohflisf (time_counter, deptht, y, x) float32 393MB dask.array\n", " vowflisf (time_counter, deptht, y, x) float32 393MB dask.array\n", " zos (time_counter, y, x) float32 5MB dask.array\n", " zossq (time_counter, y, x) float32 5MB dask.array\n", "Attributes:\n", " name: OUTPUT/eORCA1_1y_grid_T\n", " description: ocean T grid variables\n", " title: ocean T grid variables\n", " Conventions: CF-1.6\n", " timeStamp: 2024-Dec-09 10:28:01 GMT\n", " uuid: 89824b34-5d44-4531-8344-fe1ce39fbb7b" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Define directory path to model output files:\n", "gridT_url = \"https://noc-msm-o.s3-ext.jc.rl.ac.uk/npd-eorca1-jra55v1/T1y\"\n", "\n", "# Construct NEMO model T-grid dataset, including conservative temperature (degC):\n", "# (Combine 75 vertical levels into single chunk for transforming vertical coordinates with dask)\n", "ds_gridT = xr.open_zarr(gridT_url, consolidated=True, chunks={'deptht': 75}).sel(time_counter=slice('2000-01', '2010-12'))\n", "\n", "ds_gridT" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### **Creating a NEMODataTree**\n", "\n", "**Next, let's create a NEMODataTree to store our domain and T- & V-grid variables for the eORCA1 model.**" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "text/html": [ "

<xarray.DataTree 'NEMO model'>\n",
       "Group: /\n",
       "│   Dimensions:               (time_counter: 11, axis_nbounds: 2)\n",
       "│   Coordinates:\n",
       "│       time_centered         (time_counter) datetime64[ns] 88B dask.array<chunksize=(1,), meta=np.ndarray>\n",
       "│     * time_counter          (time_counter) datetime64[ns] 88B 2000-07-02 ... 20...\n",
       "│   Dimensions without coordinates: axis_nbounds\n",
       "│   Data variables:\n",
       "│       time_centered_bounds  (time_counter, axis_nbounds) datetime64[ns] 176B dask.array<chunksize=(1, 2), meta=np.ndarray>\n",
       "│       time_counter_bounds   (time_counter, axis_nbounds) datetime64[ns] 176B dask.array<chunksize=(1, 2), meta=np.ndarray>\n",
       "│   Attributes:\n",
       "│       nftype:   F\n",
       "│       iperio:   True\n",
       "├── Group: /gridT\n",
       "│       Dimensions:                (time_counter: 11, j: 331, i: 360, k: 75,\n",
       "│                                   axis_nbounds: 2)\n",
       "│       Coordinates:\n",
       "│         * deptht                 (k) float32 300B 0.5058 1.556 ... 5.698e+03 5.902e+03\n",
       "│           time_centered          (time_counter) datetime64[ns] 88B dask.array<chunksize=(1,), meta=np.ndarray>\n",
       "│           gphit                  (j, i) float64 953kB dask.array<chunksize=(331, 360), meta=np.ndarray>\n",
       "│           glamt                  (j, i) float64 953kB dask.array<chunksize=(331, 360), meta=np.ndarray>\n",
       "│         * k                      (k) int64 600B 1 2 3 4 5 6 7 ... 69 70 71 72 73 74 75\n",
       "│         * j                      (j) int64 3kB 1 2 3 4 5 6 ... 326 327 328 329 330 331\n",
       "│         * i                      (i) int64 3kB 1 2 3 4 5 6 ... 355 356 357 358 359 360\n",
       "│       Dimensions without coordinates: axis_nbounds\n",
       "│       Data variables: (12/80)\n",
       "│           berg_latent_heat_flux  (time_counter, j, i) float32 5MB dask.array<chunksize=(1, 331, 360), meta=np.ndarray>\n",
       "│           deptht_bounds          (k, axis_nbounds) float32 600B dask.array<chunksize=(75, 2), meta=np.ndarray>\n",
       "│           e3t                    (time_counter, k, j, i) float32 393MB dask.array<chunksize=(1, 75, 331, 360), meta=np.ndarray>\n",
       "│           empmr                  (time_counter, j, i) float32 5MB dask.array<chunksize=(1, 331, 360), meta=np.ndarray>\n",
       "│           evs                    (time_counter, j, i) float32 5MB dask.array<chunksize=(1, 331, 360), meta=np.ndarray>\n",
       "│           ficeberg               (time_counter, j, i) float32 5MB dask.array<chunksize=(1, 331, 360), meta=np.ndarray>\n",
       "│           ...                     ...\n",
       "│           e1t                    (j, i) float64 953kB dask.array<chunksize=(331, 360), meta=np.ndarray>\n",
       "│           e2t                    (j, i) float64 953kB dask.array<chunksize=(331, 360), meta=np.ndarray>\n",
       "│           top_level              (j, i) int32 477kB dask.array<chunksize=(331, 360), meta=np.ndarray>\n",
       "│           bottom_level           (j, i) int32 477kB dask.array<chunksize=(331, 360), meta=np.ndarray>\n",
       "│           tmask                  (k, j, i) int8 9MB dask.array<chunksize=(75, 331, 360), meta=np.ndarray>\n",
       "│           tmaskutil              (j, i) int8 119kB dask.array<chunksize=(331, 360), meta=np.ndarray>\n",
       "│       Attributes:\n",
       "│           nftype:   F\n",
       "│           iperio:   True\n",
       "├── Group: /gridU\n",
       "│       Dimensions:       (j: 331, i: 360, k: 75)\n",
       "│       Coordinates:\n",
       "│           gphiu         (j, i) float64 953kB dask.array<chunksize=(331, 360), meta=np.ndarray>\n",
       "│           glamu         (j, i) float64 953kB dask.array<chunksize=(331, 360), meta=np.ndarray>\n",
       "│         * k             (k) int64 600B 1 2 3 4 5 6 7 8 9 ... 68 69 70 71 72 73 74 75\n",
       "│         * j             (j) int64 3kB 1 2 3 4 5 6 7 8 ... 325 326 327 328 329 330 331\n",
       "│         * i             (i) float64 3kB 1.5 2.5 3.5 4.5 ... 357.5 358.5 359.5 360.5\n",
       "│       Data variables:\n",
       "│           e1u           (j, i) float64 953kB dask.array<chunksize=(331, 360), meta=np.ndarray>\n",
       "│           e2u           (j, i) float64 953kB dask.array<chunksize=(331, 360), meta=np.ndarray>\n",
       "│           umask         (k, j, i) int8 9MB dask.array<chunksize=(75, 331, 360), meta=np.ndarray>\n",
       "│           umaskutil     (j, i) int8 119kB dask.array<chunksize=(331, 360), meta=np.ndarray>\n",
       "│       Attributes:\n",
       "│           nftype:   F\n",
       "│           iperio:   True\n",
       "├── Group: /gridV\n",
       "│       Dimensions:       (j: 331, i: 360, k: 75)\n",
       "│       Coordinates:\n",
       "│           gphiv         (j, i) float64 953kB dask.array<chunksize=(331, 360), meta=np.ndarray>\n",
       "│           glamv         (j, i) float64 953kB dask.array<chunksize=(331, 360), meta=np.ndarray>\n",
       "│         * k             (k) int64 600B 1 2 3 4 5 6 7 8 9 ... 68 69 70 71 72 73 74 75\n",
       "│         * j             (j) float64 3kB 1.5 2.5 3.5 4.5 ... 328.5 329.5 330.5 331.5\n",
       "│         * i             (i) int64 3kB 1 2 3 4 5 6 7 8 ... 354 355 356 357 358 359 360\n",
       "│       Data variables:\n",
       "│           e1v           (j, i) float64 953kB dask.array<chunksize=(331, 360), meta=np.ndarray>\n",
       "│           e2v           (j, i) float64 953kB dask.array<chunksize=(331, 360), meta=np.ndarray>\n",
       "│           vmask         (k, j, i) int8 9MB dask.array<chunksize=(75, 331, 360), meta=np.ndarray>\n",
       "│           vmaskutil     (j, i) int8 119kB dask.array<chunksize=(331, 360), meta=np.ndarray>\n",
       "│       Attributes:\n",
       "│           nftype:   F\n",
       "│           iperio:   True\n",
       "├── Group: /gridW\n",
       "│       Dimensions:       (j: 331, i: 360, k: 75)\n",
       "│       Coordinates:\n",
       "│           gphit         (j, i) float64 953kB dask.array<chunksize=(331, 360), meta=np.ndarray>\n",
       "│           glamt         (j, i) float64 953kB dask.array<chunksize=(331, 360), meta=np.ndarray>\n",
       "│         * k             (k) float64 600B 0.5 1.5 2.5 3.5 4.5 ... 71.5 72.5 73.5 74.5\n",
       "│         * j             (j) int64 3kB 1 2 3 4 5 6 7 8 ... 325 326 327 328 329 330 331\n",
       "│         * i             (i) int64 3kB 1 2 3 4 5 6 7 8 ... 354 355 356 357 358 359 360\n",
       "│       Data variables:\n",
       "│           e1t           (j, i) float64 953kB dask.array<chunksize=(331, 360), meta=np.ndarray>\n",
       "│           e2t           (j, i) float64 953kB dask.array<chunksize=(331, 360), meta=np.ndarray>\n",
       "│           wmask         (k, j, i) int8 9MB dask.array<chunksize=(75, 331, 360), meta=np.ndarray>\n",
       "│           wmaskutil     (j, i) int8 119kB dask.array<chunksize=(331, 360), meta=np.ndarray>\n",
       "│       Attributes:\n",
       "│           nftype:   F\n",
       "│           iperio:   True\n",
       "└── Group: /gridF\n",
       "        Dimensions:       (j: 331, i: 360, k: 75)\n",
       "        Coordinates:\n",
       "            gphif         (j, i) float64 953kB dask.array<chunksize=(331, 360), meta=np.ndarray>\n",
       "            glamf         (j, i) float64 953kB dask.array<chunksize=(331, 360), meta=np.ndarray>\n",
       "          * k             (k) int64 600B 1 2 3 4 5 6 7 8 9 ... 68 69 70 71 72 73 74 75\n",
       "          * j             (j) float64 3kB 1.5 2.5 3.5 4.5 ... 328.5 329.5 330.5 331.5\n",
       "          * i             (i) float64 3kB 1.5 2.5 3.5 4.5 ... 357.5 358.5 359.5 360.5\n",
       "        Data variables:\n",
       "            e1f           (j, i) float64 953kB dask.array<chunksize=(331, 360), meta=np.ndarray>\n",
       "            e2f           (j, i) float64 953kB dask.array<chunksize=(331, 360), meta=np.ndarray>\n",
       "            fmask         (k, j, i) int8 9MB dask.array<chunksize=(75, 331, 360), meta=np.ndarray>\n",
       "            fmaskutil     (j, i) int8 119kB dask.array<chunksize=(331, 360), meta=np.ndarray>\n",
       "        Attributes:\n",
       "            nftype:   F\n",
       "            iperio:   True

" ], "text/plain": [ "\n", "Group: /\n", "│ Dimensions: (time_counter: 11, axis_nbounds: 2)\n", "│ Coordinates:\n", "│ time_centered (time_counter) datetime64[ns] 88B dask.array\n", "│ * time_counter (time_counter) datetime64[ns] 88B 2000-07-02 ... 20...\n", "│ Dimensions without coordinates: axis_nbounds\n", "│ Data variables:\n", "│ time_centered_bounds (time_counter, axis_nbounds) datetime64[ns] 176B dask.array\n", "│ time_counter_bounds (time_counter, axis_nbounds) datetime64[ns] 176B dask.array\n", "│ Attributes:\n", "│ nftype: F\n", "│ iperio: True\n", "├── Group: /gridT\n", "│ Dimensions: (time_counter: 11, j: 331, i: 360, k: 75,\n", "│ axis_nbounds: 2)\n", "│ Coordinates:\n", "│ * deptht (k) float32 300B 0.5058 1.556 ... 5.698e+03 5.902e+03\n", "│ time_centered (time_counter) datetime64[ns] 88B dask.array\n", "│ gphit (j, i) float64 953kB dask.array\n", "│ glamt (j, i) float64 953kB dask.array\n", "│ * k (k) int64 600B 1 2 3 4 5 6 7 ... 69 70 71 72 73 74 75\n", "│ * j (j) int64 3kB 1 2 3 4 5 6 ... 326 327 328 329 330 331\n", "│ * i (i) int64 3kB 1 2 3 4 5 6 ... 355 356 357 358 359 360\n", "│ Dimensions without coordinates: axis_nbounds\n", "│ Data variables: (12/80)\n", "│ berg_latent_heat_flux (time_counter, j, i) float32 5MB dask.array\n", "│ deptht_bounds (k, axis_nbounds) float32 600B dask.array\n", "│ e3t (time_counter, k, j, i) float32 393MB dask.array\n", "│ empmr (time_counter, j, i) float32 5MB dask.array\n", "│ evs (time_counter, j, i) float32 5MB dask.array\n", "│ ficeberg (time_counter, j, i) float32 5MB dask.array\n", "│ ... ...\n", "│ e1t (j, i) float64 953kB dask.array\n", "│ e2t (j, i) float64 953kB dask.array\n", "│ top_level (j, i) int32 477kB dask.array\n", "│ bottom_level (j, i) int32 477kB dask.array\n", "│ tmask (k, j, i) int8 9MB dask.array\n", "│ tmaskutil (j, i) int8 119kB dask.array\n", "│ Attributes:\n", "│ nftype: F\n", "│ iperio: True\n", "├── Group: /gridU\n", "│ Dimensions: (j: 331, i: 360, k: 75)\n", "│ Coordinates:\n", "│ gphiu (j, i) float64 953kB dask.array\n", "│ glamu (j, i) float64 953kB dask.array\n", "│ * k (k) int64 600B 1 2 3 4 5 6 7 8 9 ... 68 69 70 71 72 73 74 75\n", "│ * j (j) int64 3kB 1 2 3 4 5 6 7 8 ... 325 326 327 328 329 330 331\n", "│ * i (i) float64 3kB 1.5 2.5 3.5 4.5 ... 357.5 358.5 359.5 360.5\n", "│ Data variables:\n", "│ e1u (j, i) float64 953kB dask.array\n", "│ e2u (j, i) float64 953kB dask.array\n", "│ umask (k, j, i) int8 9MB dask.array\n", "│ umaskutil (j, i) int8 119kB dask.array\n", "│ Attributes:\n", "│ nftype: F\n", "│ iperio: True\n", "├── Group: /gridV\n", "│ Dimensions: (j: 331, i: 360, k: 75)\n", "│ Coordinates:\n", "│ gphiv (j, i) float64 953kB dask.array\n", "│ glamv (j, i) float64 953kB dask.array\n", "│ * k (k) int64 600B 1 2 3 4 5 6 7 8 9 ... 68 69 70 71 72 73 74 75\n", "│ * j (j) float64 3kB 1.5 2.5 3.5 4.5 ... 328.5 329.5 330.5 331.5\n", "│ * i (i) int64 3kB 1 2 3 4 5 6 7 8 ... 354 355 356 357 358 359 360\n", "│ Data variables:\n", "│ e1v (j, i) float64 953kB dask.array\n", "│ e2v (j, i) float64 953kB dask.array\n", "│ vmask (k, j, i) int8 9MB dask.array\n", "│ vmaskutil (j, i) int8 119kB dask.array\n", "│ Attributes:\n", "│ nftype: F\n", "│ iperio: True\n", "├── Group: /gridW\n", "│ Dimensions: (j: 331, i: 360, k: 75)\n", "│ Coordinates:\n", "│ gphit (j, i) float64 953kB dask.array\n", "│ glamt (j, i) float64 953kB dask.array\n", "│ * k (k) float64 600B 0.5 1.5 2.5 3.5 4.5 ... 71.5 72.5 73.5 74.5\n", "│ * j (j) int64 3kB 1 2 3 4 5 6 7 8 ... 325 326 327 328 329 330 331\n", "│ * i (i) int64 3kB 1 2 3 4 5 6 7 8 ... 354 355 356 357 358 359 360\n", "│ Data variables:\n", "│ e1t (j, i) float64 953kB dask.array\n", "│ e2t (j, i) float64 953kB dask.array\n", "│ wmask (k, j, i) int8 9MB dask.array\n", "│ wmaskutil (j, i) int8 119kB dask.array\n", "│ Attributes:\n", "│ nftype: F\n", "│ iperio: True\n", "└── Group: /gridF\n", " Dimensions: (j: 331, i: 360, k: 75)\n", " Coordinates:\n", " gphif (j, i) float64 953kB dask.array\n", " glamf (j, i) float64 953kB dask.array\n", " * k (k) int64 600B 1 2 3 4 5 6 7 8 9 ... 68 69 70 71 72 73 74 75\n", " * j (j) float64 3kB 1.5 2.5 3.5 4.5 ... 328.5 329.5 330.5 331.5\n", " * i (i) float64 3kB 1.5 2.5 3.5 4.5 ... 357.5 358.5 359.5 360.5\n", " Data variables:\n", " e1f (j, i) float64 953kB dask.array\n", " e2f (j, i) float64 953kB dask.array\n", " fmask (k, j, i) int8 9MB dask.array\n", " fmaskutil (j, i) int8 119kB dask.array\n", " Attributes:\n", " nftype: F\n", " iperio: True" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Define dictionary of grid datasets defining eORCA1 parent model domain with no child/grand-child nests:\n", "datasets = {\"parent\": {\"domain\": ds_domain, \"gridT\": ds_gridT}}\n", "\n", "# Initialise a new NEMODataTree whose parent domain is zonally periodic & north-folding on F-points:\n", "nemo = NEMODataTree.from_datasets(datasets=datasets, iperio=True, nftype=\"F\", read_mask=True)\n", "\n", "nemo" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### **Exploring our eORCA1 NEMO model vertical coordinate system**\n", "\n", "Let's begin by visualising the conservative temperature in the original vertical coordinates of our eORCA1 NPD simulation by plotting a vertical profile at a location in the North Atlantic Ocean:\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**By examining the vertical profile & the size of the `k` grid coordinate variable, we can see that our eORCA1 configuration has 75 unevenly-spaced z\\*-coordinate levels.**" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "75\n" ] }, { "data": { "image/png": "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", "text/plain": [ "

" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# -- Plot an example time-mean vertical conservative temperature profile in the subpolar North Atlantic -- #\n", "plt.figure(figsize=(6, 6))\n", "plt.grid(True, linewidth=1, linestyle='--', alpha=0.3)\n", "nemo['gridT']['thetao_con'].isel(time_counter=0, i=260, j=260).plot(y='deptht', ylim=(3600, 0), marker='o')\n", "\n", "# Axes labels:\n", "plt.title('eORCA1-JRA55v1: Time-Mean\\nVertical Conservative Temperature Profile', fontdict={'size':12, 'weight':'bold'})\n", "plt.xlabel('Conservative Temperature [$^{\\\\circ}$C]', fontdict={'size':12, 'weight':'bold'})\n", "plt.ylabel('Depth [m]', fontdict={'size':12, 'weight':'bold'})\n", "\n", "# Size of the vertical coordinate dimension:\n", "print(nemo['gridT']['k'].size)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### **Transforming the eORCA1 vertical coordinate system**\n", "\n", "**Next, let's apply a conservative vertical coordinate transformation to remap our conservative temperature output to a new regularly-spaced (200 m) vertical grid:**" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "text/html": [ "

<xarray.DataArray (k_new: 30)> Size: 240B\n",
       "array([200., 200., 200., 200., 200., 200., 200., 200., 200., 200., 200.,\n",
       "       200., 200., 200., 200., 200., 200., 200., 200., 200., 200., 200.,\n",
       "       200., 200., 200., 200., 200., 200., 200., 200.])\n",
       "Dimensions without coordinates: k_new

" ], "text/plain": [ " Size: 240B\n", "array([200., 200., 200., 200., 200., 200., 200., 200., 200., 200., 200.,\n", " 200., 200., 200., 200., 200., 200., 200., 200., 200., 200., 200.,\n", " 200., 200., 200., 200., 200., 200., 200., 200.])\n", "Dimensions without coordinates: k_new" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Define our target vertical grid coordinate:\n", "e3t_target = xr.DataArray(np.repeat(200.0, 30), dims=['k_new'])\n", "\n", "e3t_target" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**We will use the `.transform_vertical_grid()` method on a temporal subset of the global conservative temperature field:**" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "text/html": [ "

<xarray.Dataset> Size: 31MB\n",
       "Dimensions:        (j: 331, i: 360, k_new: 30)\n",
       "Coordinates:\n",
       "    time_counter   datetime64[ns] 8B 2000-07-02\n",
       "    time_centered  datetime64[ns] 8B dask.array<chunksize=(), meta=np.ndarray>\n",
       "    gphit          (j, i) float64 953kB dask.array<chunksize=(331, 360), meta=np.ndarray>\n",
       "    glamt          (j, i) float64 953kB dask.array<chunksize=(331, 360), meta=np.ndarray>\n",
       "  * j              (j) int64 3kB 1 2 3 4 5 6 7 8 ... 325 326 327 328 329 330 331\n",
       "  * i              (i) int64 3kB 1 2 3 4 5 6 7 8 ... 354 355 356 357 358 359 360\n",
       "    deptht_new     (k_new) float64 240B 200.0 400.0 600.0 ... 5.8e+03 6e+03\n",
       "Dimensions without coordinates: k_new\n",
       "Data variables:\n",
       "    thetao_con     (k_new, j, i) float32 14MB dask.array<chunksize=(30, 331, 360), meta=np.ndarray>\n",
       "    e3t_new        (k_new, j, i) float32 14MB dask.array<chunksize=(30, 331, 360), meta=np.ndarray>

" ], "text/plain": [ " Size: 31MB\n", "Dimensions: (j: 331, i: 360, k_new: 30)\n", "Coordinates:\n", " time_counter datetime64[ns] 8B 2000-07-02\n", " time_centered datetime64[ns] 8B dask.array\n", " gphit (j, i) float64 953kB dask.array\n", " glamt (j, i) float64 953kB dask.array\n", " * j (j) int64 3kB 1 2 3 4 5 6 7 8 ... 325 326 327 328 329 330 331\n", " * i (i) int64 3kB 1 2 3 4 5 6 7 8 ... 354 355 356 357 358 359 360\n", " deptht_new (k_new) float64 240B 200.0 400.0 600.0 ... 5.8e+03 6e+03\n", "Dimensions without coordinates: k_new\n", "Data variables:\n", " thetao_con (k_new, j, i) float32 14MB dask.array\n", " e3t_new (k_new, j, i) float32 14MB dask.array" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Transform eORCA1 3-dimensional conservative temperature field to new vertical coordinate system:\n", "ds_k_transform = nemo['gridT/thetao_con'].isel(time_counter=0).transform_vertical_grid(e3_new=e3t_target)\n", "\n", "ds_k_transform" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Note that the output above returns a Dataset containing two DataArrays: the vertically remapped conservative temperature `thetao_con` and the vertical grid cell thicknesses `e3t_out` (accounting for partial grid cell at the sea floor).\n", "\n", "**Since both of these DataArrays contain dask arrays, we haven't actually computed anything yet. To do this, we need to call the ``.compute()`` method:**\n" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "ds_k_transform = ds_k_transform.compute()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### **Visualising the vertically transformed conservative temperature field**\n", "\n", "**Let's plot the original and vertically transformed conservative temperature profiles together.**" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Text(0, 0.5, 'Depth [m]')" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "

" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.figure(figsize=(6, 6))\n", "plt.grid(True, linewidth=1, linestyle='--', alpha=0.3)\n", "\n", "# Plot our original time-mean vertical conservative temperature profile in the subpolar North Atlantic:\n", "nemo['gridT']['thetao_con'].isel(i=260, j=260, time_counter=0).plot(y='deptht', ylim=(3600, 0), marker='o', color='dodgerblue')\n", "\n", "# Plot our vertically transformed time-mean vertical conservative temperature profile in the subpolar North Atlantic:\n", "ds_k_transform['thetao_con'].isel(i=260, j=260).plot(y='deptht_new', ylim=(3600, 0), marker='o', color='coral')\n", "\n", "# Axis labels:\n", "plt.title('eORCA1-JRA55v1: Time-Mean\\nVertical Conservative Temperature Profiles', fontdict={'size':12, 'weight':'bold'})\n", "plt.xlabel('Conservative Temperature [$^{\\\\circ}$C]', fontdict={'size':11, 'weight':'bold'})\n", "plt.ylabel('Depth [m]', fontdict={'size':11, 'weight':'bold'})" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**We can also verify that the product of the vertical grid cell thickness (m) and conservative temperature (C) is conserved following the transformation.**\n", "\n", "**Note that we need to transform all variables to a consistent `dtype` (in this case float64) before making the comparison.**" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " Size: 8B\n", "array(14272.51116587)\n", "Coordinates:\n", " time_counter datetime64[ns] 8B 2000-07-02\n", " time_centered datetime64[ns] 8B 2000-07-02\n", " gphit float64 8B 51.34\n", " glamt float64 8B -26.44\n", " j int64 8B 261\n", " i int64 8B 261\n", " Size: 8B\n", "array(14272.51116587)\n", "Coordinates:\n", " time_counter datetime64[ns] 8B 2000-07-02\n", " time_centered datetime64[ns] 8B 2000-07-02\n", " gphit float64 8B 51.34\n", " glamt float64 8B -26.44\n", " j int64 8B 261\n", " i int64 8B 261\n" ] } ], "source": [ "# Calculate the sum of the product of the transformed conservative temperature and cell thickness at our example location:\n", "print((ds_k_transform['thetao_con'].isel(i=260, j=260).astype(np.float64) * ds_k_transform['e3t_new'].isel(i=260, j=260).astype(np.float64)).sum().compute())\n", "\n", "# Calculate the sum of the product of the original conservative temperature and cell thickness at our example location:\n", "print((nemo['gridT']['thetao_con'].isel(time_counter=0, i=260, j=260).astype(np.float64) * nemo['gridT']['e3t'].isel(time_counter=0, i=260, j=260).astype(np.float64)).sum().compute())" ] } ], "metadata": { "kernelspec": { "display_name": "dev", "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.12" } }, "nbformat": 4, "nbformat_minor": 2 }