xnemogcm documentation

Get started

  • Get started

Examples

  • open files / Datasets
  • recombine files
  • compute metrics

API

  • API

For contributors

  • What's new
  • Dev environment
  • Code of conduct
  • GitHub repository
xnemogcm documentation
  • Examples
  • recombine files

Two types of files related to the domain grid can be of use with NEMO: the domain_cfg files and the mesh_mask files. They are very similar, and any of them can be used by xnemogcm. If you are using a realistic (regional or global) configuration, they are provided as input files to NEMO so you should have these file. If you are using idealised configuration with analytical bathymetry, these files can be outputted by NEMO.

By default, NEMO outputs a mesh_mask / domain_cfg file per computing processor, if the namelist parameter is set on .true.:

  • ln_write_cfg = .true. to output the domain_cfg if created analytically in the usrdef_zgr.F90 and usrdef_hgr.F90 files
  • ln_meshmask = .true. to output the mesh_mask files (that also contain the masks)

While it is possible to recombine the files using the nemo fortran toolbox, xnemogcm can also recombine them easily.

Start by importing the functions

In [1]:
Copied! 
from pathlib import Path
from os import listdir

from xnemogcm import open_domain_cfg, open_nemo_and_domain_cfg
from xnemogcm import __version__ as xnemogcm_version
from pathlib import Path from os import listdir from xnemogcm import open_domain_cfg, open_nemo_and_domain_cfg from xnemogcm import __version__ as xnemogcm_version
In [2]:
Copied! 
xnemogcm_version
xnemogcm_version
Out[2]:
'0.5.0.post2'

We use a data folder from the test data:

In [3]:
Copied! 
datadir = Path('../../xnemogcm/test/data/4.2.0/mesh_mask_multi_files/')
datadir = Path('../../xnemogcm/test/data/4.2.0/mesh_mask_multi_files/')
In [4]:
Copied! 
print(listdir(datadir))
print(listdir(datadir))
['mesh_mask_0000.nc', 'mesh_mask_0003.nc', 'mesh_mask_0002.nc', 'mesh_mask_0001.nc']
In [5]:
Copied! 
domcfg = open_domain_cfg(datadir=datadir)
domcfg
domcfg = open_domain_cfg(datadir=datadir) domcfg
Out[5]:
<xarray.Dataset> Size: 324kB
Dimensions:    (z_c: 4, y_c: 22, x_c: 32, x_f: 32, y_f: 22, z_f: 4)
Coordinates: (12/18)
    glamt      (y_c, x_c) float64 6kB dask.array<chunksize=(11, 16), meta=np.ndarray>
    glamu      (y_c, x_f) float64 6kB dask.array<chunksize=(11, 16), meta=np.ndarray>
    glamv      (y_f, x_c) float64 6kB dask.array<chunksize=(11, 16), meta=np.ndarray>
    glamf      (y_f, x_f) float64 6kB dask.array<chunksize=(11, 16), meta=np.ndarray>
    gphit      (y_c, x_c) float64 6kB dask.array<chunksize=(11, 16), meta=np.ndarray>
    gphiu      (y_c, x_f) float64 6kB dask.array<chunksize=(11, 16), meta=np.ndarray>
    ...         ...
  * x_f        (x_f) float64 256B 0.5 1.5 2.5 3.5 4.5 ... 28.5 29.5 30.5 31.5
  * y_f        (y_f) float64 176B 0.5 1.5 2.5 3.5 4.5 ... 18.5 19.5 20.5 21.5
  * z_f        (z_f) float64 32B -0.5 0.5 1.5 2.5
  * x_c        (x_c) int64 256B 0 1 2 3 4 5 6 7 8 ... 23 24 25 26 27 28 29 30 31
  * y_c        (y_c) int64 176B 0 1 2 3 4 5 6 7 8 ... 13 14 15 16 17 18 19 20 21
  * z_c        (z_c) int64 32B 0 1 2 3
