def test_pickling(fs, tmpdir):
filename = str(tmpdir.join('pickled_floatset.pkl'))
fs.to_pickle(filename)
fs_from_pickle = gen.FloatSet(load_path=filename)
for key in fs.__dict__.keys():
assert np.all(fs.__dict__[key] == fs_from_pickle.__dict__[key])
def hex_masked_grid(request):
xlim, ylim, dx, dy, _ = request.param
test = gen.FloatSet(xlim, ylim, dx, dy, model_grid=grid_dict)
rec_g = np.asarray(test.get_rectmesh())
hex_g = np.asarray(test.get_hexmesh())
grids_parm = dict(hex=hex_g, dx=dx, dy=dy)
return grids_parm
def test_pickling_3D_with_land(fs_3D_with_land, tmpdir):
fs = fs_3D_with_land
filename = str(tmpdir.join('pickled_floatset.pkl'))
fs.to_pickle(filename)
fs_from_pickle = gen.FloatSet(load_path=filename)
for key in fs.__dict__.keys():
if key is not 'model_grid':
assert np.all(fs.__dict__[key] == fs_from_pickle.__dict__[key])
else:
for sub_key in fs.__dict__[key].keys():
assert np.all(fs.__dict__[key][sub_key] == fs_from_pickle.__dict__[key][sub_key])
def fs_big():
# Nathaniel's funky big domain
#setup produces N = 16792975, exceeds float32 exact precision
xlim = (0.0, 102.5)
ylim = (-80.0,80.0)
dx = 1/32.
dy = 1/32.
#mask grid resolution is five times as coarse as the float set
Nx = int((xlim[1] - xlim[0]) / dx)/5
Ny = int((ylim[1] - ylim[0]) / dy)/5
lon = np.linspace(xlim[0], xlim[1], Nx)
lat = np.linspace(ylim[0], ylim[1], Ny)
#set entire domain to ocean
mask = np.ones((Ny, Nx), dtype='bool')
#make a small land island
mask[5:10,5:10] = False
model_grid = {'lon': lon, 'lat': lat, 'land_mask': mask}
fs = gen.FloatSet(xlim, ylim, dx, dy, model_grid=model_grid)
return fs
hex_g = np.asarray(test.get_hexmesh())
grids_parm = dict(hex=hex_g, dx=dx, dy=dy)
return grids_parm
def test_hex_grid(hex_masked_grid):
"""Make sure we can create masked hexagonal grids correctly."""
grids_parm = hex_masked_grid
# Make sure the separation between grid points is constant
# (i.e identical to dx)
grid_diff = np.diff(grids_parm['hex'][0, :].reshape(
grids_parm['dx'], grids_parm['dy']))
assert np.all(grid_diff == grids_parm['dx'])
if __name__ == "__main__":
import pylab as plt
xlim, ylim, dx, dy, _ = domain_geometries[0]
test = gen.FloatSet(xlim, ylim, dx, dy, model_grid=grid_dict)
rec_g = np.asarray(test.get_rectmesh())
hex_g = np.asarray(test.get_hexmesh())
grids_parm = dict(rec=rec_g, hex=hex_g, dx=dx)
dhex = grids_parm['hex']
drec = grids_parm['rec']
plt.plot(dhex[0, :], dhex[1, :], 'x', label='Hexagonal Grid')
plt.plot(drec[0, :], drec[1, :], 'or', label='Rectangular Grid')
plt.legend()
plt.show()
def fs_all(request):
xlim, ylim, dx, dy, model_grid = request.param
return gen.FloatSet(xlim, ylim, dx, dy, model_grid=model_grid)
def fs_3D_with_land(request):
xlim, ylim, dx, dy, model_grid, zvect = request.param
return gen.FloatSet(xlim, ylim, dx, dy, model_grid=model_grid,zvect=zvect)
def fs_3D(request):
xlim, ylim, dx, dy,_ , zvect= request.param
return gen.FloatSet(xlim, ylim, dx, dy,zvect=zvect)
def fs(request):
xlim, ylim, dx, dy, _ = request.param
return gen.FloatSet(xlim, ylim, dx, dy)
def test_npart_to_2D_array():
# floatsets
lon = np.arange(0, 9, dtype=np.float32)
lat = np.arange(-4, 5, dtype=np.float32)
land_mask = np.full(81, True, dtype=bool)
land_mask.shape = (len(lat), len(lon))
land_mask[:,0:2] = False
model_grid = {'lon': lon, 'lat': lat, 'land_mask': land_mask}
fs_none = gen.FloatSet(xlim=(0, 9), ylim=(-4, 5))
fs_mask = gen.FloatSet(xlim=(0, 9), ylim=(-4, 5), model_grid=model_grid)
fs_mask.get_rectmesh()
# dataarray/dataset
var_list = ['test_01', 'test_02', 'test_03']
values_list_none = []
values_list_mask = []
data_vars_none = {}
data_vars_mask = {}
len_none = 81
len_mask = list(fs_mask.ocean_bools).count(True)
for var in var_list:
values_none = np.random.random(len_none)
values_none.shape = (1, 1, len_none)
values_mask = np.random.random(len_mask)
values_mask.shape = (1, 1, len_mask)
values_list_none.append(values_none)
values_list_mask.append(values_mask)
data_vars_none.update({var: (['date', 'loc', 'npart'], values_none)})
data_vars_mask.update({var: (['date', 'loc', 'npart'], values_mask)})
npart_none = np.arange(1, len_none+1, dtype=np.int32)
npart_mask = np.arange(1, len_mask+1, dtype=np.int32)
coords_none = {'date': (['date'], np.array([np.datetime64('2000-01-01')])),
'loc': (['loc'], np.array(['New York'])),
'npart': (['npart'], npart_none)}
coords_mask = {'date': (['date'], np.array([np.datetime64('2000-01-01')])),
'loc': (['loc'], np.array(['New York'])),
'npart': (['npart'], npart_mask)}
ds1d_none = xr.Dataset(data_vars=data_vars_none, coords=coords_none)
ds1d_mask = xr.Dataset(data_vars=data_vars_mask, coords=coords_mask)
da1d_none = ds1d_none['test_01']
da1d_mask = ds1d_mask['test_01']
# starts testing
test_none = (fs_none, da1d_none, ds1d_none, values_list_none)
test_mask = (fs_mask, da1d_mask, ds1d_mask, values_list_mask)
test_list = [test_none, test_mask]
for fs, da1d, ds1d, values_list in test_list:
# method test
da2d = fs.npart_to_2D_array(da1d)
ds2d = fs.npart_to_2D_array(ds1d)
# shape test
assert da2d.to_array().values.shape == (1, 1, 1, fs.Ny, fs.Nx)
assert ds2d.to_array().values.shape == (3, 1, 1, fs.Ny, fs.Nx)
# dimension test
assert da2d.dims == {'date': 1, 'loc': 1, 'y0': 9, 'x0': 9}
assert ds2d.dims == {'date': 1, 'loc': 1, 'y0': 9, 'x0': 9}
# coordinates test
np.testing.assert_allclose(da2d.x0.values, fs.x)
np.testing.assert_allclose(da2d.y0.values, fs.y)
np.testing.assert_allclose(ds2d.x0.values, fs.x)
np.testing.assert_allclose(ds2d.y0.values, fs.y)
# values test
da1d_values = values_list[0][0][0]
da2d_values_full = da2d.to_array().values[0].ravel()
da2d_values = da2d_values_full[~np.isnan(da2d_values_full)]
np.testing.assert_allclose(da2d_values, da1d_values)
for i in range(3):
ds1d_values = values_list[i][0][0]
ds2d_values_full = ds2d.to_array().values[i].ravel()
ds2d_values = ds2d_values_full[~np.isnan(ds2d_values_full)]
np.testing.assert_allclose(ds2d_values, ds1d_values)
# mask test
if fs.model_grid is not None:
mask1d = fs.ocean_bools
mask2d_da = (np.isnan(da2d.to_array().values[0])==False).ravel()
np.testing.assert_allclose(mask2d_da, mask1d)
for i in range(3):
mask2d_ds = (np.isnan(ds2d.to_array().values[i])==False).ravel()
np.testing.assert_allclose(mask2d_ds, mask1d)
def test_npart_to_2D_array():
# floatsets
lon = np.linspace(0, 8, 9, dtype=np.float32)
lat = np.linspace(-4, 4, 9, dtype=np.float32)
land_mask = np.zeros(81, dtype=bool) == False
land_mask.shape = (len(lat), len(lon))
land_mask[:, 0:2] = False
model_grid = {'lon': lon, 'lat': lat, 'land_mask': land_mask}
fs_none = gen.FloatSet(xlim=(0, 9), ylim=(-4, 5), dx=1, dy=1)
fs_mask = gen.FloatSet(xlim=(0, 9),
ylim=(-4, 5),
dx=1,
dy=1,
model_grid=model_grid)
# dataarray/dataset
var_list = ['test_01', 'test_02', 'test_03']
values_list_none = []
values_list_mask = []
data_vars_none = {}
data_vars_mask = {}
for var in var_list:
values_none = np.random.random(81)
values_mask = np.random.random(69)
values_list_none.append(values_none)
values_list_mask.append(values_mask)
data_vars_none.update({var: (['npart'], values_none)})
data_vars_mask.update({var: (['npart'], values_mask)})
npart_none = np.linspace(1, 81, 81, dtype=np.int32)
npart_mask = np.linspace(1, 69, 69, dtype=np.int32)
coords_none = {'npart': (['npart'], npart_none)}
coords_mask = {'npart': (['npart'], npart_mask)}
ds1d_none = xr.Dataset(data_vars=data_vars_none, coords=coords_none)
ds1d_mask = xr.Dataset(data_vars=data_vars_mask, coords=coords_mask)
da1d_none = ds1d_none['test_01']
da1d_mask = ds1d_mask['test_01']
# starts testing
test_none = (fs_none, da1d_none, ds1d_none, values_list_none)
test_mask = (fs_mask, da1d_mask, ds1d_mask, values_list_mask)
test_list = [test_none, test_mask]
for fs, da1d, ds1d, values_list in test_list:
fs.get_rectmesh()
# method test
da2d = fs.npart_to_2D_array(da1d)
ds2d = fs.npart_to_2D_array(ds1d)
# shape test
assert da2d.to_array().values.shape == (1, fs.Ny, fs.Nx)
assert ds2d.to_array().values.shape == (3, fs.Ny, fs.Nx)
# coordinates test
np.testing.assert_allclose(da2d.lon.values, fs.x)
np.testing.assert_allclose(da2d.lat.values, fs.y)
np.testing.assert_allclose(ds2d.lon.values, fs.x)
np.testing.assert_allclose(ds2d.lat.values, fs.y)
# values test
da1d_values = values_list[0]
da2d_values_full = da2d.to_array().values[0].ravel()
da2d_values = da2d_values_full[~np.isnan(da2d_values_full)]
np.testing.assert_allclose(da2d_values, da1d_values)
for i in range(3):
ds1d_values = values_list[i]
ds2d_values_full = ds2d.to_array().values[i].ravel()
ds2d_values = ds2d_values_full[~np.isnan(ds2d_values_full)]
np.testing.assert_allclose(ds2d_values, ds1d_values)
# mask test
if fs.model_grid is not None:
mask1d = fs.ocean_bools
mask2d_da = (np.isnan(da2d.to_array().values[0]) == False).ravel()
np.testing.assert_allclose(mask2d_da, mask1d)
for i in range(3):
mask2d_ds = (np.isnan(
ds2d.to_array().values[i]) == False).ravel()
np.testing.assert_allclose(mask2d_ds, mask1d)
