OM4 Animation

To run this notebook, you will have to use LEAP-Pangeo hub!

In this notebook, we will visualize the OM4 data using the xarray and matplotlib libraries and create an animation of the Surface Kinetic Energy over time. We will explore visualizations in both global and regional scales.

Credits: Pperezhogin/MOM6

import xarray as xr
import numpy as np
import matplotlib.pyplot as plt
from helpers.plot_helpers import *
from helpers.computational_tools import (
    remesh,
    gaussian_remesh,
    select_LatLon,
    Lk_error,
    x_coord,
    y_coord,
)
import os

%load_ext autoreload
%autoreload 2
import warnings

warnings.filterwarnings("ignore")
import hvplot.xarray
import holoviews as hv
import matplotlib as mpl
import cartopy.crs as ccrs

hvplot.output(widget_location="bottom")

path = "gs://leap-persistent/jbusecke/OM4_m2lines/daily_combined.zarr"
ds = xr.open_dataset(path, engine="zarr", chunks={})
ds

<xarray.Dataset>
Dimensions:       (yq: 1081, xq: 1441, yh: 1080, xh: 1440, experiment: 2,
                   time: 1827, nv: 2)
Coordinates: (12/34)
    Coriolis      (yq, xq) float32 dask.array<chunksize=(271, 361), meta=np.ndarray>
    areacello     (yh, xh) float32 dask.array<chunksize=(270, 360), meta=np.ndarray>
    areacello_bu  (yq, xq) float32 dask.array<chunksize=(271, 361), meta=np.ndarray>
    areacello_cu  (yh, xq) float32 dask.array<chunksize=(270, 361), meta=np.ndarray>
    areacello_cv  (yq, xh) float32 dask.array<chunksize=(271, 360), meta=np.ndarray>
    basin         (yh, xh) int32 dask.array<chunksize=(270, 360), meta=np.ndarray>
    ...            ...
    wet_u         (yh, xq) float32 dask.array<chunksize=(270, 361), meta=np.ndarray>
    wet_v         (yq, xh) float32 dask.array<chunksize=(271, 360), meta=np.ndarray>
  * xh            (xh) float64 -299.7 -299.5 -299.2 -299.0 ... 59.53 59.78 60.03
  * xq            (xq) float64 -299.8 -299.6 -299.3 -299.1 ... 59.66 59.91 60.16
  * yh            (yh) float64 -80.39 -80.31 -80.23 -80.15 ... 89.73 89.84 89.95
  * yq            (yq) float64 -80.43 -80.35 -80.27 -80.19 ... 89.78 89.89 90.0
Data variables:
    average_DT    (experiment, time) timedelta64[ns] dask.array<chunksize=(2, 1827), meta=np.ndarray>
    average_T1    (experiment, time) datetime64[ns] dask.array<chunksize=(2, 1827), meta=np.ndarray>
    average_T2    (experiment, time) datetime64[ns] dask.array<chunksize=(2, 1827), meta=np.ndarray>
    ssu           (experiment, time, yh, xq) float32 dask.array<chunksize=(1, 20, 1080, 1441), meta=np.ndarray>
    ssv           (experiment, time, yq, xh) float32 dask.array<chunksize=(1, 20, 1081, 1440), meta=np.ndarray>
    time_bnds     (experiment, time, nv) object dask.array<chunksize=(2, 1827, 2), meta=np.ndarray>
    tos           (experiment, time, yh, xh) float32 dask.array<chunksize=(1, 20, 1080, 1440), meta=np.ndarray>
    zos           (experiment, time, yh, xh) float32 dask.array<chunksize=(1, 20, 1080, 1440), meta=np.ndarray>
Attributes:
    associated_files:  areacello: 20080101.ocean_static.nc
    grid_tile:         N/A
    grid_type:         regular
    title:             OM4p25_bugfixes_JRA55do1.5_cycle1

xarray.Dataset

• Dimensions:
  • yq: 1081
  • xq: 1441
  • yh: 1080
  • xh: 1440
  • experiment: 2
  • time: 1827
  • nv: 2