Data variables: (12/28)
    tmask      (z_c, y_c, x_c) int8 3kB dask.array<chunksize=(4, 11, 16), meta=np.ndarray>
    umask      (z_c, y_c, x_f) int8 3kB dask.array<chunksize=(4, 11, 16), meta=np.ndarray>
    vmask      (z_c, y_f, x_c) int8 3kB dask.array<chunksize=(4, 11, 16), meta=np.ndarray>
    fmask      (z_c, y_f, x_f) int8 3kB dask.array<chunksize=(4, 11, 16), meta=np.ndarray>
    tmaskutil  (y_c, x_c) int8 704B dask.array<chunksize=(11, 16), meta=np.ndarray>
    umaskutil  (y_c, x_f) int8 704B dask.array<chunksize=(11, 16), meta=np.ndarray>
    ...         ...
    e3u_0      (z_c, y_c, x_f) float64 23kB dask.array<chunksize=(4, 11, 16), meta=np.ndarray>
    e3v_0      (z_c, y_f, x_c) float64 23kB dask.array<chunksize=(4, 11, 16), meta=np.ndarray>
    e3f_0      (z_c, y_f, x_f) float64 23kB dask.array<chunksize=(4, 11, 16), meta=np.ndarray>
    e3w_0      (z_f, y_c, x_c) float64 23kB dask.array<chunksize=(4, 11, 16), meta=np.ndarray>
    e3uw_0     (z_f, y_c, x_f) float64 23kB dask.array<chunksize=(4, 11, 16), meta=np.ndarray>
    e3vw_0     (z_f, y_f, x_c) float64 23kB dask.array<chunksize=(4, 11, 16), meta=np.ndarray>
Attributes: (12/13)
    DOMAIN_dimensions_ids:   [1 2]
    DOMAIN_size_global:      [32 22]
    DOMAIN_halo_size_start:  [0 0]
    DOMAIN_halo_size_end:    [0 0]
    DOMAIN_type:             BOX
    CfgName:                 GYRE
    ...                      ...
    Iperio:                  0
    Jperio:                  0
    NFold:                   0
    NFtype:                  -
    VertCoord:               zco
    IsfCav:                  0
