{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "### **Description**\n", "\n", "This recipe shows how to calculate the volume census in discrete temperature-salinity coordinates using annual-mean outputs from the National Oceanography Centre Near-Present-Day global eORCA1 configuration of NEMO forced using JRA55-do 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.colors as colors\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: 39GB\n",
       "Dimensions:                (time_counter: 48, 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] 384B dask.array<chunksize=(1,), meta=np.ndarray>\n",
       "  * time_counter           (time_counter) datetime64[ns] 384B 1976-07-02 ... ...\n",
       "Dimensions without coordinates: y, x, axis_nbounds\n",
       "Data variables: (12/74)\n",
       "    berg_latent_heat_flux  (time_counter, y, x) float32 23MB dask.array<chunksize=(1, 331, 360), meta=np.ndarray>\n",
       "    deptht_bounds          (deptht, axis_nbounds) float32 600B dask.array<chunksize=(25, 2), meta=np.ndarray>\n",
       "    e3t                    (time_counter, deptht, y, x) float32 2GB dask.array<chunksize=(1, 25, 331, 360), meta=np.ndarray>\n",
       "    empmr                  (time_counter, y, x) float32 23MB dask.array<chunksize=(1, 331, 360), meta=np.ndarray>\n",
       "    evs                    (time_counter, y, x) float32 23MB dask.array<chunksize=(1, 331, 360), meta=np.ndarray>\n",
       "    ficeberg               (time_counter, y, x) float32 23MB dask.array<chunksize=(1, 331, 360), meta=np.ndarray>\n",
       "    ...                     ...\n",
       "    ttrd_qns_li            (time_counter, y, x) float32 23MB dask.array<chunksize=(1, 331, 360), meta=np.ndarray>\n",
       "    vohfcisf               (time_counter, deptht, y, x) float32 2GB dask.array<chunksize=(1, 25, 331, 360), meta=np.ndarray>\n",
       "    vohflisf               (time_counter, deptht, y, x) float32 2GB dask.array<chunksize=(1, 25, 331, 360), meta=np.ndarray>\n",
       "    vowflisf               (time_counter, deptht, y, x) float32 2GB dask.array<chunksize=(1, 25, 331, 360), meta=np.ndarray>\n",
       "    zos                    (time_counter, y, x) float32 23MB dask.array<chunksize=(1, 331, 360), meta=np.ndarray>\n",
       "    zossq                  (time_counter, y, x) float32 23MB 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: 39GB\n", "Dimensions: (time_counter: 48, 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] 384B dask.array\n", " * time_counter (time_counter) datetime64[ns] 384B 1976-07-02 ... ...\n", "Dimensions without coordinates: y, x, axis_nbounds\n", "Data variables: (12/74)\n", " berg_latent_heat_flux (time_counter, y, x) float32 23MB dask.array\n", " deptht_bounds (deptht, axis_nbounds) float32 600B dask.array\n", " e3t (time_counter, deptht, y, x) float32 2GB dask.array\n", " empmr (time_counter, y, x) float32 23MB dask.array\n", " evs (time_counter, y, x) float32 23MB dask.array\n", " ficeberg (time_counter, y, x) float32 23MB dask.array\n", " ... ...\n", " ttrd_qns_li (time_counter, y, x) float32 23MB dask.array\n", " vohfcisf (time_counter, deptht, y, x) float32 2GB dask.array\n", " vohflisf (time_counter, deptht, y, x) float32 2GB dask.array\n", " vowflisf (time_counter, deptht, y, x) float32 2GB dask.array\n", " zos (time_counter, y, x) float32 23MB dask.array\n", " zossq (time_counter, y, x) float32 23MB 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", "ds_gridT = xr.open_zarr(gridT_url, consolidated=True, chunks={})\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: 48, axis_nbounds: 2)\n",
       "│   Coordinates:\n",
       "│       time_centered         (time_counter) datetime64[ns] 384B dask.array<chunksize=(1,), meta=np.ndarray>\n",
       "│     * time_counter          (time_counter) datetime64[ns] 384B 1976-07-02 ... 2...\n",
       "│   Dimensions without coordinates: axis_nbounds\n",
       "│   Data variables:\n",
       "│       time_centered_bounds  (time_counter, axis_nbounds) datetime64[ns] 768B dask.array<chunksize=(1, 2), meta=np.ndarray>\n",
       "│       time_counter_bounds   (time_counter, axis_nbounds) datetime64[ns] 768B dask.array<chunksize=(1, 2), meta=np.ndarray>\n",
       "│   Attributes:\n",
       "│       nftype:   F\n",
       "│       iperio:   True\n",
       "├── Group: /gridT\n",
       "│       Dimensions:                (time_counter: 48, 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] 384B 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 23MB dask.array<chunksize=(1, 331, 360), meta=np.ndarray>\n",
       "│           deptht_bounds          (k, axis_nbounds) float32 600B dask.array<chunksize=(25, 2), meta=np.ndarray>\n",
       "│           e3t                    (time_counter, k, j, i) float32 2GB dask.array<chunksize=(1, 25, 331, 360), meta=np.ndarray>\n",
       "│           empmr                  (time_counter, j, i) float32 23MB dask.array<chunksize=(1, 331, 360), meta=np.ndarray>\n",
       "│           evs                    (time_counter, j, i) float32 23MB dask.array<chunksize=(1, 331, 360), meta=np.ndarray>\n",
       "│           ficeberg               (time_counter, j, i) float32 23MB 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: 48, axis_nbounds: 2)\n", "│ Coordinates:\n", "│ time_centered (time_counter) datetime64[ns] 384B dask.array\n", "│ * time_counter (time_counter) datetime64[ns] 384B 1976-07-02 ... 2...\n", "│ Dimensions without coordinates: axis_nbounds\n", "│ Data variables:\n", "│ time_centered_bounds (time_counter, axis_nbounds) datetime64[ns] 768B dask.array\n", "│ time_counter_bounds (time_counter, axis_nbounds) datetime64[ns] 768B dask.array\n", "│ Attributes:\n", "│ nftype: F\n", "│ iperio: True\n", "├── Group: /gridT\n", "│ Dimensions: (time_counter: 48, 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] 384B 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 23MB dask.array\n", "│ deptht_bounds (k, axis_nbounds) float32 600B dask.array\n", "│ e3t (time_counter, k, j, i) float32 2GB dask.array\n", "│ empmr (time_counter, j, i) float32 23MB dask.array\n", "│ evs (time_counter, j, i) float32 23MB dask.array\n", "│ ficeberg (time_counter, j, i) float32 23MB 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": [ "### **Calculating Volume Census**\n", "\n", "**Now we have constructed our `NEMODataTree`, let's calculate the volume census in in T-S coordinates using the `.binned_statistic()` method:**" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "# Define Atlantic Ocean basin mask:\n", "atlmask = ds_domain['atlmsk'].rename({\"x\":\"i\", \"y\":\"j\"}).astype(bool)" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "text/html": [ "

<xarray.DataArray 'volcello' (time_counter: 48, thetao_con_bins: 73,\n",
       "                              so_abs_bins: 179)> Size: 5MB\n",
       "dask.array<reshape, shape=(48, 73, 179), dtype=float64, chunksize=(48, 73, 179), chunktype=numpy.ndarray>\n",
       "Coordinates:\n",
       "  * time_counter     (time_counter) datetime64[ns] 384B 1976-07-02 ... 2023-0...\n",
       "  * thetao_con_bins  (thetao_con_bins) float64 584B -1.75 -1.25 ... 33.75 34.25\n",
       "  * so_abs_bins      (so_abs_bins) float64 1kB 20.05 20.15 20.25 ... 37.75 37.85

" ], "text/plain": [ " Size: 5MB\n", "dask.array\n", "Coordinates:\n", " * time_counter (time_counter) datetime64[ns] 384B 1976-07-02 ... 2023-0...\n", " * thetao_con_bins (thetao_con_bins) float64 584B -1.75 -1.25 ... 33.75 34.25\n", " * so_abs_bins (so_abs_bins) float64 1kB 20.05 20.15 20.25 ... 37.75 37.85" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Define discrete conservative temperature [C] and absolute salinity [g/kg] bins:\n", "thetao_bins = np.arange(-2, 35, 0.5)\n", "so_bins = np.arange(20, 38, 0.1)\n", "\n", "# Compute volume of each T-grid cell [m3].\n", "nemo['gridT']['volcello'] = nemo.cell_volume(grid='gridT')\n", "\n", "# Compute total volume in discrete conservative temperature - absolute salinity coords:\n", "vol_thetao_so_atl = nemo.binned_statistic(grid=\"gridT\",\n", " vars=[\"thetao_con\", \"so_abs\"],\n", " values=\"volcello\",\n", " keep_dims=[\"time_counter\"],\n", " bins=[thetao_bins, so_bins],\n", " statistic=\"nansum\",\n", " mask=atlmask\n", " )\n", "\n", "vol_thetao_so_atl" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Notice that the output above contains dask arrays, so we haven't actually computed the volume census yet. To do this, we need to call the ``.compute()`` method:**" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "OMP: Info #276: omp_set_nested routine deprecated, please use omp_set_max_active_levels instead.\n" ] } ], "source": [ "vol_thetao_so_atl = vol_thetao_so_atl.compute()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### **Visualising the time-mean volume census in T-S coordinates**\n", "\n", "**Finally, let's visualise the results by plotting the time-mean volume census in conservative temperature - absolute salinity space using a logarithmic scale:**" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Text(0, 0.5, 'Conservative Temperature [$^{\\\\circ}$C]')" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "

" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# -- Plot time-mean volume census in conservative temperature - absolute salinity space -- #\n", "plt.figure(figsize=(7, 6))\n", "\n", "# Calculate time-mean volume census:\n", "plt_data = vol_thetao_so_atl.mean(dim='time_counter')\n", "\n", "# Plot time-mean volume census:\n", "(plt_data\n", " .plot(norm=colors.LogNorm(vmin=plt_data.min(),\n", " vmax=plt_data.max()),\n", " cmap=\"turbo\",\n", " cbar_kwargs={\"label\": \"Volume ($\\\\log_{10}$[m$^3$])\"}\n", " )\n", " )\n", "\n", "# Axes labels:\n", "plt.title('eORCA1-JRA55v1: Atlantic Ocean Volume Census', fontdict={'size':12, 'weight':'bold'})\n", "plt.xlabel('Absolute Salinity [g kg$^{-1}$]', fontdict={'size':11, 'weight':'bold'})\n", "plt.ylabel('Conservative Temperature [$^{\\\\circ}$C]', fontdict={'size':11, 'weight':'bold'})" ] } ], "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 }