• Coordinates: (34)
  • Coriolis
    (yq, xq)
    float32
    dask.array<chunksize=(271, 361), meta=np.ndarray>

    cell_methods :

    time: point

    interp_method :

    none

    long_name :

    Coriolis parameter at corner (Bu) points

    units :

    s-1

    Array Chunk Bytes 5.94 MiB 382.15 kiB Shape (1081, 1441) (271, 361) Dask graph 16 chunks in 2 graph layers Data type float32 numpy.ndarray

  • areacello
    (yh, xh)
    float32
    dask.array<chunksize=(270, 360), meta=np.ndarray>

    cell_methods :

    area:sum yh:sum xh:sum time: point

    long_name :

    Ocean Grid-Cell Area

    standard_name :

    cell_area

    units :

    m2

    Array Chunk Bytes 5.93 MiB 379.69 kiB Shape (1080, 1440) (270, 360) Dask graph 16 chunks in 2 graph layers Data type float32 numpy.ndarray

  • areacello_bu
    (yq, xq)
    float32
    dask.array<chunksize=(271, 361), meta=np.ndarray>

    cell_methods :

    area:sum yq:sum xq:sum time: point

    long_name :

    Ocean Grid-Cell Area

    standard_name :

    cell_area

    units :

    m2

    Array Chunk Bytes 5.94 MiB 382.15 kiB Shape (1081, 1441) (271, 361) Dask graph 16 chunks in 2 graph layers Data type float32 numpy.ndarray

  • areacello_cu
    (yh, xq)
    float32
    dask.array<chunksize=(270, 361), meta=np.ndarray>

    cell_methods :

    area:sum yh:sum xq:sum time: point

    long_name :

    Ocean Grid-Cell Area

    standard_name :

    cell_area

    units :

    m2

    Array Chunk Bytes 5.94 MiB 380.74 kiB Shape (1080, 1441) (270, 361) Dask graph 16 chunks in 2 graph layers Data type float32 numpy.ndarray

  • areacello_cv
    (yq, xh)
    float32
    dask.array<chunksize=(271, 360), meta=np.ndarray>

    cell_methods :

    area:sum yq:sum xh:sum time: point

    long_name :

    Ocean Grid-Cell Area

    standard_name :

    cell_area

    units :

    m2

    Array Chunk Bytes 5.94 MiB 381.09 kiB Shape (1081, 1440) (271, 360) Dask graph 16 chunks in 2 graph layers Data type float32 numpy.ndarray

  • basin
    (yh, xh)
    int32
    dask.array<chunksize=(270, 360), meta=np.ndarray>

    flag_meanings :

    global_land southern_ocean atlantic_ocean pacific_ocean arctic_ocean indian_ocean mediterranean_sea black_sea hudson_bay baltic_sea red_sea

    flag_values :

    0 1 2 3 4 5 6 7 8 9 10

    interp_method :

    none

    long_name :

    Region Selection Index

    standard_name :

    region

    units :

    1.0

    Array Chunk Bytes 5.93 MiB 379.69 kiB Shape (1080, 1440) (270, 360) Dask graph 16 chunks in 2 graph layers Data type int32 numpy.ndarray

  • deptho
    (yh, xh)
    float32
    dask.array<chunksize=(270, 360), meta=np.ndarray>

    cell_measures :

    area: areacello

    cell_methods :

    area:mean yh:mean xh:mean time: point

    long_name :

    Sea Floor Depth

    standard_name :

    sea_floor_depth_below_geoid

    units :

    m

    Array Chunk Bytes 5.93 MiB 379.69 kiB Shape (1080, 1440) (270, 360) Dask graph 16 chunks in 2 graph layers Data type float32 numpy.ndarray

  • dxCu
    (yh, xq)
    float32
    dask.array<chunksize=(270, 361), meta=np.ndarray>

    cell_methods :

    time: point

    interp_method :

    none

    long_name :

    Delta(x) at u points (meter)

    units :

    m

    Array Chunk Bytes 5.94 MiB 380.74 kiB Shape (1080, 1441) (270, 361) Dask graph 16 chunks in 2 graph layers Data type float32 numpy.ndarray

  • dxCv
    (yq, xh)
    float32
    dask.array<chunksize=(271, 360), meta=np.ndarray>

    cell_methods :

    time: point

    interp_method :

    none

    long_name :

    Delta(x) at v points (meter)

    units :

    m

    Array Chunk Bytes 5.94 MiB 381.09 kiB Shape (1081, 1440) (271, 360) Dask graph 16 chunks in 2 graph layers Data type float32 numpy.ndarray

  • dxt
    (yh, xh)
    float32
    dask.array<chunksize=(270, 360), meta=np.ndarray>

    cell_methods :

    time: point

    interp_method :

    none

    long_name :

    Delta(x) at thickness/tracer points (meter)

    units :

    m

    Array Chunk Bytes 5.93 MiB 379.69 kiB Shape (1080, 1440) (270, 360) Dask graph 16 chunks in 2 graph layers Data type float32 numpy.ndarray

  • dyCu
    (yh, xq)
    float32
    dask.array<chunksize=(270, 361), meta=np.ndarray>

    cell_methods :

    time: point

    interp_method :

    none

    long_name :

    Delta(y) at u points (meter)

    units :

    m

    Array Chunk Bytes 5.94 MiB 380.74 kiB Shape (1080, 1441) (270, 361) Dask graph 16 chunks in 2 graph layers Data type float32 numpy.ndarray

  • dyCv
    (yq, xh)
    float32
    dask.array<chunksize=(271, 360), meta=np.ndarray>

    cell_methods :

    time: point

    interp_method :

    none

    long_name :

    Delta(y) at v points (meter)

    units :

    m

    Array Chunk Bytes 5.94 MiB 381.09 kiB Shape (1081, 1440) (271, 360) Dask graph 16 chunks in 2 graph layers Data type float32 numpy.ndarray

  • dyt
    (yh, xh)
    float32
    dask.array<chunksize=(270, 360), meta=np.ndarray>

    cell_methods :

    time: point

    interp_method :

    none

    long_name :

    Delta(y) at thickness/tracer points (meter)

    units :

    m

    Array Chunk Bytes 5.93 MiB 379.69 kiB Shape (1080, 1440) (270, 360) Dask graph 16 chunks in 2 graph layers Data type float32 numpy.ndarray

  • experiment
    (experiment)
    <U15
    'unparameterized' 'ZB2020'

    array(['unparameterized', 'ZB2020'], dtype='<U15')

  • geolat
    (yh, xh)
    float32
    dask.array<chunksize=(270, 360), meta=np.ndarray>

    cell_methods :

    time: point

    long_name :

    Latitude of tracer (T) points

    units :

    degrees_north

    Array Chunk Bytes 5.93 MiB 379.69 kiB Shape (1080, 1440) (270, 360) Dask graph 16 chunks in 2 graph layers Data type float32 numpy.ndarray

  • geolat_c
    (yq, xq)
    float32
    dask.array<chunksize=(271, 361), meta=np.ndarray>

    cell_methods :

    time: point

    interp_method :

    none

    long_name :

    Latitude of corner (Bu) points

    units :

    degrees_north

    Array Chunk Bytes 5.94 MiB 382.15 kiB Shape (1081, 1441) (271, 361) Dask graph 16 chunks in 2 graph layers Data type float32 numpy.ndarray

  • geolat_u
    (yh, xq)
    float32
    dask.array<chunksize=(270, 361), meta=np.ndarray>

    cell_methods :

    time: point

    interp_method :

    none

    long_name :

    Latitude of zonal velocity (Cu) points

    units :

    degrees_north

    Array Chunk Bytes 5.94 MiB 380.74 kiB Shape (1080, 1441) (270, 361) Dask graph 16 chunks in 2 graph layers Data type float32 numpy.ndarray

  • geolat_v
    (yq, xh)
    float32
    dask.array<chunksize=(271, 360), meta=np.ndarray>

    cell_methods :

    time: point

    interp_method :

    none

    long_name :

    Latitude of meridional velocity (Cv) points

    units :

    degrees_north

    Array Chunk Bytes 5.94 MiB 381.09 kiB Shape (1081, 1440) (271, 360) Dask graph 16 chunks in 2 graph layers Data type float32 numpy.ndarray

  • geolon
    (yh, xh)
    float32
    dask.array<chunksize=(270, 360), meta=np.ndarray>

    cell_methods :

    time: point

    long_name :

    Longitude of tracer (T) points

    units :

    degrees_east

    Array Chunk Bytes 5.93 MiB 379.69 kiB Shape (1080, 1440) (270, 360) Dask graph 16 chunks in 2 graph layers Data type float32 numpy.ndarray

  • geolon_c
    (yq, xq)
    float32
    dask.array<chunksize=(271, 361), meta=np.ndarray>

    cell_methods :

    time: point

    interp_method :

    none

    long_name :

    Longitude of corner (Bu) points

    units :

    degrees_east

    Array Chunk Bytes 5.94 MiB 382.15 kiB Shape (1081, 1441) (271, 361) Dask graph 16 chunks in 2 graph layers Data type float32 numpy.ndarray

  • geolon_u
    (yh, xq)
    float32
    dask.array<chunksize=(270, 361), meta=np.ndarray>

    cell_methods :

    time: point

    interp_method :

    none

    long_name :

    Longitude of zonal velocity (Cu) points

    units :

    degrees_east

    Array Chunk Bytes 5.94 MiB 380.74 kiB Shape (1080, 1441) (270, 361) Dask graph 16 chunks in 2 graph layers Data type float32 numpy.ndarray

  • geolon_v
    (yq, xh)
    float32
    dask.array<chunksize=(271, 360), meta=np.ndarray>

    cell_methods :

    time: point

    interp_method :

    none

    long_name :

    Longitude of meridional velocity (Cv) points

    units :

    degrees_east

    Array Chunk Bytes 5.94 MiB 381.09 kiB Shape (1081, 1440) (271, 360) Dask graph 16 chunks in 2 graph layers Data type float32 numpy.ndarray

  • hfgeou
    (yh, xh)
    float32
    dask.array<chunksize=(270, 360), meta=np.ndarray>

    cell_methods :

    area:mean yh:mean xh:mean time: point

    long_name :

    Upward geothermal heat flux at sea floor

    standard_name :

    upward_geothermal_heat_flux_at_sea_floor

    units :

    W m-2

    Array Chunk Bytes 5.93 MiB 379.69 kiB Shape (1080, 1440) (270, 360) Dask graph 16 chunks in 2 graph layers Data type float32 numpy.ndarray

  • nv
    (nv)
    float64
    1.0 2.0

    long_name :

    vertex number

    array([1., 2.])

  • sftof
    (yh, xh)
    float32
    dask.array<chunksize=(270, 360), meta=np.ndarray>

    cell_methods :

    area:mean yh:mean xh:mean time: point

    long_name :

    Sea Area Fraction

    standard_name :

    SeaAreaFraction

    units :

    %

    Array Chunk Bytes 5.93 MiB 379.69 kiB Shape (1080, 1440) (270, 360) Dask graph 16 chunks in 2 graph layers Data type float32 numpy.ndarray

  • time
    (time)
    object
    2008-01-01 12:00:00 ... 2012-12-...

    axis :

    T

    bounds :

    time_bnds

    calendar_type :

    JULIAN

    cell_methods :

    time: mean

    long_name :

    time

    array([cftime.DatetimeJulian(2008, 1, 1, 12, 0, 0, 0, has_year_zero=False),
           cftime.DatetimeJulian(2008, 1, 2, 12, 0, 0, 0, has_year_zero=False),
           cftime.DatetimeJulian(2008, 1, 3, 12, 0, 0, 0, has_year_zero=False),
           ...,
           cftime.DatetimeJulian(2012, 12, 29, 12, 0, 0, 0, has_year_zero=False),
           cftime.DatetimeJulian(2012, 12, 30, 12, 0, 0, 0, has_year_zero=False),
           cftime.DatetimeJulian(2012, 12, 31, 12, 0, 0, 0, has_year_zero=False)],
          dtype=object)

  • wet
    (yh, xh)
    float32
    dask.array<chunksize=(270, 360), meta=np.ndarray>

    cell_measures :

    area: areacello

    cell_methods :

    time: point

    long_name :

    0 if land, 1 if ocean at tracer points

    units :

    none

    Array Chunk Bytes 5.93 MiB 379.69 kiB Shape (1080, 1440) (270, 360) Dask graph 16 chunks in 2 graph layers Data type float32 numpy.ndarray

  • wet_c
    (yq, xq)
    float32
    dask.array<chunksize=(271, 361), meta=np.ndarray>

    cell_methods :

    time: point

    interp_method :

    none

    long_name :

    0 if land, 1 if ocean at corner (Bu) points

    units :

    none

    Array Chunk Bytes 5.94 MiB 382.15 kiB Shape (1081, 1441) (271, 361) Dask graph 16 chunks in 2 graph layers Data type float32 numpy.ndarray

  • wet_u
    (yh, xq)
    float32
    dask.array<chunksize=(270, 361), meta=np.ndarray>

    cell_methods :

    time: point

    interp_method :

    none

    long_name :

    0 if land, 1 if ocean at zonal velocity (Cu) points

    units :

    none

    Array Chunk Bytes 5.94 MiB 380.74 kiB Shape (1080, 1441) (270, 361) Dask graph 16 chunks in 2 graph layers Data type float32 numpy.ndarray

  • wet_v
    (yq, xh)
    float32
    dask.array<chunksize=(271, 360), meta=np.ndarray>

    cell_methods :

    time: point

    interp_method :

    none

    long_name :

    0 if land, 1 if ocean at meridional velocity (Cv) points

    units :

    none

    Array Chunk Bytes 5.94 MiB 381.09 kiB Shape (1081, 1440) (271, 360) Dask graph 16 chunks in 2 graph layers Data type float32 numpy.ndarray

  • xh
    (xh)
    float64
    -299.7 -299.5 ... 59.78 60.03

    axis :

    X

    long_name :

    h point nominal longitude

    units :

    degrees_east

    array([-299.724244, -299.476198, -299.22815 , ...,   59.531631,   59.77967 ,
             60.027712])

  • xq
    (xq)
    float64
    -299.8 -299.6 ... 59.91 60.16

    axis :

    X

    long_name :

    q point nominal longitude

    units :

    degrees_east

    array([-299.842324, -299.594355, -299.346385, ...,   59.661746,   59.90971 ,
             60.157676])

  • yh
    (yh)
    float64
    -80.39 -80.31 ... 89.84 89.95

    axis :

    Y

    long_name :

    h point nominal latitude

    units :

    degrees_north

    array([-80.389238, -80.308075, -80.226911, ...,  89.729781,  89.837868,
            89.945956])

  • yq
    (yq)
    float64
    -80.43 -80.35 -80.27 ... 89.89 90.0

    axis :

    Y

    long_name :

    q point nominal latitude

    units :

    degrees_north

    array([-80.429819, -80.348657, -80.267493, ...,  89.783825,  89.891912,
            90.      ])