xarray.Dataset
    • z_c: 4
    • y_c: 22
    • x_c: 32
    • x_f: 32
    • y_f: 22
    • z_f: 4
    • glamt
      (y_c, x_c)
      float64
      dask.array<chunksize=(11, 16), meta=np.ndarray>
      standard_name :
      longitude
      units :
      degrees_east
      Array Chunk
      Bytes 5.50 kiB 1.38 kiB
      Shape (22, 32) (11, 16)
      Dask graph 4 chunks in 12 graph layers
      Data type float64 numpy.ndarray
      		32 22
    • glamu
      (y_c, x_f)
      float64
      dask.array<chunksize=(11, 16), meta=np.ndarray>
      standard_name :
      longitude
      units :
      degrees_east
      Array Chunk
      Bytes 5.50 kiB 1.38 kiB
      Shape (22, 32) (11, 16)
      Dask graph 4 chunks in 12 graph layers
      Data type float64 numpy.ndarray
      		32 22
    • glamv
      (y_f, x_c)
      float64
      dask.array<chunksize=(11, 16), meta=np.ndarray>
      standard_name :
      longitude
      units :
      degrees_east
      Array Chunk
      Bytes 5.50 kiB 1.38 kiB
      Shape (22, 32) (11, 16)
      Dask graph 4 chunks in 12 graph layers
      Data type float64 numpy.ndarray
      		32 22
    • glamf
      (y_f, x_f)
      float64
      dask.array<chunksize=(11, 16), meta=np.ndarray>
      standard_name :
      longitude
      units :
      degrees_east
      Array Chunk
      Bytes 5.50 kiB 1.38 kiB
      Shape (22, 32) (11, 16)
      Dask graph 4 chunks in 12 graph layers
      Data type float64 numpy.ndarray
      		32 22
    • gphit
      (y_c, x_c)
      float64
      dask.array<chunksize=(11, 16), meta=np.ndarray>
      standard_name :
      latitude
      units :
      degrees_north
      Array Chunk
      Bytes 5.50 kiB 1.38 kiB
      Shape (22, 32) (11, 16)
      Dask graph 4 chunks in 12 graph layers
      Data type float64 numpy.ndarray
      		32 22
    • gphiu
      (y_c, x_f)
      float64
      dask.array<chunksize=(11, 16), meta=np.ndarray>
      standard_name :
      latitude
      units :
      degrees_north
      Array Chunk
      Bytes 5.50 kiB 1.38 kiB
      Shape (22, 32) (11, 16)
      Dask graph 4 chunks in 12 graph layers
      Data type float64 numpy.ndarray
      		32 22
    • gphiv
      (y_f, x_c)
      float64
      dask.array<chunksize=(11, 16), meta=np.ndarray>
      standard_name :
      latitude
      units :
      degrees_north
      Array Chunk
      Bytes 5.50 kiB 1.38 kiB
      Shape (22, 32) (11, 16)
      Dask graph 4 chunks in 12 graph layers
      Data type float64 numpy.ndarray
      		32 22
    • gphif
      (y_f, x_f)
      float64
      dask.array<chunksize=(11, 16), meta=np.ndarray>
      standard_name :
      latitude
      units :
      degrees_north
      Array Chunk
      Bytes 5.50 kiB 1.38 kiB
      Shape (22, 32) (11, 16)
      Dask graph 4 chunks in 12 graph layers
      Data type float64 numpy.ndarray
      		32 22
    • gdept_1d
      (z_c)
      float64
      dask.array<chunksize=(4,), meta=np.ndarray>
      standard_name :
      depth
      units :
      m
      positive :
      down
      Array Chunk
      Bytes 32 B 32 B
      Shape (4,) (4,)
      Dask graph 1 chunks in 7 graph layers
      Data type float64 numpy.ndarray
      		4 1
    • gdepw_1d
      (z_f)
      float64
      dask.array<chunksize=(4,), meta=np.ndarray>
      standard_name :
      depth
      units :
      m
      positive :
      down
      Array Chunk
      Bytes 32 B 32 B
      Shape (4,) (4,)
      Dask graph 1 chunks in 7 graph layers
      Data type float64 numpy.ndarray
      		4 1
    • gdept_0
      (z_c, y_c, x_c)
      float64
      dask.array<chunksize=(4, 11, 16), meta=np.ndarray>
      standard_name :
      depth
      units :
      m
      positive :
      down
      Array Chunk
      Bytes 22.00 kiB 5.50 kiB
      Shape (4, 22, 32) (4, 11, 16)
      Dask graph 4 chunks in 12 graph layers
      Data type float64 numpy.ndarray
      		32 22 4
    • gdepw_0
      (z_f, y_c, x_c)
      float64
      dask.array<chunksize=(4, 11, 16), meta=np.ndarray>
      standard_name :
      depth
      units :
      m
      positive :
      down
      Array Chunk
      Bytes 22.00 kiB 5.50 kiB
      Shape (4, 22, 32) (4, 11, 16)
      Dask graph 4 chunks in 12 graph layers
      Data type float64 numpy.ndarray
      		32 22 4
    • x_f
      (x_f)
      float64
      0.5 1.5 2.5 3.5 ... 29.5 30.5 31.5
      axis :
      X
      c_grid_axis_shift :
      0.5
      array([ 0.5,  1.5,  2.5,  3.5,  4.5,  5.5,  6.5,  7.5,  8.5,  9.5, 10.5, 11.5,
       12.5, 13.5, 14.5, 15.5, 16.5, 17.5, 18.5, 19.5, 20.5, 21.5, 22.5, 23.5,
       24.5, 25.5, 26.5, 27.5, 28.5, 29.5, 30.5, 31.5])
    • y_f
      (y_f)
      float64
      0.5 1.5 2.5 3.5 ... 19.5 20.5 21.5
      axis :
      Y
      c_grid_axis_shift :
      0.5
      array([ 0.5,  1.5,  2.5,  3.5,  4.5,  5.5,  6.5,  7.5,  8.5,  9.5, 10.5, 11.5,
       12.5, 13.5, 14.5, 15.5, 16.5, 17.5, 18.5, 19.5, 20.5, 21.5])
    • z_f
      (z_f)
      float64
      -0.5 0.5 1.5 2.5
      axis :
      Z
      c_grid_axis_shift :
      -0.5
      array([-0.5,  0.5,  1.5,  2.5])
    • x_c
      (x_c)
      int64
      0 1 2 3 4 5 6 ... 26 27 28 29 30 31
      axis :
      X
      array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,
       18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31])
    • y_c
      (y_c)
      int64
      0 1 2 3 4 5 6 ... 16 17 18 19 20 21
      axis :
      Y
      array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,
       18, 19, 20, 21])
    • z_c
      (z_c)
      int64
      0 1 2 3
      axis :
      Z
      array([0, 1, 2, 3])
    • tmask
      (z_c, y_c, x_c)
      int8
      dask.array<chunksize=(4, 11, 16), meta=np.ndarray>
      Array Chunk
      Bytes 2.75 kiB 704 B
      Shape (4, 22, 32) (4, 11, 16)
      Dask graph 4 chunks in 12 graph layers
      Data type int8 numpy.ndarray
      		32 22 4
    • umask
      (z_c, y_c, x_f)
      int8
      dask.array<chunksize=(4, 11, 16), meta=np.ndarray>
      Array Chunk
      Bytes 2.75 kiB 704 B
      Shape (4, 22, 32) (4, 11, 16)
      Dask graph 4 chunks in 12 graph layers
      Data type int8 numpy.ndarray
      		32 22 4
    • vmask
      (z_c, y_f, x_c)
      int8
      dask.array<chunksize=(4, 11, 16), meta=np.ndarray>
      Array Chunk
      Bytes 2.75 kiB 704 B
      Shape (4, 22, 32) (4, 11, 16)
      Dask graph 4 chunks in 12 graph layers
      Data type int8 numpy.ndarray
      		32 22 4
    • fmask
      (z_c, y_f, x_f)
      int8
      dask.array<chunksize=(4, 11, 16), meta=np.ndarray>
      Array Chunk
      Bytes 2.75 kiB 704 B
      Shape (4, 22, 32) (4, 11, 16)
      Dask graph 4 chunks in 12 graph layers
      Data type int8 numpy.ndarray
      		32 22 4
    • tmaskutil
      (y_c, x_c)
      int8
      dask.array<chunksize=(11, 16), meta=np.ndarray>
      Array Chunk
      Bytes 704 B 176 B
      Shape (22, 32) (11, 16)
      Dask graph 4 chunks in 12 graph layers
      Data type int8 numpy.ndarray
      		32 22
    • umaskutil
      (y_c, x_f)
      int8
      dask.array<chunksize=(11, 16), meta=np.ndarray>
      Array Chunk
      Bytes 704 B 176 B
      Shape (22, 32) (11, 16)
      Dask graph 4 chunks in 12 graph layers
      Data type int8 numpy.ndarray
      		32 22
    • vmaskutil
      (y_f, x_c)
      int8
      dask.array<chunksize=(11, 16), meta=np.ndarray>
      Array Chunk
      Bytes 704 B 176 B
      Shape (22, 32) (11, 16)
      Dask graph 4 chunks in 12 graph layers
      Data type int8 numpy.ndarray
      		32 22
    • e1t
      (y_c, x_c)
      float64
      dask.array<chunksize=(11, 16), meta=np.ndarray>
      units :
      m
      Array Chunk
      Bytes 5.50 kiB 1.38 kiB
      Shape (22, 32) (11, 16)
      Dask graph 4 chunks in 12 graph layers
      Data type float64 numpy.ndarray
      		32 22
    • e1u
      (y_c, x_f)
      float64
      dask.array<chunksize=(11, 16), meta=np.ndarray>
      units :
      m
      Array Chunk
      Bytes 5.50 kiB 1.38 kiB
      Shape (22, 32) (11, 16)
      Dask graph 4 chunks in 12 graph layers
      Data type float64 numpy.ndarray
      		32 22
    • e1v
      (y_f, x_c)
      float64
      dask.array<chunksize=(11, 16), meta=np.ndarray>
      units :
      m
      Array Chunk
      Bytes 5.50 kiB 1.38 kiB
      Shape (22, 32) (11, 16)
      Dask graph 4 chunks in 12 graph layers
      Data type float64 numpy.ndarray
      		32 22
    • e1f
      (y_f, x_f)
      float64
      dask.array<chunksize=(11, 16), meta=np.ndarray>
      units :
      m
      Array Chunk
      Bytes 5.50 kiB 1.38 kiB
      Shape (22, 32) (11, 16)
      Dask graph 4 chunks in 12 graph layers
      Data type float64 numpy.ndarray
      		32 22
    • e2t
      (y_c, x_c)
      float64
      dask.array<chunksize=(11, 16), meta=np.ndarray>
      units :
      m
      Array Chunk
      Bytes 5.50 kiB 1.38 kiB
      Shape (22, 32) (11, 16)
      Dask graph 4 chunks in 12 graph layers
      Data type float64 numpy.ndarray
      		32 22
    • e2u
      (y_c, x_f)
      float64
      dask.array<chunksize=(11, 16), meta=np.ndarray>
      units :
      m
      Array Chunk
      Bytes 5.50 kiB 1.38 kiB
      Shape (22, 32) (11, 16)
      Dask graph 4 chunks in 12 graph layers
      Data type float64 numpy.ndarray
      		32 22
    • e2v
      (y_f, x_c)
      float64
      dask.array<chunksize=(11, 16), meta=np.ndarray>
      units :
      m
      Array Chunk
      Bytes 5.50 kiB 1.38 kiB
      Shape (22, 32) (11, 16)
      Dask graph 4 chunks in 12 graph layers
      Data type float64 numpy.ndarray
      		32 22
    • e2f
      (y_f, x_f)
      float64
      dask.array<chunksize=(11, 16), meta=np.ndarray>
      units :
      m
      Array Chunk
      Bytes 5.50 kiB 1.38 kiB
      Shape (22, 32) (11, 16)
      Dask graph 4 chunks in 12 graph layers
      Data type float64 numpy.ndarray
      		32 22
    • ff_f
      (y_f, x_f)
      float64
      dask.array<chunksize=(11, 16), meta=np.ndarray>
      standard_name :
      coriolis_parameter
      units :
      s-1
      Array Chunk
      Bytes 5.50 kiB 1.38 kiB
      Shape (22, 32) (11, 16)
      Dask graph 4 chunks in 12 graph layers
      Data type float64 numpy.ndarray
      		32 22
    • ff_t
      (y_c, x_c)
      float64
      dask.array<chunksize=(11, 16), meta=np.ndarray>
      standard_name :
      coriolis_parameter
      units :
      s-1
      Array Chunk
      Bytes 5.50 kiB 1.38 kiB
      Shape (22, 32) (11, 16)
      Dask graph 4 chunks in 12 graph layers
      Data type float64 numpy.ndarray
      		32 22
    • mbathy
      (y_c, x_c)
      int32
      dask.array<chunksize=(11, 16), meta=np.ndarray>
      Array Chunk
      Bytes 2.75 kiB 704 B
      Shape (22, 32) (11, 16)
      Dask graph 4 chunks in 12 graph layers
      Data type int32 numpy.ndarray
      		32 22
    • misf
      (y_c, x_c)
      int32
      dask.array<chunksize=(11, 16), meta=np.ndarray>
      Array Chunk
      Bytes 2.75 kiB 704 B
      Shape (22, 32) (11, 16)
      Dask graph 4 chunks in 12 graph layers
      Data type int32 numpy.ndarray
      		32 22
    • e3t_1d
      (z_c)
      float64
      dask.array<chunksize=(4,), meta=np.ndarray>
      standard_name :
      cell_thickness
      units :
      m
      Array Chunk
      Bytes 32 B 32 B
      Shape (4,) (4,)
      Dask graph 1 chunks in 7 graph layers
      Data type float64 numpy.ndarray
      		4 1
    • e3w_1d
      (z_f)
      float64
      dask.array<chunksize=(4,), meta=np.ndarray>
      standard_name :
      cell_thickness
      units :
      m
      Array Chunk
      Bytes 32 B 32 B
      Shape (4,) (4,)
      Dask graph 1 chunks in 7 graph layers
      Data type float64 numpy.ndarray
      		4 1
    • e3t_0
      (z_c, y_c, x_c)
      float64
      dask.array<chunksize=(4, 11, 16), meta=np.ndarray>
      standard_name :
      cell_thickness
      units :
      m
      Array Chunk
      Bytes 22.00 kiB 5.50 kiB
      Shape (4, 22, 32) (4, 11, 16)
      Dask graph 4 chunks in 12 graph layers
      Data type float64 numpy.ndarray
      		32 22 4
    • e3u_0
      (z_c, y_c, x_f)
      float64
      dask.array<chunksize=(4, 11, 16), meta=np.ndarray>
      standard_name :
      cell_thickness
      units :
      m
      Array Chunk
      Bytes 22.00 kiB 5.50 kiB
      Shape (4, 22, 32) (4, 11, 16)
      Dask graph 4 chunks in 12 graph layers
      Data type float64 numpy.ndarray
      		32 22 4
    • e3v_0
      (z_c, y_f, x_c)
      float64
      dask.array<chunksize=(4, 11, 16), meta=np.ndarray>
      standard_name :
      cell_thickness
      units :
      m
      Array Chunk
      Bytes 22.00 kiB 5.50 kiB
      Shape (4, 22, 32) (4, 11, 16)
      Dask graph 4 chunks in 12 graph layers
      Data type float64 numpy.ndarray
      		32 22 4
    • e3f_0
      (z_c, y_f, x_f)
      float64
      dask.array<chunksize=(4, 11, 16), meta=np.ndarray>
      standard_name :
      cell_thickness
      units :
      m
      Array Chunk
      Bytes 22.00 kiB 5.50 kiB
      Shape (4, 22, 32) (4, 11, 16)
      Dask graph 4 chunks in 12 graph layers
      Data type float64 numpy.ndarray
      		32 22 4
    • e3w_0
      (z_f, y_c, x_c)
      float64
      dask.array<chunksize=(4, 11, 16), meta=np.ndarray>
      standard_name :
      cell_thickness
      units :
      m
      Array Chunk
      Bytes 22.00 kiB 5.50 kiB
      Shape (4, 22, 32) (4, 11, 16)
      Dask graph 4 chunks in 12 graph layers
      Data type float64 numpy.ndarray
      		32 22 4
    • e3uw_0
      (z_f, y_c, x_f)
      float64
      dask.array<chunksize=(4, 11, 16), meta=np.ndarray>
      standard_name :
      cell_thickness
      units :
      m
      Array Chunk
      Bytes 22.00 kiB 5.50 kiB
      Shape (4, 22, 32) (4, 11, 16)
      Dask graph 4 chunks in 12 graph layers
      Data type float64 numpy.ndarray
      		32 22 4
    • e3vw_0
      (z_f, y_f, x_c)
      float64
      dask.array<chunksize=(4, 11, 16), meta=np.ndarray>
      standard_name :
      cell_thickness
      units :
      m
      Array Chunk
      Bytes 22.00 kiB 5.50 kiB
      Shape (4, 22, 32) (4, 11, 16)
      Dask graph 4 chunks in 12 graph layers
      Data type float64 numpy.ndarray
      		32 22 4
    • x_c
      PandasIndex
      PandasIndex(Index([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,
       18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31],
      dtype='int64', name='x_c'))
    • x_f
      PandasIndex
      PandasIndex(Index([ 0.5,  1.5,  2.5,  3.5,  4.5,  5.5,  6.5,  7.5,  8.5,  9.5, 10.5, 11.5,
       12.5, 13.5, 14.5, 15.5, 16.5, 17.5, 18.5, 19.5, 20.5, 21.5, 22.5, 23.5,
       24.5, 25.5, 26.5, 27.5, 28.5, 29.5, 30.5, 31.5],
      dtype='float64', name='x_f'))
    • y_c
      PandasIndex
      PandasIndex(Index([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
       20, 21],
      dtype='int64', name='y_c'))
    • y_f
      PandasIndex
      PandasIndex(Index([ 0.5,  1.5,  2.5,  3.5,  4.5,  5.5,  6.5,  7.5,  8.5,  9.5, 10.5, 11.5,
       12.5, 13.5, 14.5, 15.5, 16.5, 17.5, 18.5, 19.5, 20.5, 21.5],
      dtype='float64', name='y_f'))
    • z_c
      PandasIndex
      PandasIndex(Index([0, 1, 2, 3], dtype='int64', name='z_c'))
    • z_f
      PandasIndex
      PandasIndex(Index([-0.5, 0.5, 1.5, 2.5], dtype='float64', name='z_f'))
  • DOMAIN_dimensions_ids :
    [1 2]
    DOMAIN_size_global :
    [32 22]
    DOMAIN_halo_size_start :
    [0 0]
    DOMAIN_halo_size_end :
    [0 0]
    DOMAIN_type :
    BOX
    CfgName :
    GYRE
    CfgIndex :
    1
    Iperio :
    0
    Jperio :
    0
    NFold :
    0
    NFtype :
    -
    VertCoord :
    zco
    IsfCav :
    0

We verify that the variables are the same than when opening a unique full mesh_mask file.

In [6]:
Copied! 
domcfg_1_file = open_domain_cfg(datadir=Path('../../xnemogcm/test/data/4.2.0/mesh_mask_1_file/'), files=['mesh_mask.nc'])
domcfg_1_file = open_domain_cfg(datadir=Path('../../xnemogcm/test/data/4.2.0/mesh_mask_1_file/'), files=['mesh_mask.nc'])
In [7]:
Copied! 
domcfg_1_file.equals(domcfg)
domcfg_1_file.equals(domcfg)
Out[7]:
True
Previous Next
Built with MkDocs using a theme provided by Read the Docs.