def test_variables(self):
row = VectorDimension(value=[5, 6])
col = VectorDimension(value=[7, 8])
grid = SpatialGridDimension(row=row, col=col)
sdim = SpatialDimension(grid=grid)
temporal = TemporalDimension(value=[5000])
field = Field(spatial=sdim, temporal=temporal)
self.assertIsInstance(field.variables, VariableCollection)
self.assertEqual(len(field.variables), 0)
self.assertEqual(field.shape, (1, 1, 1, 2, 2))
with self.assertRaises(ValueError):
field.variables = 'foo'
def test_write_netcdf_scale_offset(self):
"""Test with a scale and offset in the attributes."""
var = Variable(value=np.random.rand(1, 1, 1, 3, 4), attrs={'scale_value': 2, 'add_offset': 10}, name='tas')
grid = SpatialGridDimension(value=np.ma.array(np.random.rand(2, 3, 4)))
sdim = SpatialDimension(grid=grid)
field = Field(variables=var, spatial=sdim)
path = os.path.join(self.current_dir_output, 'foo.nc')
with self.nc_scope(path, 'w') as ds:
field.write_netcdf(ds)
with self.nc_scope(path, 'r') as out:
var_out = out.variables['tas'][:]
target = var_out.reshape(*var.shape)
self.assertNumpyAllClose(var.value.data, target)
def test_get_fiona_dict(self):
field = self.get_field(with_value=True, crs=WGS84())
_, arch = field.get_iter().next()
target = Field.get_fiona_dict(field, arch)
self.assertAsSetEqual(target.keys(), ['crs', 'fconvert', 'schema'])
def test_get_ocgis_field_from_esmpy_field(self):
# todo: return spherical crs if none is passed. check something on the grid
np.random.seed(1)
temporal = TemporalDimension(value=[3000.0, 4000.0, 5000.0])
level = VectorDimension(value=[10, 20, 30, 40])
realization = VectorDimension(value=[100, 200])
kwds = dict(
crs=[None, CoordinateReferenceSystem(epsg=4326), Spherical()],
with_mask=[False, True],
with_corners=[False, True],
dimensions=[False, True],
drealization=[False, True],
dtemporal=[False, True],
dlevel=[False, True],
)
for k in self.iter_product_keywords(kwds):
row = VectorDimension(value=[1.0, 2.0])
col = VectorDimension(value=[3.0, 4.0])
if k.with_corners:
row.set_extrapolated_bounds()
col.set_extrapolated_bounds()
value_tmin = np.random.rand(2, 3, 4, 2, 2)
tmin = Variable(value=value_tmin, name="tmin")
variables = VariableCollection([tmin])
grid = SpatialGridDimension(row=row, col=col)
sdim = SpatialDimension(grid=grid, crs=k.crs)
field = Field(variables=variables, spatial=sdim, temporal=temporal, level=level, realization=realization)
if k.with_mask:
mask = np.zeros(value_tmin.shape[-2:], dtype=bool)
mask[0, 1] = True
field._set_new_value_mask_(field, mask)
sdim.set_mask(mask)
self.assertTrue(tmin.value.mask.any())
self.assertTrue(sdim.get_mask().any())
else:
self.assertFalse(tmin.value.mask.any())
self.assertFalse(sdim.get_mask().any())
coll = SpatialCollection()
coll[1] = {field.name: field}
conv = ESMPyConverter([coll])
efield = conv.write()
if k.dimensions:
dimensions = {}
if k.drealization:
dimensions["realization"] = realization
if k.dtemporal:
dimensions["temporal"] = temporal
if k.dlevel:
dimensions["level"] = level
else:
dimensions = None
ofield = get_ocgis_field_from_esmpy_field(efield, crs=k.crs, dimensions=dimensions)
self.assertIsInstance(ofield, Field)
self.assertEqual(ofield.shape, efield.shape)
if k.drealization and k.dimensions:
target = realization.value
else:
target = np.array([1, 2])
self.assertNumpyAll(ofield.realization.value, target)
if k.dtemporal and k.dimensions:
target = temporal.value
else:
target = np.array([1, 1, 1])
with self.assertRaises(CannotFormatTimeError):
ofield.temporal.value_datetime
self.assertFalse(ofield.temporal.format_time)
self.assertNumpyAll(ofield.temporal.value, target)
if k.dlevel and k.dimensions:
target = level.value
else:
target = np.array([1, 2, 3, 4])
self.assertNumpyAll(ofield.level.value, target)
self.assertNumpyAll(field.spatial.grid.value, ofield.spatial.grid.value)
if k.with_corners:
self.assertIsNotNone(ofield.spatial.grid.corners)
self.assertNumpyAll(field.spatial.grid.corners, ofield.spatial.grid.corners)
self.assertEqual(ofield.spatial.crs, sdim.crs)
ofield_tmin_value = ofield.variables[efield.name].value
for arr1, arr2 in itertools.combinations([tmin.value, efield, ofield_tmin_value], r=2):
self.assertNumpyAll(arr1, arr2, check_arr_type=False)
rows = list(ofield.get_iter())
try:
self.assertEqual(len(rows), len(value_tmin.flatten()))
except AssertionError:
self.assertTrue(k.with_mask)
self.assertEqual(len(rows), len(tmin.value.compressed()))
self.assertTrue(np.may_share_memory(ofield_tmin_value, efield))
self.assertFalse(np.may_share_memory(ofield_tmin_value, tmin.value))