• Data variables: (8)
  • average_DT
    (experiment, time)
    timedelta64[ns]
    dask.array<chunksize=(2, 1827), meta=np.ndarray>

    cell_methods :

    time: mean

    long_name :

    Length of average period

    Array Chunk Bytes 28.55 kiB 28.55 kiB Shape (2, 1827) (2, 1827) Dask graph 1 chunks in 2 graph layers Data type timedelta64[ns] numpy.ndarray

  • average_T1
    (experiment, time)
    datetime64[ns]
    dask.array<chunksize=(2, 1827), meta=np.ndarray>

    cell_methods :

    time: mean

    long_name :

    Start time for average period

    Array Chunk Bytes 28.55 kiB 28.55 kiB Shape (2, 1827) (2, 1827) Dask graph 1 chunks in 2 graph layers Data type datetime64[ns] numpy.ndarray

  • average_T2
    (experiment, time)
    datetime64[ns]
    dask.array<chunksize=(2, 1827), meta=np.ndarray>

    cell_methods :

    time: mean

    long_name :

    End time for average period

    Array Chunk Bytes 28.55 kiB 28.55 kiB Shape (2, 1827) (2, 1827) Dask graph 1 chunks in 2 graph layers Data type datetime64[ns] numpy.ndarray

  • ssu
    (experiment, time, yh, xq)
    float32
    dask.array<chunksize=(1, 20, 1080, 1441), meta=np.ndarray>

    cell_methods :

    yh:mean xq:point time: mean

    interp_method :

    none

    long_name :

    Sea Surface Zonal Velocity

    time_avg_info :

    average_T1,average_T2,average_DT

    units :

    m s-1

    Array Chunk Bytes 21.18 GiB 118.73 MiB Shape (2, 1827, 1080, 1441) (1, 20, 1080, 1441) Dask graph 184 chunks in 2 graph layers Data type float32 numpy.ndarray

  • ssv
    (experiment, time, yq, xh)
    float32
    dask.array<chunksize=(1, 20, 1081, 1440), meta=np.ndarray>

    cell_methods :

    yq:point xh:mean time: mean

    interp_method :

    none

    long_name :

    Sea Surface Meridional Velocity

    time_avg_info :

    average_T1,average_T2,average_DT

    units :

    m s-1

    Array Chunk Bytes 21.19 GiB 118.76 MiB Shape (2, 1827, 1081, 1440) (1, 20, 1081, 1440) Dask graph 184 chunks in 2 graph layers Data type float32 numpy.ndarray

  • time_bnds
    (experiment, time, nv)
    object
    dask.array<chunksize=(2, 1827, 2), meta=np.ndarray>

    cell_methods :

    time: mean

    long_name :

    time axis boundaries

    Array Chunk Bytes 57.09 kiB 57.09 kiB Shape (2, 1827, 2) (2, 1827, 2) Dask graph 1 chunks in 2 graph layers Data type object numpy.ndarray

  • tos
    (experiment, time, yh, xh)
    float32
    dask.array<chunksize=(1, 20, 1080, 1440), meta=np.ndarray>

    cell_measures :

    area: areacello

    cell_methods :

    area:mean yh:mean xh:mean time: mean

    long_name :

    Sea Surface Temperature

    standard_name :

    sea_surface_temperature

    time_avg_info :

    average_T1,average_T2,average_DT

    units :

    degC

    Array Chunk Bytes 21.17 GiB 118.65 MiB Shape (2, 1827, 1080, 1440) (1, 20, 1080, 1440) Dask graph 184 chunks in 2 graph layers Data type float32 numpy.ndarray

  • zos
    (experiment, time, yh, xh)
    float32
    dask.array<chunksize=(1, 20, 1080, 1440), meta=np.ndarray>

    cell_measures :

    area: areacello

    cell_methods :

    area:mean yh:mean xh:mean time: mean

    long_name :

    Sea surface height above geoid

    standard_name :

    sea_surface_height_above_geoid

    time_avg_info :

    average_T1,average_T2,average_DT

    units :

    m

    Array Chunk Bytes 21.17 GiB 118.65 MiB Shape (2, 1827, 1080, 1440) (1, 20, 1080, 1440) Dask graph 184 chunks in 2 graph layers Data type float32 numpy.ndarray

