def test_eos_ds_dask():
fname = DATASETS.fetch('cesm_pop_monthly.T62_g17.nc')
ds = xr.open_dataset(fname,
decode_times=False,
decode_coords=False,
chunks={'z_t': 20})
rho = pop_tools.eos(ds.SALT, ds.TEMP, depth=ds.z_t * 1e-2)
assert isinstance(rho, xr.DataArray)
def mld_dsigma(SALT, TEMP, dsigma=0.03, rho_chunks={'nlat': 16, 'nlon': 16}):
"""
Compute MLD based on ∆σ criterion. Uses xarray.map_blocks.
Parameters
----------
SALT : xarray.DataArray
Salinity
TEMP : xarray.DataArray
Potential temperature
dsigma : float, optional
The value for ∆σ.
Returns
-------
MLD : xarray.DataArray
The MLD (m) defined as the point in the water column where
density exceeds rho[0] + dsigma.
"""
# determine dimensionality
dims_in = SALT.dims
assert dims_in == TEMP.dims, 'dimension mismatch'
assert 'z_t' in SALT.coords, 'z_t not found in SALT coords'
# drop ancillary coordinates (this may not be necessary)
SALT = SALT.reset_coords(drop=True)
TEMP = TEMP.reset_coords(drop=True)
# compute density
rho = pop_tools.eos(SALT.chunk({'z_t': 10}),
TEMP.chunk({'z_t': 10}),
depth=SALT.z_t * 0.).compute()
if 'nlat' in rho.dims:
rho = rho.assign_coords({
'nlat':
xr.DataArray(np.arange(len(SALT.nlat)), dims=('nlat')),
'nlon':
xr.DataArray(np.arange(len(SALT.nlon)), dims=('nlon')),
})
rho = rho.chunk(rho_chunks).persist()
# compute and return MLD
template = rho.isel(z_t=0).drop('z_t')
template.attrs['long_name'] = 'MLD'
template.attrs['units'] = SALT.z_t.attrs['units']
template.name = 'MLD'
return xr.map_blocks(
_interp_mld,
rho,
kwargs=dict(dsigma=dsigma),
template=template,
)
def test_eos_ds_dask():
ds = xr.open_dataset(
f'{testdata_dir}/cesm_pop_monthly.T62_g17.nc',
decode_times=False,
decode_coords=False,
chunks={'z_t': 20},
)
rho = pop_tools.eos(ds.SALT, ds.TEMP, depth=ds.z_t * 1e-2)
assert isinstance(rho, xr.DataArray)
def test_eos_xarray_2():
ds = xr.open_dataset(f'{testdata_dir}/cesm_pop_monthly.T62_g17.nc',
decode_times=False,
decode_coords=False)
rho, drhodS, drhodT = pop_tools.eos(ds.SALT,
ds.TEMP,
depth=ds.z_t * 1e-2,
return_coefs=True)
assert isinstance(rho, xr.DataArray)
def test_eos_xarray_2():
fname = DATASETS.fetch('cesm_pop_monthly.T62_g17.nc')
ds = xr.open_dataset(fname, decode_times=False, decode_coords=False)
rho, drhodS, drhodT = pop_tools.eos(ds.SALT,
ds.TEMP,
depth=ds.z_t * 1e-2,
return_coefs=True)
assert isinstance(rho, xr.DataArray)
assert isinstance(drhodS, xr.DataArray)
assert isinstance(drhodT, xr.DataArray)
})
sigma_mid.encoding['_FillValue'] = None
sigma_bot = xr.DataArray(sig2_bot,
dims=['sigma_bot'],
attrs={
'long_name': 'Sigma2 at bottom of layer',
'units': 'kg/m^3'
})
sigma_bot.encoding['_FillValue'] = None
# Compute POP sigma2 field (NOTE: this is only necessary if sigmacoord=True)
# using pop_tools:
depth = xr.DataArray(np.ones(np.shape(salt)) * 2000.,
dims=salt.dims,
coords=salt.coords)
sigma2 = pop_tools.eos(salt=salt, temp=temp, depth=depth)
sigma2 = sigma2 - 1000.
# using gsw functions:
# first, convert model depth to pressure
# (gsw function require numpy arrays, not xarray, so use ".values")
# (use [:,None,None] syntax to conform the z_t and tlat into 3D arrays)
#press = gsw.p_from_z(-z_t.values[:,None,None],tlat.values[None,:,:])
# compute absolute salinity from practical salinity
#SA = gsw.SA_from_SP(salt,press[None,:,:,:],tlon.values[None,None,:,:],tlat.values[None,None,:,:])
# compute conservative temperature from potential temperature
#CT = gsw.CT_from_pt(SA,temp.values)
#sigma2 = gsw.sigma2(SA,CT)
time3 = timer.time()
print('Timing: EOS call = ', time3 - time2a, 's')
# convert to DataArray & regrid from T-grid to U-grid
def test_eos_numpy_1():
rho = pop_tools.eos(35.0, 20.0, pressure=2000.0)
np.testing.assert_almost_equal(rho, 1033.2133865866824181, decimal=14)
def test_eos_numpy_3():
rho, drhodS, drhodT = pop_tools.eos(35.0,
20.0,
pressure=2000.0,
return_coefs=True)
np.testing.assert_almost_equal(rho, 1033.2133865866824181, decimal=14)
def test_eos_numpy_2():
rho = pop_tools.eos(35.0, 20.0, depth=1976.5347494030665985)
np.testing.assert_almost_equal(rho, 1033.2133865866824181, decimal=14)
tlat = ds['TLAT']
tarea = ds['TAREA']
ssd = ds['RHO'].isel(z_t=0)
ssd = ssd.drop(['z_t'])
sst = ds['TEMP'].isel(z_t=0)
sss_psu = ds['SALT'].isel(z_t=0)
sss_msu = sss_psu.copy() / 1000.
sss_msu.attrs['units'] = 'kg/kg'
nt = np.shape(sst)[0]
ny = np.shape(sst)[1]
nx = np.shape(sst)[2]
# Compute rho, alpha, & beta using pop-tools.eos
depth = xr.DataArray(np.zeros(np.shape(sst)), dims=sst.dims, coords=sst.coords)
rho, drhods, drhodt = pop_tools.eos(salt=sss_psu,
temp=sst,
return_coefs=True,
depth=depth)
alpha = (drhodt / rho) * -1 # 1/degC
beta = (drhods / rho) # kg(Seawater)/kg(SALT)
sigma0 = rho - 1000.
sigma0 = sigma0.drop(['z_t'])
sigma0.attrs['units'] = 'kg/m^3'
sigma0.attrs['long_name'] = 'Sigma referenced to z=0'
sigma0.encoding['_FillValue'] = 1.e30
depth = depth + 2000.
tmp = pop_tools.eos(salt=sss_psu, temp=sst, return_coefs=False, depth=depth)
sigma2 = tmp - 1000.
sigma2 = sigma2.drop(['z_t'])
sigma2.attrs['units'] = 'kg/m^3'
sigma2.attrs['long_name'] = 'Sigma referenced to z=2000'
