def test_limiter(self, default_calving):
_, ds1, df_diag1 = default_calving
model = FluxBasedModel(bu_tidewater_bed(),
mb_model=ScalarMassBalance(),
is_tidewater=True,
calving_use_limiter=False,
flux_gate=0.06,
do_kcalving=True,
calving_k=0.2)
_, ds2 = model.run_until_and_store(3000)
df_diag2 = model.get_diagnostics()
assert_allclose(model.volume_m3 + model.calving_m3_since_y0,
model.flux_gate_m3_since_y0)
assert_allclose(ds2.calving_m3[-1], model.calving_m3_since_y0)
# Not exact same of course
assert_allclose(ds1.volume_m3[-1], ds2.volume_m3[-1], rtol=0.06)
assert_allclose(ds1.calving_m3[-1], ds2.calving_m3[-1], rtol=0.15)
if do_plot:
f, ax = plt.subplots(1, 1, figsize=(12, 5))
df_diag1[['surface_h']].plot(ax=ax, color=['C3'])
df_diag2[['surface_h', 'bed_h']].plot(ax=ax, color=['C1', 'k'])
plt.hlines(0, 0, 60000, color='C0', linestyles=':')
plt.ylim(-350, 800)
plt.ylabel('Altitude [m]')
plt.show()
def test_staggered_diagnostics(self):
mb = LinearMassBalance(2600.)
fls = dummy_constant_bed()
model = FluxBasedModel(fls, mb_model=mb, y0=0.)
model.run_until(700)
assert_allclose(mb.get_specific_mb(fls=fls), 0, atol=10)
# Check the flux just for fun
fl = model.flux_stag[0]
assert fl[0] == 0
# Now check the diags
df = model.get_diagnostics()
fl = model.fls[0]
df['my_flux'] = np.cumsum(mb.get_annual_mb(fl.surface_h) *
fl.widths_m * fl.dx_meter *
cfg.SEC_IN_YEAR).clip(0)
df = df.loc[df['ice_thick'] > 0]
# Also convert ours
df['ice_flux'] *= cfg.SEC_IN_YEAR
df['ice_velocity'] *= cfg.SEC_IN_YEAR
df['tributary_flux'] *= cfg.SEC_IN_YEAR
assert_allclose(np.abs(df['ice_flux'] - df['my_flux']), 0, atol=35e3)
assert df['ice_velocity'].max() > 25
assert df['tributary_flux'].max() == 0
fls = dummy_width_bed_tributary()
model = FluxBasedModel(fls, mb_model=mb, y0=0.)
model.run_until(500)
df = model.get_diagnostics()
df['ice_velocity'] *= cfg.SEC_IN_YEAR
df['tributary_flux'] *= cfg.SEC_IN_YEAR
df = df.loc[df['ice_thick'] > 0]
assert df['ice_velocity'].max() > 50
assert df['tributary_flux'].max() > 30e4
df = model.get_diagnostics(fl_id=0)
df = df.loc[df['ice_thick'] > 0]
df['ice_velocity'] *= cfg.SEC_IN_YEAR
df['tributary_flux'] *= cfg.SEC_IN_YEAR
assert df['ice_velocity'].max() > 10
assert df['tributary_flux'].max() == 0
def test_run_until_and_store(self):
fls = dummy_constant_bed()
mb = LinearMassBalance(2600.)
model = FluxBasedModel(fls, mb_model=mb)
ds_f, ds_d = model.run_until_and_store(150)
assert ds_d['length_m'][-1] > 1e3
df = model.get_diagnostics()
assert (df['ice_velocity'].max() * cfg.SEC_IN_YEAR) > 10
def default_calving():
cfg.initialize()
model = FluxBasedModel(bu_tidewater_bed(),
mb_model=ScalarMassBalance(),
is_tidewater=True, calving_use_limiter=True,
flux_gate=0.06, do_kcalving=True,
calving_k=0.2)
_, ds = model.run_until_and_store(3000)
df_diag = model.get_diagnostics()
assert_allclose(model.volume_m3 + model.calving_m3_since_y0,
model.flux_gate_m3_since_y0)
assert_allclose(ds.calving_m3[-1], model.calving_m3_since_y0)
return model, ds, df_diag
def test_water_level(self, default_calving):
_, ds_1, _ = default_calving
model = FluxBasedModel(bu_tidewater_bed(water_level=1000),
mb_model=ScalarMassBalance(),
is_tidewater=True,
calving_use_limiter=True,
flux_gate=0.06,
do_kcalving=True,
calving_water_level=1000,
calving_k=0.2)
_, ds_2 = model.run_until_and_store(3000)
assert_allclose(model.volume_m3 + model.calving_m3_since_y0,
model.flux_gate_m3_since_y0)
assert_allclose(ds_1.calving_m3, ds_2.calving_m3)
if do_plot:
df_diag = model.get_diagnostics()
f, ax = plt.subplots(1, 1, figsize=(12, 5))
df_diag[['surface_h', 'bed_h']].plot(ax=ax, color=['C3', 'k'])
plt.hlines(1000, 0, 60000, color='C0', linestyles=':')
plt.ylim(1000 - 350, 1000 + 800)
plt.ylabel('Altitude [m]')
plt.show()
# Let the model decide the water level
fls = bu_tidewater_bed(water_level=1000)
thick = fls[0].thick
thick[fls[0].bed_h > 1000] = 1
fls[0].thick = thick
model = FluxBasedModel(fls,
mb_model=ScalarMassBalance(),
is_tidewater=True,
calving_use_limiter=True,
is_lake_terminating=True,
flux_gate=0.06,
do_kcalving=True,
calving_k=0.2)
assert_allclose(model.water_level, 1000, atol=1)
with pytest.raises(InvalidParamsError):
fls = bu_tidewater_bed(water_level=1000)
FluxBasedModel(fls,
mb_model=ScalarMassBalance(),
is_tidewater=True,
calving_use_limiter=True,
is_lake_terminating=True)