• Indexes: (7)
  • experiment
    PandasIndex

    PandasIndex(Index(['unparameterized', 'ZB2020'], dtype='object', name='experiment'))

  • nv
    PandasIndex

    PandasIndex(Index([1.0, 2.0], dtype='float64', name='nv'))

  • time
    PandasIndex

    PandasIndex(CFTimeIndex([2008-01-01 12:00:00, 2008-01-02 12:00:00, 2008-01-03 12:00:00,
                 2008-01-04 12:00:00, 2008-01-05 12:00:00, 2008-01-06 12:00:00,
                 2008-01-07 12:00:00, 2008-01-08 12:00:00, 2008-01-09 12:00:00,
                 2008-01-10 12:00:00,
                 ...
                 2012-12-22 12:00:00, 2012-12-23 12:00:00, 2012-12-24 12:00:00,
                 2012-12-25 12:00:00, 2012-12-26 12:00:00, 2012-12-27 12:00:00,
                 2012-12-28 12:00:00, 2012-12-29 12:00:00, 2012-12-30 12:00:00,
                 2012-12-31 12:00:00],
                dtype='object', length=1827, calendar='julian', freq='D'))

  • xh
    PandasIndex

    PandasIndex(Index([-299.72424385142534, -299.47619795417893, -299.22815003129284,
            -298.9801000979502, -298.73204816972844, -298.48399426259493,
            -298.2359383929031, -297.98788057738807,  -297.7398208331622,
           -297.49175917771095,
           ...
              57.7954116364209,    58.0434365318752,   58.29146358221654,
             58.53949277642749,   58.78752410305645,    59.0355575502213,
            59.283593105613505,   59.53163075650182,   59.77967048973631,
             60.02771229175239],
          dtype='float64', name='xh', length=1440))

  • xq
    PandasIndex

    PandasIndex(Index([-299.84232356963065,  -299.5943552901672, -299.34638489675444,
           -299.09841240498736, -298.85043783087235, -298.60246119082325,
            -298.3544825016569,  -298.1065017805884,  -297.8585190452273,
           -297.61053431357254,
           ...
             57.92605940685515,  58.174008029019525,  58.421958886267745,
             58.66991196689831,   58.91786725876078,   59.16582474925989,
             59.41378442535931,   59.66174627358603,   59.90971028003419,
             60.15767643036936],
          dtype='float64', name='xq', length=1441))

  • yh
    PandasIndex

    PandasIndex(Index([-80.38923793857394, -80.30807479101273, -80.22691082925455,
           -80.14574767486899, -80.06458691047965,  -79.9834300812582,
           -79.90227869634805, -79.82113423022128, -79.73999812397257,
           -79.65887178655316,
           ...
             88.9731671559671,  89.08125482376003,  89.18934249155296,
            89.29743015934592,  89.40551782713882,  89.51360549493178,
            89.62169316272471,  89.72978083051767,  89.83786849831056,
             89.9459561661037],
          dtype='float64', name='yh', length=1080))

  • yq
    PandasIndex

    PandasIndex(Index([-80.42981868925645, -80.34865656947974, -80.26749280962936,
           -80.18632905133127,  -80.1051668964908, -80.02400790882328,
           -79.94285361531256, -79.86170550760079, -79.78056504331342,
           -79.69943364732279,
           ...
            89.02721098986355,   89.1352986576565,  89.24338632544942,
            89.35147399324238,  89.45956166103532,  89.56764932882824,
            89.67573699662118,  89.78382466441413,  89.89191233220704,
                         90.0],
          dtype='float64', name='yq', length=1081))

