def test_invert_and_run(self):
from oggm.core.models import flowline, massbalance
glen_a = cfg.A * 2
gdir = utils.GlacierDirectory(self.rgin, base_dir=self.testdir)
gis.glacier_masks(gdir)
centerlines.compute_centerlines(gdir)
centerlines.compute_downstream_lines(gdir)
geometry.initialize_flowlines(gdir)
geometry.catchment_area(gdir)
geometry.catchment_width_geom(gdir)
geometry.catchment_width_correction(gdir)
climate.local_mustar_apparent_mb(gdir, tstar=1975, bias=0.)
inversion.prepare_for_inversion(gdir)
v, a = inversion.invert_parabolic_bed(gdir, glen_a=glen_a)
cfg.PARAMS['bed_shape'] = 'parabolic'
flowline.init_present_time_glacier(gdir)
mb_mod = massbalance.TstarMassBalanceModel(gdir)
fls = gdir.read_pickle('model_flowlines')
model = flowline.FluxBasedModel(fls,
mb_model=mb_mod,
y0=0.,
fs=0,
glen_a=glen_a)
ref_vol = model.volume_m3
model.run_until_equilibrium()
after_vol = model.volume_m3
np.testing.assert_allclose(ref_vol, after_vol, rtol=0.1)
def test_equilibrium(self):
#TODO: equilibrium test only working with parabolic bed
_tmp = cfg.PARAMS['bed_shape']
cfg.PARAMS['bed_shape'] = 'parabolic'
flowline.init_present_time_glacier(self.gdir)
cfg.PARAMS['bed_shape'] = _tmp
mb_mod = massbalance.TstarMassBalanceModel(self.gdir)
fls = self.gdir.read_pickle('model_flowlines')
model = flowline.FluxBasedModel(fls,
mb_model=mb_mod,
y0=0.,
fs=self.fs,
glen_a=self.glen_a)
ref_vol = model.volume_km3
ref_area = model.area_km2
ref_len = model.fls[-1].length_m
np.testing.assert_allclose(ref_area, self.gdir.rgi_area_km2, rtol=0.03)
model.run_until(50.)
self.assertFalse(model.dt_warning)
after_vol = model.volume_km3
after_area = model.area_km2
after_len = model.fls[-1].length_m
np.testing.assert_allclose(ref_vol, after_vol, rtol=0.03)
np.testing.assert_allclose(ref_area, after_area, rtol=0.03)
np.testing.assert_allclose(ref_len, after_len, atol=200.01)
def test_init_present_time_glacier(self):
gdirs = up_to_inversion()
# Inversion Results
cfg.PARAMS['invert_with_sliding'] = True
cfg.PARAMS['optimize_thick'] = True
workflow.inversion_tasks(gdirs)
fpath = os.path.join(cfg.PATHS['working_dir'],
'inversion_optim_results.csv')
df = pd.read_csv(fpath, index_col=0)
r1 = rmsd(df['ref_volume_km3'], df['oggm_volume_km3'])
r2 = rmsd(df['ref_volume_km3'], df['vas_volume_km3'])
self.assertTrue(r1 < r2)
cfg.PARAMS['invert_with_sliding'] = False
cfg.PARAMS['optimize_thick'] = False
workflow.inversion_tasks(gdirs)
fpath = os.path.join(cfg.PATHS['working_dir'],
'inversion_optim_results.csv')
df = pd.read_csv(fpath, index_col=0)
r1 = rmsd(df['ref_volume_km3'], df['oggm_volume_km3'])
r2 = rmsd(df['ref_volume_km3'], df['vas_volume_km3'])
self.assertTrue(r1 < r2)
# Init glacier
d = gdirs[0].read_pickle('inversion_params')
fs = d['fs']
glen_a = d['glen_a']
maxs = cfg.PARAMS['max_shape_param']
for gdir in gdirs:
flowline.init_present_time_glacier(gdir)
mb_mod = massbalance.ConstantMassBalanceModel(gdir)
fls = gdir.read_pickle('model_flowlines')
model = flowline.FluxBasedModel(fls, mb_model=mb_mod, y0=0.,
fs=fs, glen_a=glen_a)
_vol = model.volume_km3
_area = model.area_km2
if gdir.rgi_id in df.index:
gldf = df.loc[gdir.rgi_id]
# TODO: broken but should work
# assert_allclose(gldf['oggm_volume_km3'], _vol, rtol=0.03)
# assert_allclose(gldf['ref_area_km2'], _area, rtol=0.03)
maxo = max([fl.order for fl in model.fls])
for fl in model.fls:
self.assertTrue(np.all(fl.bed_shape > 0))
self.assertTrue(np.all(fl.bed_shape <= maxs))
if len(model.fls) > 1:
if fl.order == (maxo-1):
self.assertTrue(fl.flows_to is fls[-1])
# Test the glacier charac
dfc = utils.glacier_characteristics(gdirs)
self.assertTrue(np.all(dfc.terminus_type == 'Land-terminating'))
cc = dfc[['dem_mean_elev', 'clim_temp_avgh']].corr().values[0, 1]
self.assertTrue(cc > 0.4)
def test_ideal_glacier(self):
# we are making a
glen_a = cfg.A * 1
from oggm.core.models import flowline, massbalance
gdir = utils.GlacierDirectory(self.rgin, base_dir=self.testdir)
fls = self._parabolic_bed()
mbmod = massbalance.ConstantBalanceModel(2800.)
model = flowline.FluxBasedModel(fls, mb_model=mbmod, glen_a=glen_a)
model.run_until_equilibrium()
# from dummy bed
map_dx = 100.
towrite = []
for fl in model.fls:
# Distance between two points
dx = fl.dx * map_dx
# Widths
widths = fl.widths * map_dx
# Heights
hgt = fl.surface_h
# Flux
mb = mbmod.get_mb(hgt) * cfg.SEC_IN_YEAR * cfg.RHO
fl.flux = np.zeros(len(fl.surface_h))
fl.set_apparent_mb(mb)
flux = fl.flux * (map_dx**2) / cfg.SEC_IN_YEAR / cfg.RHO
pok = np.nonzero(widths > 10.)
widths = widths[pok]
hgt = hgt[pok]
flux = flux[pok]
angle = np.arctan(-np.gradient(hgt, dx)) # beware the minus sign
# Clip flux to 0
assert not np.any(flux < -0.1)
# add to output
cl_dic = dict(dx=dx,
flux=flux,
width=widths,
hgt=hgt,
slope_angle=angle,
is_last=True)
towrite.append(cl_dic)
# Write out
gdir.write_pickle(towrite, 'inversion_input', div_id=1)
v, a = inversion.invert_parabolic_bed(gdir, glen_a=glen_a)
v_km3 = v * 1e-9
a_km2 = np.sum(widths * dx) * 1e-6
v_vas = 0.034 * (a_km2**1.375)
np.testing.assert_allclose(v, model.volume_m3, rtol=0.01)
cl = gdir.read_pickle('inversion_output', div_id=1)[0]
assert utils.rmsd(cl['thick'],
model.fls[0].thick[:len(cl['thick'])]) < 10.
def test_init_present_time_glacier(self):
gdirs = up_to_inversion()
# Inversion Results
cfg.PARAMS['invert_with_sliding'] = True
cfg.PARAMS['optimize_thick'] = True
workflow.inversion_tasks(gdirs)
fpath = os.path.join(cfg.PATHS['working_dir'],
'inversion_optim_results.csv')
df = pd.read_csv(fpath, index_col=0)
r1 = rmsd(df['ref_volume_km3'], df['oggm_volume_km3'])
r2 = rmsd(df['ref_volume_km3'], df['vas_volume_km3'])
self.assertTrue(r1 < r2)
cfg.PARAMS['invert_with_sliding'] = False
cfg.PARAMS['optimize_thick'] = False
workflow.inversion_tasks(gdirs)
fpath = os.path.join(cfg.PATHS['working_dir'],
'inversion_optim_results.csv')
df = pd.read_csv(fpath, index_col=0)
r1 = rmsd(df['ref_volume_km3'], df['oggm_volume_km3'])
r2 = rmsd(df['ref_volume_km3'], df['vas_volume_km3'])
self.assertTrue(r1 < r2)
# Init glacier
d = gdirs[0].read_pickle('inversion_params')
fs = d['fs']
glen_a = d['glen_a']
maxs = cfg.PARAMS['max_shape_param']
for gdir in gdirs:
flowline.init_present_time_glacier(gdir)
mb_mod = massbalance.ConstantMassBalanceModel(gdir)
fls = gdir.read_pickle('model_flowlines')
model = flowline.FluxBasedModel(fls,
mb_model=mb_mod,
y0=0.,
fs=fs,
glen_a=glen_a)
_vol = model.volume_km3
_area = model.area_km2
gldf = df.loc[gdir.rgi_id]
assert_allclose(gldf['oggm_volume_km3'], _vol, rtol=0.03)
assert_allclose(gldf['ref_area_km2'], _area, rtol=0.03)
maxo = max([fl.order for fl in model.fls])
for fl in model.fls:
self.assertTrue(np.all(fl.bed_shape > 0))
self.assertTrue(np.all(fl.bed_shape <= maxs))
if len(model.fls) > 1:
if fl.order == (maxo - 1):
self.assertTrue(fl.flows_to is fls[-1])
def test_coxe():
testdir = os.path.join(cfg.PATHS['test_dir'], 'tmp_coxe')
utils.mkdir(testdir)
# Init
cfg.initialize()
cfg.PATHS['dem_file'] = get_demo_file('dem_RGI50-01.10299.tif')
cfg.PARAMS['border'] = 40
cfg.PARAMS['use_multiple_flowlines'] = False
hef_file = get_demo_file('rgi_RGI50-01.10299.shp')
entity = gpd.GeoDataFrame.from_file(hef_file).iloc[0]
gdir = oggm.GlacierDirectory(entity, base_dir=testdir, reset=True)
gis.define_glacier_region(gdir, entity=entity)
gis.glacier_masks(gdir)
centerlines.compute_centerlines(gdir)
centerlines.compute_downstream_lines(gdir)
geometry.initialize_flowlines(gdir)
# Just check if the rest runs
centerlines.compute_downstream_bedshape(gdir)
geometry.catchment_area(gdir)
geometry.catchment_intersections(gdir)
geometry.catchment_width_geom(gdir)
geometry.catchment_width_correction(gdir)
climate.apparent_mb_from_linear_mb(gdir)
inversion.prepare_for_inversion(gdir)
inversion.volume_inversion(gdir, use_cfg_params={'glen_a': cfg.A, 'fs': 0})
inversion.filter_inversion_output(gdir)
flowline.init_present_time_glacier(gdir)
fls = gdir.read_pickle('model_flowlines')
p = gdir.read_pickle('linear_mb_params')
mb_mod = massbalance.LinearMassBalanceModel(ela_h=p['ela_h'],
grad=p['grad'])
mb_mod.temp_bias = -0.3
model = flowline.FluxBasedModel(fls,
mb_model=mb_mod,
y0=0,
is_tidewater=True)
# run
model.run_until(200)
assert model.calving_m3_since_y0 > 0
fig, ax = plt.subplots()
graphics.plot_modeloutput_map(gdir, ax=ax, model=model)
fig.tight_layout()
return fig
def setUp(self):
self.fs = 5.7e-20
# Backwards
_fd = 1.9e-24
self.glen_a = (N + 2) * _fd / 2.
self.ela = 2800.
origfls = dummy_constant_bed(nx=120, hmin=1800)
mb = ConstantBalanceModel(self.ela)
model = flowline.FluxBasedModel(origfls,
mb_model=mb,
fs=self.fs,
glen_a=self.glen_a)
model.run_until(500)
self.glacier = copy.deepcopy(model.fls)
def test_fails(self):
y0 = 0.
y1 = 100.
mb = ConstantBalanceModel(self.ela - 150.)
model = flowline.FluxBasedModel(self.glacier,
mb_model=mb,
y0=y0,
fs=self.fs,
glen_a=self.glen_a)
self.assertRaises(RuntimeError,
flowline._find_inital_glacier,
model,
mb,
y0,
y1,
rtol=0.02,
max_ite=5)
def test_commitment(self):
_tmp = cfg.PARAMS['mixed_min_shape']
cfg.PARAMS['mixed_min_shape'] = 0.
flowline.init_present_time_glacier(self.gdir)
cfg.PARAMS['mixed_min_shape'] = _tmp
mb_mod = massbalance.BackwardsMassBalanceModel(self.gdir)
fls = self.gdir.read_pickle('model_flowlines')
model = flowline.FluxBasedModel(fls,
mb_model=mb_mod,
y0=0.,
fs=self.fs,
glen_a=self.glen_a)
ref_vol = model.volume_km3
ref_area = model.area_km2
ref_len = model.fls[-1].length_m
np.testing.assert_allclose(ref_area, self.gdir.rgi_area_km2, rtol=0.01)
model.run_until_equilibrium()
self.assertTrue(model.yr > 100)
after_vol_1 = model.volume_km3
after_area_1 = model.area_km2
after_len_1 = model.fls[-1].length_m
_tmp = cfg.PARAMS['mixed_min_shape']
cfg.PARAMS['mixed_min_shape'] = 0.001
flowline.init_present_time_glacier(self.gdir)
cfg.PARAMS['mixed_min_shape'] = _tmp
glacier = self.gdir.read_pickle('model_flowlines')
mb_mod = massbalance.BackwardsMassBalanceModel(self.gdir)
fls = self.gdir.read_pickle('model_flowlines')
model = flowline.FluxBasedModel(fls,
mb_model=mb_mod,
y0=0.,
fs=self.fs,
glen_a=self.glen_a)
ref_vol = model.volume_km3
ref_area = model.area_km2
ref_len = model.fls[-1].length_m
np.testing.assert_allclose(ref_area, self.gdir.rgi_area_km2, rtol=0.01)
model.run_until_equilibrium()
self.assertTrue(model.yr > 100)
after_vol_2 = model.volume_km3
after_area_2 = model.area_km2
after_len_2 = model.fls[-1].length_m
self.assertTrue(after_vol_1 < (0.3 * ref_vol))
self.assertTrue(after_vol_2 < (0.3 * ref_vol))
if do_plot: # pragma: no cover
fig = plt.figure()
plt.plot(glacier[-1].surface_h, 'b', label='start')
plt.plot(model.fls[-1].surface_h, 'r', label='end')
plt.plot(glacier[-1].bed_h, 'gray', linewidth=2)
plt.legend(loc='best')
plt.show()
def test_iterative_back(self):
y0 = 0.
y1 = 150.
rtol = 0.02
mb = ConstantBalanceModel(self.ela + 50.)
model = flowline.FluxBasedModel(self.glacier,
mb_model=mb,
fs=self.fs,
glen_a=self.glen_a)
ite, bias, past_model = flowline._find_inital_glacier(model,
mb,
y0,
y1,
rtol=rtol)
bef_fls = copy.deepcopy(past_model.fls)
past_model.run_until(y1)
self.assertTrue(bef_fls[-1].area_m2 > past_model.area_m2)
np.testing.assert_allclose(past_model.area_m2,
self.glacier[-1].area_m2,
rtol=rtol)
if do_plot: # pragma: no cover
plt.plot(self.glacier[-1].surface_h, 'k', label='ref')
plt.plot(bef_fls[-1].surface_h, 'b', label='start')
plt.plot(past_model.fls[-1].surface_h, 'r', label='end')
plt.plot(self.glacier[-1].bed_h, 'gray', linewidth=2)
plt.legend(loc='best')
plt.show()
mb = ConstantBalanceModel(self.ela - 50.)
model = flowline.FluxBasedModel(self.glacier,
mb_model=mb,
y0=y0,
fs=self.fs,
glen_a=self.glen_a)
ite, bias, past_model = flowline._find_inital_glacier(model,
mb,
y0,
y1,
rtol=rtol)
bef_fls = copy.deepcopy(past_model.fls)
past_model.run_until(y1)
self.assertTrue(bef_fls[-1].area_m2 < past_model.area_m2)
np.testing.assert_allclose(past_model.area_m2,
self.glacier[-1].area_m2,
rtol=rtol)
if do_plot: # pragma: no cover
plt.plot(self.glacier[-1].surface_h, 'k', label='ref')
plt.plot(bef_fls[-1].surface_h, 'b', label='start')
plt.plot(past_model.fls[-1].surface_h, 'r', label='end')
plt.plot(self.glacier[-1].bed_h, 'gray', linewidth=2)
plt.legend(loc='best')
plt.show()
mb = ConstantBalanceModel(self.ela)
model = flowline.FluxBasedModel(self.glacier,
mb_model=mb,
y0=y0,
fs=self.fs,
glen_a=self.glen_a)
# Hit the correct one
ite, bias, past_model = flowline._find_inital_glacier(model,
mb,
y0,
y1,
rtol=rtol)
past_model.run_until(y1)
np.testing.assert_allclose(past_model.area_m2,
self.glacier[-1].area_m2,
rtol=rtol)
