def test_append_with_new_field(tmpdir, format):
grid = RasterModelGrid((3, 4))
grid.add_full("elevation", 1.0, at="node")
with tmpdir.as_cwd():
to_netcdf(grid, "test.nc", format=format)
grid.add_full("temperature", 2.0, at="node")
to_netcdf(grid, "test.nc", format=format, mode="a", time=10.0)
def test_append_with_new_field(tmpdir, format):
grid = RasterModelGrid((3, 4))
grid.add_full("elevation", 1.0, at="node")
with tmpdir.as_cwd():
to_netcdf(grid, "test.nc", format=format, time=0.0)
grid.add_full("temperature", 2.0, at="node")
to_netcdf(grid, "test.nc", format=format, mode="a", time=10.0)
with xr.open_dataset("test.nc") as ds:
assert sorted(ds.variables) == [
"at_node:elevation",
"at_node:temperature",
"shape",
"status_at_node",
"time",
"xy_of_lower_left",
"xy_spacing",
]
assert_array_equal(
ds["at_node:temperature"],
np.vstack([
np.full(grid.number_of_nodes, np.nan),
grid.at_node["temperature"]
]),
)
assert_array_equal(
ds["at_node:elevation"],
np.vstack(
[grid.at_node["elevation"], grid.at_node["elevation"]]),
)
assert_array_equal(ds["time"], [0.0, 10.0])
def test_raster_model_grid(tmpdir, format):
grid = RasterModelGrid((4, 3), xy_spacing=(2, 5), xy_of_lower_left=(-2.0, 10.0))
with tmpdir.as_cwd():
to_netcdf(grid, "test.nc", format=format)
actual = from_netcdf("test.nc")
assert (actual.dx, actual.dy) == (grid.dx, grid.dy)
assert actual.xy_of_lower_left == grid.xy_of_lower_left
def test_layers(tmpdir, format):
grid = RasterModelGrid((3, 4))
grid.event_layers.add(10.0, water_depth=[1.0, 2.0])
with tmpdir.as_cwd():
to_netcdf(grid, "test.nc", include="at_layer*", format=format)
actual = xr.open_dataset("test.nc")
actual_fields = set(
[name for name in actual.variables if name.startswith("at_")])
assert actual_fields == set(["at_layer:water_depth"])
def test_netcdf_write_uint8(tmpdir, format):
grid = RasterModelGrid((4, 3))
grid.add_field("topographic__elevation", np.arange(12, dtype=np.uint8), at="node")
with tmpdir.as_cwd():
to_netcdf(grid, "test.nc", format=format)
actual = xr.open_dataset("test.nc")["at_node:topographic__elevation"]
assert_array_equal(actual, grid.at_node["topographic__elevation"])
assert actual.dtype == np.uint8 if format == "NETCDF4" else np.int8
def test_netcdf_write_dtype(tmpdir, format, dtype):
"""Test write_netcdf with a grid that has an uint8 field."""
grid = RasterModelGrid((4, 3))
grid.add_field("topographic__elevation", np.arange(12, dtype=dtype), at="node")
with tmpdir.as_cwd():
to_netcdf(grid, "test.nc", format=format)
actual = xr.open_dataset("test.nc")["at_node:topographic__elevation"]
assert_array_equal(actual, grid.at_node["topographic__elevation"])
assert actual.dtype == dtype
def test_include_keyword_is_empty(tmpdir, format, include):
grid = RasterModelGrid((4, 3),
xy_spacing=(2, 5),
xy_of_lower_left=(-2.0, 10.0))
grid.add_ones("elev", at="node")
grid.add_zeros("elev", at="link")
grid.add_empty("temp", at="node")
with tmpdir.as_cwd():
to_netcdf(grid, "test.nc", format=format)
actual = from_netcdf("test.nc", include=include)
assert len(actual.at_node) == 0
assert len(actual.at_link) == 0
def test_netcdf_write_int64(tmpdir, format):
grid = RasterModelGrid((4, 3))
grid.add_field("topographic__elevation", np.arange(12, dtype=np.int64), at="node")
with tmpdir.as_cwd():
to_netcdf(grid, "test.nc", format=format)
actual = xr.open_dataset("test.nc")
values = actual["at_node:topographic__elevation"]
assert_array_equal(values, grid.at_node["topographic__elevation"])
if format == "NETCDF4":
assert values.dtype == "int64"
else:
assert values.dtype == "int32"
def test_with_and_without_time(tmpdir, format, mode):
grid = RasterModelGrid((3, 4))
grid.add_full("elevation", 1.0, at="node")
with tmpdir.as_cwd():
to_netcdf(grid, "test-without-time.nc", format=format, mode=mode)
with xr.open_dataset("test-without-time.nc") as actual:
assert "time" not in actual.dims
assert "time" not in actual.variables
assert actual["at_node:elevation"].dims == ("node",)
to_netcdf(grid, "test-with-time.nc", format=format, time=10.0, mode=mode)
with xr.open_dataset("test-with-time.nc") as actual:
assert "time" in actual.dims
assert "time" in actual.variables
assert actual["time"] == [10.0]
assert actual["at_node:elevation"].dims == ("time", "node")
def run_one_step(self):
""" Write output to file as a netCDF. """
filename_prefix = self.filename_prefix
filename = f"{filename_prefix}.nc"
filepath = os.path.join(self.output_dir, filename)
grid = self.model.grid
if isinstance(grid, RasterModelGrid):
write_raster_netcdf(filepath,
grid,
names=self.output_fields,
format="NETCDF4")
else:
to_netcdf(grid, filepath, format="NETCDF4")
self.register_output_filepath(filepath)
def test_hex_model_grid(tmpdir, format, orientation, node_layout):
grid = HexModelGrid(
shape=(4, 5),
spacing=2.0,
xy_of_lower_left=(-3, -5),
orientation=orientation,
node_layout=node_layout,
)
with tmpdir.as_cwd():
to_netcdf(grid, "test.nc", format=format)
actual = from_netcdf("test.nc")
assert actual.spacing == grid.spacing
assert actual.xy_of_lower_left == grid.xy_of_lower_left
assert actual.orientation == grid.orientation
assert actual.node_layout == grid.node_layout
def test_netcdf_write_uint8(tmpdir, format):
grid = RasterModelGrid((4, 3))
grid.add_field("topographic__elevation",
np.arange(12, dtype=np.uint8),
at="node")
with tmpdir.as_cwd():
if format != "NETCDF4":
with pytest.raises(RuntimeError):
to_netcdf(grid, "test.nc", format=format)
else:
to_netcdf(grid, "test.nc", format=format)
assert_array_equal(
xr.open_dataset("test.nc")["at_node:topographic__elevation"],
grid.at_node["topographic__elevation"],
)
def run_model(self):
"""
Run StreamPowerModel for full duration specified by total_morphological_time.
Record elevation change quantiles [0, 10, 50, 90, 100] and mean.
If output dictionary was provided, record output.
If output dictionary and steady state condition were provided, record output and stop when steady state condition is met.
"""
# Run model forward
for i in tqdm(range(self.N), desc="Completion"):
self.run_step(self.dt_m, dt_m_max=self.dt_m_max)
if self.save_output:
if i % self.output_interval == 0 or i == max(range(self.N)):
# save the specified grid fields
filename = self.base_path + "%d_grid_%d.nc" % (self.id, i)
to_netcdf(
self._grid,
filename,
include=self.output_fields,
format="NETCDF4",
)
if self.stop_cond and i % self.output_interval == 0 and i > 0:
# check stopping condition
filename0 = self.base_path + "%d_grid_%d.nc" % (
self.id,
i - self.output_interval,
)
grid0 = from_netcdf(filename0)
elev0 = grid0.at_node["topographic__elevation"]
dzdt = self.calc_rate_of_change(
self._elev, elev0, self.dt_m, self.output_interval
)
if dzdt < self.stop_rate:
self.verboseprint(
"Stopping rate condition met, dzdt = %.4e" % dzdt
)
break
def test_at_keyword(tmpdir, at):
grid = RasterModelGrid((4, 3))
name = "topographic__elevation"
for src_at in {"node", "link", "patch", "corner", "face", "cell"}:
grid.add_field(name, grid.ones(at=src_at) * 10.0, at=src_at)
include = "at_{0}:*".format(at)
with tmpdir.as_cwd():
to_netcdf(grid, "test.nc", format="NETCDF4", include=include)
with xr.open_dataset("test.nc") as actual:
actual_fields = set(
[name for name in actual.variables if name.startswith("at_")])
nc_name = "at_{0}:{1}".format(at, name)
assert actual_fields == set([nc_name])
assert_array_equal(actual[nc_name],
getattr(grid, "at_" + at)[name])
def test_append_with_and_without_time(tmpdir, format, mode, time0, time1):
grid = RasterModelGrid((3, 4))
grid.add_full("elevation", 1.0, at="node")
with tmpdir.as_cwd():
to_netcdf(grid, "test.nc", format=format, mode=mode, time=time0)
to_netcdf(grid, "test.nc", format=format, mode="a", time=time1)
time0 = np.nan if time0 is None else time0
with xr.open_dataset("test.nc") as actual:
assert "time" in actual.dims
assert "time" in actual.variables
assert_array_equal(
actual["time"],
[
np.nan if time0 is None else time0,
time0 + 1 if time1 is None else time1,
],
)
'at_node:hand_curvature',
'at_node:hand_sat_interstorm',
'at_node:saturation_class',
'at_node:saturation_probability',
'at_node:saturation_entropy',
'at_node:sat_unsat_union_probability',
'at_node:topographic__index_D8',
'at_node:topographic__index_D4',
'at_node:slope_D8',
'at_node:slope_D4',
'at_node:drainage_area',
'at_node:curvature',
'at_node:steepness',
'at_node:qstar_mean_no_interevent',
'at_node:wtrel_mean_end_storm',
'at_node:wtrel_mean_end_interstorm',
'at_node:sat_mean_end_storm',
'at_node:sat_mean_end_interstorm',
'at_node:Q_mean_end_storm',
'at_node:Q_mean_end_interstorm',
]
filename = '../post_proc/%s/grid_%d.nc' % (base_output_path, ID)
to_netcdf(mg, filename, include=output_fields, format="NETCDF4")
df_output.to_csv('../post_proc/%s/output_ID_%d.csv' % (base_output_path, ID))
df.to_csv('../post_proc/%s/q_s_dt_ID_%d.csv' % (base_output_path, ID))
df_z_change.to_csv('../post_proc/%s/z_change_%d.csv' % (base_output_path, ID))
r_change.to_csv('../post_proc/%s/relief_change_%d.csv' %
(base_output_path, ID))
surface="topographic__elevation",
fill_surface="topographic__elevation",
redirect_flow_steepest_descent=False,
reaccumulate_flow=False,
track_lakes=False,
ignore_overfill=True,
)
dfr = DepressionFinderAndRouter(grid)
ld = LinearDiffuser(grid, D)
sp = FastscapeEroder(grid, K_sp=Ksp, m_sp=0.5, n_sp=1.0, threshold_sp=E0)
for i in range(N):
dfr._find_pits()
if dfr._number_of_pits > 0:
lmb.run_one_step()
z[grid.core_nodes] += U * dt
ld.run_one_step(dt)
fa.run_one_step()
sp.run_one_step(dt)
print('completed loop %d' % i)
if i % output_interval == 0:
print('finished iteration %d' % i)
filename = base_path + '%d_grid_%d.nc' % (ID, i)
to_netcdf(grid, filename, include="at_node:topographic__elevation")
df_output['runtime'] = t2 - t1
# save output
output_fields = [
"at_node:topographic__elevation",
"at_node:aquifer_base__elevation",
"at_node:wtrel_mean_end_storm",
"at_node:wtrel_mean_end_interstorm",
"at_node:wtrel_99",
"at_node:wtrel_01",
"at_node:sat_mean_end_storm",
"at_node:sat_mean_end_interstorm",
"at_node:Q_mean_end_storm",
"at_node:Q_mean_end_interstorm",
"at_node:saturation_class",
"at_node:saturation_probability",
"at_node:saturation_entropy",
"at_node:sat_unsat_union_probability",
"at_node:qstar_mean_no_interevent",
]
#print("analysis finished")
pickle.dump(df_output, open('output_%d.p' % ID, 'wb'))
pickle.dump(grid, open('grid_%d.p' % ID, 'wb'))
#print("pickle output written")
to_netcdf(grid, 'grid_%d.nc' % ID, include=output_fields, format="NETCDF4")
#print("netcdf output written")