• Attributes: (4)

  associated_files :

  areacello: 20080101.ocean_static.nc

  grid_tile :

  N/A

  grid_type :

  regular

  title :

  OM4p25_bugfixes_JRA55do1.5_cycle1

ZBu = ds["ssu"].sel(experiment="ZB2020")
ZBv = ds["ssv"].sel(experiment="ZB2020")
ZBT = ds["tos"].sel(experiment="ZB2020")

loresu = ds["ssu"].sel(experiment="unparameterized")
loresv = ds["ssv"].sel(experiment="unparameterized")
loresT = ds["tos"].sel(experiment="unparameterized")

def KE(u, v, T):
    return 0.5 * (remesh(u**2, T) + remesh(v**2, T))

ZBke = KE(ZBu, ZBv, ZBT)
loreske = KE(loresu, loresv, ZBT)

Global plotter

import cartopy.crs as ccrs
import matplotlib as mpl

default_rcParams({"figure.subplot.hspace": 0.05, "font.size": 30})


def plot_global(i=0, fig=None, len_idx=None):
    if fig is None:
        fig = plt.figure(figsize=(7, 13))
    elif i != 0:
        print(f"Processing frame ({i//5}/{len_idx-1})")
    time_idx = i * 5
    time_str = loreske.time.isel(time=time_idx).item().strftime("%Y-%m-%d")

    ax1 = plt.subplot(211, projection=ccrs.Orthographic(central_longitude=i))
    ax1.coastlines(resolution="110m")
    ax1.gridlines()
    im = loreske.isel(time=time_idx).plot(
        ax=ax1,
        transform=ccrs.PlateCarree(),
        norm=mpl.colors.LogNorm(vmin=1e-3, vmax=1e0),
        cmap="inferno",
        add_colorbar=False,
    )
    ax1.set_title("$1/4^o$", fontsize=30)

    ax2 = plt.subplot(212, projection=ccrs.Orthographic(central_longitude=i))
    ax2.coastlines(resolution="110m")
    ax2.gridlines()
    im = ZBke.isel(time=time_idx).plot(
        ax=ax2,
        transform=ccrs.PlateCarree(),
        norm=mpl.colors.LogNorm(vmin=1e-3, vmax=1e0),
        cmap="inferno",
        add_colorbar=False,
    )
    ax2.set_title("$1/4^o$, ZB2020", fontsize=30)
    cb = plt.colorbar(im, pad=0.02, ax=[ax1, ax2], extend="both", aspect=50, shrink=0.9)
    cb.set_label(label="Surface KE, $\mathrm{m}^2/\mathrm{s}^2$", fontsize=30)
    plt.suptitle(time_str)

