def test_write_with_depths():
'''
tests writing a netcdf file with depth data
'''
fname = 'temp.nc'
grid = two_triangles()
grid.mesh_name='mesh1'
# create a dataset object for the depths:
depths = DataSet('depth', location='node', data=[1.0, 2.0, 3.0, 4.0])
depths.attributes['units'] = 'm'
depths.attributes["standard_name"] = "sea_floor_depth_below_geoid"
depths.attributes["positive"] = "down"
grid.add_data(depths)
grid.save_as_netcdf(fname)
with netCDF4.Dataset(fname) as ds:
assert nc_has_variable(ds, 'mesh1')
assert nc_has_variable(ds, 'depth')
assert nc_var_has_attr_vals(ds, 'depth', {"coordinates" : "mesh1_node_lon mesh1_node_lat",
"location" : "node",
"mesh": "mesh1"})
def test_write_with_edge_data():
'''
tests writing a netcdf file with data on the edges (fluxes, maybe?)
'''
fname = 'temp.nc'
grid = two_triangles()
grid.mesh_name = 'mesh2'
# create a dataset object for fluxes:
flux = DataSet('flux', location='edge', data=[0.0, 0.0, 4.1, 0.0, 5.1, ])
flux.attributes['units'] = 'm^3/s'
flux.attributes["long_name"] = "volume flux between cells"
flux.attributes["standard_name"] = "ocean_volume_transport_across_line"
grid.add_data(flux)
#add coordinates for edges
grid.build_edge_coordinates()
grid.save_as_netcdf(fname)
with netCDF4.Dataset(fname) as ds:
assert nc_has_variable(ds, 'mesh2')
assert nc_has_variable(ds, 'flux')
assert nc_var_has_attr_vals(ds, 'flux', {
"coordinates" : "mesh2_edge_lon mesh2_edge_lat",
"location" : "edge",
'units' : 'm^3/s',
"mesh": "mesh2",
})
assert np.array_equal( ds.variables['mesh2_edge_lon'], grid.edge_coordinates[:,0] )
assert np.array_equal( ds.variables['mesh2_edge_lat'], grid.edge_coordinates[:,1] )
def test_add_boundary_data():
grid = two_triangles()
print grid.boundaries
# add the boundary definitions:
grid.boundaries = [(0,1),
(0,2),
(1,3),
(2,3),
]
# create a dataset object for boundary conditions:
bnds = DataSet('bounds', location='boundary', data=[0, 1, 0, 0, 1])
bnds.attributes["long_name"] = "model boundary conditions"
# wrong size for data
with pytest.raises(ValueError):
grid.add_data(bnds)
# correct data
bnds.data = [0, 1, 0, 0]
grid.add_data(bnds)
assert grid.data['bounds'].name == 'bounds'
assert np.array_equal( grid.data['bounds'].data, [0, 1, 0, 0] )
def two_triangles_with_depths():
grid = two_triangles()
depths = DataSet('depth', location='node', data=[1.0, 2.0, 3.0, 4.0])
depths.attributes['units'] = 'unknown'
depths.attributes['standard_name'] = "sea_floor_depth_below_geoid"
depths.attributes['positive'] = "down"
grid.add_data(depths)
return grid
def two_triangles_with_depths():
grid = two_triangles()
depths = DataSet('depth', location='node', data=[1.0, 2.0, 3.0, 4.0])
depths.attributes['units'] = 'unknown'
depths.attributes['standard_name'] = "sea_floor_depth_below_geoid"
depths.attributes['positive'] = "down"
grid.add_data(depths)
return grid
def add_attributes():
d = DataSet('depth', location='node', data=[1.0, 2.0, 3.0, 4.0])
d.attributes = {"standard_name" : "sea_floor_depth_below_geoid",
"units" : "m",
"positive" : "down",
}
assert d.attributes['units'] == 'm'
assert d.attributes['posative'] == 'down'
def add_attributes():
d = DataSet('depth', location='node', data=[1.0, 2.0, 3.0, 4.0])
d.attributes = {
"standard_name": "sea_floor_depth_below_geoid",
"units": "m",
"positive": "down",
}
assert d.attributes['units'] == 'm'
assert d.attributes['posative'] == 'down'
def test_init():
# create a dataset object for the depths:
d = DataSet('depth', location='node', data=[1.0, 2.0, 3.0, 4.0])
assert d.name == 'depth'
assert np.array_equal(d.data, [1.0, 2.0, 3.0, 4.0])
assert d.location == 'node'
assert d.attributes == {}
with pytest.raises(ValueError):
d = DataSet('depth', location='nodes')
def test_add_edge_data():
grid = two_triangles()
# create a dataset object for velocity:
bnds = DataSet('bounds', location='edge', data=[0, 1, 0, 0, 1])
bnds.attributes["standard_name"] = "boundary type"
grid.add_data(bnds)
assert grid.data['bounds'].name == 'bounds'
assert np.array_equal( grid.data['bounds'].data, [0, 1, 0, 0, 1] )
def twenty_one_triangles_with_depths():
"""
returns a basic triangle grid with 21 triangles, a hole and a "tail"
"""
grid = twenty_one_triangles()
depths = DataSet('depth', location='node', data=range(1, 21))
depths.attributes['units'] = 'unknown'
depths.attributes['standard_name'] = "sea_floor_depth_below_geoid"
depths.attributes['positive'] = "down"
grid.add_data(depths)
return grid
def twenty_one_triangles_with_depths():
"""
returns a basic triangle grid with 21 triangles, a hole and a "tail"
"""
grid = twenty_one_triangles()
depths = DataSet('depth', location='node', data=range(1, 21))
depths.attributes['units'] = 'unknown'
depths.attributes['standard_name'] = "sea_floor_depth_below_geoid"
depths.attributes['positive'] = "down"
grid.add_data(depths)
return grid
def test_no_std_name():
"""
tests to make sure it doesn' crash if a DataSet does not have a standard_name
"""
grid = two_triangles_with_depths()
junk = DataSet('junk', location='node', data=[1.0, 2.0, 3.0, 4.0])
junk.attributes['units'] = 'unknown'
grid.add_data(junk)
depths = find_depths(grid)
assert depths.name == 'depth'
def test_no_std_name():
"""
tests to make sure it doesn' crash if a DataSet does not have a standard_name
"""
grid = two_triangles_with_depths()
junk = DataSet('junk', location='node', data=[1.0, 2.0, 3.0, 4.0])
junk.attributes['units'] = 'unknown'
grid.add_data(junk)
depths = find_depths(grid)
assert depths.name == 'depth'
def test_add_face_data():
grid = two_triangles()
# create a dataset object for velocity:
u_vel = DataSet('u', location='face', data=[1.0, 2.0])
u_vel.attributes['units'] = 'm/s'
u_vel.attributes["standard_name"] = "eastward_sea_water_velocity"
grid.add_data(u_vel)
assert grid.data['u'].name == 'u'
assert grid.data['u'].attributes['units'] == 'm/s'
assert np.array_equal( grid.data['u'].data, [1.0, 2.0] )
def test_add_data():
d = DataSet('depth', location='node')
assert d.name == 'depth'
assert np.array_equal(d.data, [])
#add the data:
d.data = [1.0, 2.0, 3.0, 4.0]
assert np.array_equal(d.data, [1.0, 2.0, 3.0, 4.0])
# duck type check of ndarray
d.data *= 2
assert np.array_equal(d.data, [2.0, 4.0, 6.0, 8.0])
def test_add_data():
d = DataSet('depth', location='node')
assert d.name == 'depth'
assert np.array_equal(d.data, [] )
#add the data:
d.data = [1.0, 2.0, 3.0, 4.0]
assert np.array_equal(d.data, [1.0, 2.0, 3.0, 4.0] )
# duck type check of ndarray
d.data *= 2
assert np.array_equal(d.data, [2.0, 4.0, 6.0, 8.0] )
def test_add_node_data():
grid = two_triangles()
# create a dataset object for the depths:
depths = DataSet('depth', location='node', data=[1.0, 2.0, 3.0, 4.0])
depths.attributes['units'] = 'm'
depths.attributes["standard_name"] = "sea_floor_depth"
depths.attributes["positive"] = "down"
grid.add_data(depths)
assert grid.data['depth'].name == 'depth'
assert grid.data['depth'].attributes['units'] == 'm'
assert np.array_equal( grid.data['depth'].data, [1.0, 2.0, 3.0, 4.0] )
def test_delete_data():
# create a dataset object for the depths:
d = DataSet('depth', location='node', data=[1.0, 2.0, 3.0, 4.0])
del d.data
assert np.array_equal(d.data, [])
def test_with_just_nodes_and_depths():
filename = '2_triangles_depth.nc'
grid = two_triangles()
del grid.faces
del grid.edges
depth_array = [1.0, 2.0, 3.0, 4.0]
depth = DataSet('depth',
'node',
[1.0, 2.0, 3.0, 4.0],
{'units':'m',
'positive':'down',
'standard_name' : "sea_floor_depth_below_geoid",
})
grid.add_data(depth)
with chdir('files'):
grid.save_as_netcdf(filename)
# read it back in and check it out
grid2 = UGrid.from_ncfile(filename, load_data=True)
assert grid2.faces is None
assert grid2.edges is None
assert np.array_equal( grid2.nodes, grid.nodes )
assert np.array_equal( grid2.data['depth'].data, depth_array )
assert grid2.data['depth'].attributes == depth.attributes
def test_write_with_bound_data():
'''
tests writing a netcdf file with data on the boundaries
suitable for boundary conditions, for example -- (fluxes, maybe?)
'''
fname = 'temp.nc'
grid = two_triangles() # using default mesh name
# add the boundary definitions:
grid.boundaries = [(0,1),
(0,2),
(1,3),
(2,3),
]
# create a dataset object for boundary conditions:
bnds = DataSet('bnd_cond', location='boundary', data=[0, 1, 0, 0])
bnds.attributes["long_name"] = "model boundary conditions"
bnds.attributes["flag_values"] = "0 1"
bnds.attributes["flag_meanings"] = "no_flow_boundary open_boundary"
grid.add_data(bnds)
grid.save_as_netcdf(fname)
with netCDF4.Dataset(fname) as ds:
assert nc_has_variable(ds, 'mesh')
assert nc_has_variable(ds, 'bnd_cond')
assert nc_var_has_attr_vals(ds, 'mesh', {
"boundary_node_connectivity" : "mesh_boundary_nodes",
})
assert nc_var_has_attr_vals(ds, 'bnd_cond', {
"location" : "boundary",
"flag_values" : "0 1",
"flag_meanings" : "no_flow_boundary open_boundary",
"mesh": "mesh",
})
## there should be no coordinates attribute or variable for the boundaries
## as there is no boundaries_coordinates defined
assert not nc_has_variable(ds, 'mesh_boundary_lon')
assert not nc_has_variable(ds, 'mesh_boundary_lat')
assert not nc_var_has_attr(ds, 'bnd_cond', 'coordinates')
def test_add_all_data():
'''
you should not be able add a data dict directly
'''
grid = two_triangles()
assert grid.data == {}
with pytest.raises(AttributeError):
grid.data = {'depth': DataSet('depth', location='node', data=[1.0, 2.0, 3.0, 4.0])}
def test_add_face_data_wrong():
"""too short an array"""
grid = two_triangles()
# create a dataset object for velocity:
u_vel = DataSet('u', location='face', data=[1.0])
with pytest.raises(ValueError):
grid.add_data(u_vel)
def test_add_node_data_wrong():
"""too short an array"""
grid = two_triangles()
# create a dataset object for the depths:
depths = DataSet('depth', location='node', data=[1.0, 2.0, 3.0])
with pytest.raises(ValueError):
grid.add_data(depths)
def test_add_edge_data_wrong():
"""too long an array"""
grid = two_triangles()
# create a dataset object for velocity:
# a miss-matched set
bnds = DataSet('bounds', location='edge', data=[0, 1, 0, 0, 1, 3, 3])
with pytest.raises(ValueError):
grid.add_data(bnds)
def test_write_with_velocities():
'''
tests writing a netcdf file with velocities on the faces
'''
fname = 'temp.nc'
grid = two_triangles()
grid.mesh_name = 'mesh2'
# create a dataset object for u velocity:
u_vel = DataSet('u', location='face', data=[1.0, 2.0])
u_vel.attributes['units'] = 'm/s'
u_vel.attributes["standard_name"] = "eastward_sea_water_velocity"
grid.add_data(u_vel)
# create a dataset object for v velocity:
v_vel = DataSet('v', location='face', data=[3.2, 4.3])
v_vel.attributes['units'] = 'm/s'
v_vel.attributes["standard_name"] = "northward_sea_water_velocity"
grid.add_data(v_vel)
# add coordinates for face data
grid.build_face_coordinates()
grid.save_as_netcdf(fname)
with netCDF4.Dataset(fname) as ds:
assert nc_has_variable(ds, 'mesh2')
assert nc_has_variable(ds, 'u')
assert nc_has_variable(ds, 'v')
assert nc_var_has_attr_vals(ds, 'u', {
"coordinates" : "mesh2_face_lon mesh2_face_lat",
"location" : "face",
"mesh": "mesh2",
})
def test_write_everything():
""" An example with all features enabled, and a less trivial grid """
# use a small, but interesting grid
fname = 'full_example.nc'
grid = twenty_one_triangles() # using default mesh name
grid.build_face_face_connectivity()
grid.build_edges()
grid.build_edge_coordinates()
grid.build_face_coordinates()
grid.build_boundary_coordinates()
# depth on the nodes
depths = DataSet('depth', location='node', data=np.linspace(1,10,20))
depths.attributes['units'] = 'm'
depths.attributes["standard_name"] = "sea_floor_depth_below_geoid"
depths.attributes["positive"] = "down"
grid.add_data(depths)
# velocities on the faces:
u_vel = DataSet('u', location='face', data=np.sin(np.linspace(3,12,21)))
u_vel.attributes['units'] = 'm/s'
u_vel.attributes["standard_name"] = "eastward_sea_water_velocity"
grid.add_data(u_vel)
# create a dataset object for v velocity:
v_vel = DataSet('v', location='face', data=np.sin(np.linspace(12,15,21)))
v_vel.attributes['units'] = 'm/s'
v_vel.attributes["standard_name"] = "northward_sea_water_velocity"
grid.add_data(v_vel)
# fluxes on the edges:
flux = DataSet('flux', location='edge', data=np.linspace(1000,2000,41))
flux.attributes['units'] = 'm^3/s'
flux.attributes["long_name"] = "volume flux between cells"
flux.attributes["standard_name"] = "ocean_volume_transport_across_line"
grid.add_data(flux)
# Some boundary conditions:
bounds = np.zeros( (19,), dtype=np.uint8 )
bounds[7] = 1
bnds = DataSet('bnd_cond', location='boundary', data=bounds)
bnds.attributes["long_name"] = "model boundary conditions"
bnds.attributes["flag_values"] = "0 1"
bnds.attributes["flag_meanings"] = "no_flow_boundary open_boundary"
grid.add_data(bnds)
grid.save_as_netcdf(fname)
## now the tests:
with netCDF4.Dataset(fname) as ds:
assert nc_has_variable(ds, 'mesh')
assert nc_has_variable(ds, 'depth')
assert nc_var_has_attr_vals(ds, 'depth', {"coordinates" : "mesh_node_lon mesh_node_lat",
"location" : "node"})
assert nc_has_variable(ds, 'u')
assert nc_has_variable(ds, 'v')
assert nc_var_has_attr_vals(ds, 'u', {
"coordinates" : "mesh_face_lon mesh_face_lat",
"location" : "face",
"mesh": "mesh"
})
assert nc_var_has_attr_vals(ds, 'v', {
"coordinates" : "mesh_face_lon mesh_face_lat",
"location" : "face",
"mesh": "mesh",
})
assert nc_has_variable(ds, 'flux')
assert nc_var_has_attr_vals(ds, 'flux', {
"coordinates" : "mesh_edge_lon mesh_edge_lat",
"location" : "edge",
'units' : 'm^3/s',
"mesh": "mesh",
})
assert nc_has_variable(ds, 'mesh')
assert nc_has_variable(ds, 'bnd_cond')
assert nc_var_has_attr_vals(ds, 'mesh', {
"boundary_node_connectivity" : "mesh_boundary_nodes",
})
assert nc_var_has_attr_vals(ds, 'bnd_cond', {
"location" : "boundary",
"flag_values" : "0 1",
"flag_meanings" : "no_flow_boundary open_boundary",
"mesh": "mesh",
})
# and make sure pyugrid can reload it!
grid = UGrid.from_ncfile(fname,load_data=True)
# and that some things are the same:
# note: more testing might be good here...
# maybe some grid comparison functions?
assert grid.mesh_name == 'mesh'
print "grid data:", grid.data
assert len(grid.nodes) == 20
depth = grid.data['depth']
assert depth.attributes['units'] == 'm'
u = grid.data['u']
assert u.attributes['units'] == 'm/s'
def test_str():
d = DataSet('depth', location='node', data=[1.0, 2.0, 3.0, 4.0])
print(str(d))
assert str(
d
) == "DataSet object: depth, on the nodes, and 4 data points\nAttributes: {}"
def test_write_everything():
""" An example with all features enabled, and a less trivial grid """
# use a small, but interesting grid
fname = 'full_example.nc'
grid = twenty_one_triangles() # using default mesh name
grid.build_face_face_connectivity()
grid.build_edges()
grid.build_edge_coordinates()
grid.build_face_coordinates()
grid.build_boundary_coordinates()
# depth on the nodes
depths = DataSet('depth', location='node', data=np.linspace(1,10,20))
depths.attributes['units'] = 'm'
depths.attributes["standard_name"] = "sea_floor_depth_below_geoid"
depths.attributes["positive"] = "down"
grid.add_data(depths)
# velocities on the faces:
u_vel = DataSet('u', location='face', data=np.sin(np.linspace(3,12,21)))
u_vel.attributes['units'] = 'm/s'
u_vel.attributes["standard_name"] = "eastward_sea_water_velocity"
grid.add_data(u_vel)
# create a dataset object for v velocity:
v_vel = DataSet('v', location='face', data=np.sin(np.linspace(12,15,21)))
v_vel.attributes['units'] = 'm/s'
v_vel.attributes["standard_name"] = "northward_sea_water_velocity"
grid.add_data(v_vel)
# fluxes on the edges:
flux = DataSet('flux', location='edge', data=np.linspace(1000,2000,41))
flux.attributes['units'] = 'm^3/s'
flux.attributes["long_name"] = "volume flux between cells"
grid.add_data(flux)
# Some boundary conditions:
print grid.boundaries.shape
print grid.boundaries
bounds = np.zeros( (19,), dtype=np.uint8 )
bounds[7] = 1
bnds = DataSet('bnd_cond', location='boundary', data=bounds)
bnds.attributes["long_name"] = "model boundary conditions"
bnds.attributes["flag_values"] = "0 1"
bnds.attributes["flag_meanings"] = "no_flow_boundary open_boundary"
grid.add_data(bnds)
grid.save_as_netcdf(fname)
## now the tests:
with netCDF4.Dataset(fname) as ds:
assert nc_has_variable(ds, 'mesh')
assert nc_has_variable(ds, 'depth')
assert nc_var_has_attr_vals(ds, 'depth', {"coordinates" : "mesh_node_lon mesh_node_lat",
"location" : "node"})
assert nc_has_variable(ds, 'u')
assert nc_has_variable(ds, 'v')
assert nc_var_has_attr_vals(ds, 'u', {
"coordinates" : "mesh_face_lon mesh_face_lat",
"location" : "face",
"mesh": "mesh"
})
assert nc_var_has_attr_vals(ds, 'v', {
"coordinates" : "mesh_face_lon mesh_face_lat",
"location" : "face",
"mesh": "mesh",
})
assert nc_has_variable(ds, 'flux')
assert nc_var_has_attr_vals(ds, 'flux', {
"coordinates" : "mesh_edge_lon mesh_edge_lat",
"location" : "edge",
'units' : 'm^3/s',
"mesh": "mesh",
})
assert nc_has_variable(ds, 'mesh')
assert nc_has_variable(ds, 'bnd_cond')
assert nc_var_has_attr_vals(ds, 'mesh', {
"boundary_node_connectivity" : "mesh_boundary_nodes",
})
assert nc_var_has_attr_vals(ds, 'bnd_cond', {
"location" : "boundary",
"flag_values" : "0 1",
"flag_meanings" : "no_flow_boundary open_boundary",
"mesh": "mesh",
})