plot_global()

Here, we show the animation of the Surface Kinetic Energy in intervals of 5 days shifting the longitude by 5 degrees each step.

from matplotlib.animation import FuncAnimation, PillowWriter

def update_frame(i, plot_func, fig, len_idx):
    # Clear the current figure to prepare for the next frame's plot.
    plt.clf()
    plot_func(i, fig, len_idx)


def create_gif(plot_func, idx, filename="my-animation.gif", dpi=200, FPS=18, loop=0):
    fig = plt.figure(figsize=(10, 20))
    ani = FuncAnimation(
        fig,
        update_frame,
        frames=idx,
        fargs=(plot_func, fig, len(idx)),
        repeat=bool(loop),
        blit=False,
    )

    writer = PillowWriter(fps=FPS, metadata=dict(artist="Me"))
    ani.save(filename, writer=writer)
    plt.close(fig)

%%time
create_gif(
    plot_global, range(0, 360, 5), filename="./Global.gif", dpi=200, FPS=18, loop=0
)

Processing frame (1/71)
Processing frame (2/71)
Processing frame (3/71)
Processing frame (4/71)
Processing frame (5/71)
Processing frame (6/71)
Processing frame (7/71)
Processing frame (8/71)
Processing frame (9/71)
Processing frame (10/71)
Processing frame (11/71)
Processing frame (12/71)
Processing frame (13/71)
Processing frame (14/71)
Processing frame (15/71)
Processing frame (16/71)
Processing frame (17/71)
Processing frame (18/71)
Processing frame (19/71)
Processing frame (20/71)
Processing frame (21/71)
Processing frame (22/71)
Processing frame (23/71)
Processing frame (24/71)
Processing frame (25/71)
Processing frame (26/71)
Processing frame (27/71)
Processing frame (28/71)
Processing frame (29/71)
Processing frame (30/71)
Processing frame (31/71)
Processing frame (32/71)
Processing frame (33/71)
Processing frame (34/71)
Processing frame (35/71)
Processing frame (36/71)
Processing frame (37/71)
Processing frame (38/71)
Processing frame (39/71)
Processing frame (40/71)
Processing frame (41/71)
Processing frame (42/71)
Processing frame (43/71)
Processing frame (44/71)
Processing frame (45/71)
Processing frame (46/71)
Processing frame (47/71)
Processing frame (48/71)
Processing frame (49/71)
Processing frame (50/71)
Processing frame (51/71)
Processing frame (52/71)
Processing frame (53/71)
Processing frame (54/71)
Processing frame (55/71)
Processing frame (56/71)
Processing frame (57/71)
Processing frame (58/71)
Processing frame (59/71)
Processing frame (60/71)
Processing frame (61/71)
Processing frame (62/71)
Processing frame (63/71)
Processing frame (64/71)
Processing frame (65/71)
Processing frame (66/71)
Processing frame (67/71)
Processing frame (68/71)
Processing frame (69/71)
Processing frame (70/71)
Processing frame (71/71)
CPU times: user 15min 7s, sys: 3min 40s, total: 18min 48s
Wall time: 14min 29s

Saved Gif:

Regional plotter

default_rcParams({"figure.subplot.hspace": 0.05, "font.size": 30})


def plot_regions(i=0, lat=slice(15, 70), lon=slice(-100, 0), fig=None, len_idx=None):
    if fig is None:
        fig = plt.figure(figsize=(7, 13))
    elif i != 1461:  # Start index for all regions
        i = i - 1461
        print(f"Processing frame ({i//5}/{len_idx-1})")
    time_idx = i
    time_str = loreske.time.isel(time=time_idx).item().strftime("%Y-%m-%d")

    ax1 = plt.subplot(
        211,
        projection=ccrs.Orthographic(
            central_latitude=(lat.start + lat.stop) / 2,
            central_longitude=(lon.start + lon.stop) / 2,
        ),
    )
    ax1.coastlines(resolution="110m")
    ax1.gridlines()
    im = (
        loreske.isel(time=time_idx)
        .sel(xh=lon, yh=lat)
        .plot(
            ax=ax1,
            transform=ccrs.PlateCarree(),
            norm=mpl.colors.LogNorm(vmin=1e-3, vmax=1e0),
            cmap="inferno",
            add_colorbar=False,
        )
    )
    ax1.set_title("$1/4^o$", fontsize=30)

    ax2 = plt.subplot(
        212,
        projection=ccrs.Orthographic(
            central_latitude=(lat.start + lat.stop) / 2,
            central_longitude=(lon.start + lon.stop) / 2,
        ),
    )
    # ax2.coastlines(resolution='110m')
    ax2.gridlines()
    im = (
        ZBke.isel(time=time_idx)
        .sel(xh=lon, yh=lat)
        .plot(
            ax=ax2,
            transform=ccrs.PlateCarree(),
            norm=mpl.colors.LogNorm(vmin=1e-3, vmax=1e0),
            cmap="inferno",
            add_colorbar=False,
        )
    )
    ax2.set_title("$1/4^o$, ZB2020", fontsize=30)
    cb = plt.colorbar(im, pad=0.02, ax=[ax1, ax2], extend="both", aspect=50, shrink=0.9)
    cb.set_label(label="Surface KE, $\mathrm{m}^2/\mathrm{s}^2$", fontsize=30)
    plt.suptitle(time_str)

Plotting the Surface Kinetic Energy in the North Atlantic region.

plot_Atlantic = lambda idx, fig, len_idx: plot_regions(
    i=idx, lat=slice(20, 60), lon=slice(-90, -40), fig=fig, len_idx=len_idx
)
plot_Atlantic(1461, None, None)
# plot_Atlantic(1826)

Saving the corresponding animation

%%time
create_gif(
    plot_Atlantic,
    range(1461, 1821, 5),
    filename="./Atlantic.gif",
    dpi=200,
    FPS=18,
    loop=0,
)

Processing frame (1/71)
Processing frame (2/71)
Processing frame (3/71)
Processing frame (4/71)
Processing frame (5/71)
Processing frame (6/71)
Processing frame (7/71)
Processing frame (8/71)
Processing frame (9/71)
Processing frame (10/71)
Processing frame (11/71)
Processing frame (12/71)
Processing frame (13/71)
Processing frame (14/71)
Processing frame (15/71)
Processing frame (16/71)
Processing frame (17/71)
Processing frame (18/71)
Processing frame (19/71)
Processing frame (20/71)
Processing frame (21/71)
Processing frame (22/71)
Processing frame (23/71)
Processing frame (24/71)
Processing frame (25/71)
Processing frame (26/71)
Processing frame (27/71)
Processing frame (28/71)
Processing frame (29/71)
Processing frame (30/71)
Processing frame (31/71)
Processing frame (32/71)
Processing frame (33/71)
Processing frame (34/71)
Processing frame (35/71)
Processing frame (36/71)
Processing frame (37/71)
Processing frame (38/71)
Processing frame (39/71)
Processing frame (40/71)
Processing frame (41/71)
Processing frame (42/71)
Processing frame (43/71)
Processing frame (44/71)
Processing frame (45/71)
Processing frame (46/71)
Processing frame (47/71)
Processing frame (48/71)
Processing frame (49/71)
Processing frame (50/71)
Processing frame (51/71)
Processing frame (52/71)
Processing frame (53/71)
Processing frame (54/71)
Processing frame (55/71)
Processing frame (56/71)
Processing frame (57/71)
Processing frame (58/71)
Processing frame (59/71)
Processing frame (60/71)
Processing frame (61/71)
Processing frame (62/71)
Processing frame (63/71)
Processing frame (64/71)
Processing frame (65/71)
Processing frame (66/71)
Processing frame (67/71)
Processing frame (68/71)
Processing frame (69/71)
Processing frame (70/71)
Processing frame (71/71)
CPU times: user 10min 15s, sys: 3min 37s, total: 13min 52s
Wall time: 9min 13s

Saved Gif:

Plotting the Surface Kinetic Energy in the Pacific region.

plot_Pacific = lambda idx, fig, len_idx: plot_regions(
    i=idx, lat=slice(20, 60), lon=slice(-240, -190), fig=fig, len_idx=len_idx
)
plot_Pacific(-1, None, None)

Saving the corresponding animation

%%time
create_gif(
    plot_Pacific,
    range(1461, 1821, 5),
    filename="./Pacific.gif",
    dpi=200,
    FPS=18,
    loop=0,
)

Processing frame (1/71)
Processing frame (2/71)
Processing frame (3/71)
Processing frame (4/71)
Processing frame (5/71)
Processing frame (6/71)
Processing frame (7/71)
Processing frame (8/71)
Processing frame (9/71)
Processing frame (10/71)
Processing frame (11/71)
Processing frame (12/71)
Processing frame (13/71)
Processing frame (14/71)
Processing frame (15/71)
Processing frame (16/71)
Processing frame (17/71)
Processing frame (18/71)
Processing frame (19/71)
Processing frame (20/71)
Processing frame (21/71)
Processing frame (22/71)
Processing frame (23/71)
Processing frame (24/71)
Processing frame (25/71)
Processing frame (26/71)
Processing frame (27/71)
Processing frame (28/71)
Processing frame (29/71)
Processing frame (30/71)
Processing frame (31/71)
Processing frame (32/71)
Processing frame (33/71)
Processing frame (34/71)
Processing frame (35/71)
Processing frame (36/71)
Processing frame (37/71)
Processing frame (38/71)
Processing frame (39/71)
Processing frame (40/71)
Processing frame (41/71)
Processing frame (42/71)
Processing frame (43/71)
Processing frame (44/71)
Processing frame (45/71)
Processing frame (46/71)
Processing frame (47/71)
Processing frame (48/71)
Processing frame (49/71)
Processing frame (50/71)
Processing frame (51/71)
Processing frame (52/71)
Processing frame (53/71)
Processing frame (54/71)
Processing frame (55/71)
Processing frame (56/71)
Processing frame (57/71)
Processing frame (58/71)
Processing frame (59/71)
Processing frame (60/71)
Processing frame (61/71)
Processing frame (62/71)
Processing frame (63/71)
Processing frame (64/71)
Processing frame (65/71)
Processing frame (66/71)
Processing frame (67/71)
Processing frame (68/71)
Processing frame (69/71)
Processing frame (70/71)
Processing frame (71/71)
CPU times: user 10min 14s, sys: 3min 28s, total: 13min 42s
Wall time: 9min

Saved Gif:

Plotting the Surface Kinetic Energy in the Aghulas region

plot_Aghulas = lambda idx, fig, len_idx: plot_regions(
    i=idx, lat=slice(-50, -10), lon=slice(0, 50), fig=fig, len_idx=len_idx
)
plot_Aghulas(-1, None, None)

Saving the corresponding animation

%%time
create_gif(
    plot_Aghulas,
    range(1461, 1821, 5),
    filename="./Aghulas.gif",
    dpi=200,
    FPS=18,
    loop=0,
)

Processing frame (1/71)
Processing frame (2/71)
Processing frame (3/71)
Processing frame (4/71)
Processing frame (5/71)
Processing frame (6/71)
Processing frame (7/71)
Processing frame (8/71)
Processing frame (9/71)
Processing frame (10/71)
Processing frame (11/71)
Processing frame (12/71)
Processing frame (13/71)
Processing frame (14/71)
Processing frame (15/71)
Processing frame (16/71)
Processing frame (17/71)
Processing frame (18/71)
Processing frame (19/71)
Processing frame (20/71)
Processing frame (21/71)
Processing frame (22/71)
Processing frame (23/71)
Processing frame (24/71)
Processing frame (25/71)
Processing frame (26/71)
Processing frame (27/71)
Processing frame (28/71)
Processing frame (29/71)
Processing frame (30/71)
Processing frame (31/71)
Processing frame (32/71)
Processing frame (33/71)
Processing frame (34/71)
Processing frame (35/71)
Processing frame (36/71)
Processing frame (37/71)
Processing frame (38/71)
Processing frame (39/71)
Processing frame (40/71)
Processing frame (41/71)
Processing frame (42/71)
Processing frame (43/71)
Processing frame (44/71)
Processing frame (45/71)
Processing frame (46/71)
Processing frame (47/71)
Processing frame (48/71)
Processing frame (49/71)
Processing frame (50/71)
Processing frame (51/71)
Processing frame (52/71)
Processing frame (53/71)
Processing frame (54/71)
Processing frame (55/71)
Processing frame (56/71)
Processing frame (57/71)
Processing frame (58/71)
Processing frame (59/71)
Processing frame (60/71)
Processing frame (61/71)
Processing frame (62/71)
Processing frame (63/71)
Processing frame (64/71)
Processing frame (65/71)
Processing frame (66/71)
Processing frame (67/71)
Processing frame (68/71)
Processing frame (69/71)
Processing frame (70/71)
Processing frame (71/71)
CPU times: user 10min 8s, sys: 3min 26s, total: 13min 34s
Wall time: 8min 57s

Saved Gif: