def test_distribute_climate(self):
hef_file = get_demo_file('Hintereisferner.shp')
rgidf = gpd.GeoDataFrame.from_file(hef_file)
gdirs = []
# loop because for some reason indexing wont work
for index, entity in rgidf.iterrows():
gdir = oggm.GlacierDirectory(entity, base_dir=self.testdir)
gis.define_glacier_region(gdir, entity=entity)
gdirs.append(gdir)
climate.distribute_climate_data(gdirs)
with netCDF4.Dataset(get_demo_file('histalp_merged_hef.nc')) as nc_r:
ref_h = nc_r.variables['hgt'][1, 1]
ref_p = nc_r.variables['prcp'][:, 1, 1]
ref_p *= cfg.PARAMS['prcp_scaling_factor']
ref_t = nc_r.variables['temp'][:, 1, 1]
with netCDF4.Dataset(os.path.join(gdir.dir,
'climate_monthly.nc')) as nc_r:
self.assertTrue(ref_h == nc_r.ref_hgt)
np.testing.assert_allclose(ref_t, nc_r.variables['temp'][:])
np.testing.assert_allclose(ref_p, nc_r.variables['prcp'][:])
def test_mu_candidates(self):
hef_file = get_demo_file('Hintereisferner.shp')
entity = gpd.GeoDataFrame.from_file(hef_file).iloc[0]
gdirs = []
gdir = oggm.GlacierDirectory(entity, base_dir=self.testdir)
gis.define_glacier_region(gdir, entity=entity)
gis.glacier_masks(gdir)
centerlines.compute_centerlines(gdir)
geometry.initialize_flowlines(gdir)
geometry.catchment_area(gdir)
geometry.catchment_width_geom(gdir)
geometry.catchment_width_correction(gdir)
gdirs.append(gdir)
climate.distribute_climate_data(gdirs)
climate.mu_candidates(gdir, div_id=0)
se = gdir.read_pickle('mu_candidates')
self.assertTrue(se.index[0] == 1802)
self.assertTrue(se.index[-1] == 2003)
df = pd.DataFrame()
df['mu'] = se
# Check that the moovin average of temp is negatively correlated
# with the mus
with netCDF4.Dataset(get_demo_file('histalp_merged_hef.nc')) as nc_r:
ref_t = nc_r.variables['temp'][:, 1, 1]
ref_t = np.mean(ref_t.reshape((len(df), 12)), 1)
ma = np.convolve(ref_t, np.ones(31) / float(31), 'same')
df['temp'] = ma
df = df.dropna()
self.assertTrue(np.corrcoef(df['mu'], df['temp'])[0, 1] < -0.75)
def test_distribute_climate_cru(self):
hef_file = get_demo_file('Hintereisferner.shp')
entity = gpd.GeoDataFrame.from_file(hef_file).iloc[0]
gdirs = []
gdir = oggm.GlacierDirectory(entity, base_dir=self.testdir)
gis.define_glacier_region(gdir, entity=entity)
gdirs.append(gdir)
gdir = oggm.GlacierDirectory(entity, base_dir=self.testdir_cru)
gis.define_glacier_region(gdir, entity=entity)
gdirs.append(gdir)
climate.distribute_climate_data([gdirs[0]])
cru_dir = get_demo_file('cru_ts3.23.1901.2014.tmp.dat.nc')
cru_dir = os.path.dirname(cru_dir)
cfg.PATHS['climate_file'] = '~'
cfg.PATHS['cru_dir'] = cru_dir
climate.distribute_climate_data([gdirs[1]])
cfg.PATHS['cru_dir'] = '~'
cfg.PATHS['climate_file'] = get_demo_file('histalp_merged_hef.nc')
gdh = gdirs[0]
gdc = gdirs[1]
with xr.open_dataset(os.path.join(gdh.dir, 'climate_monthly.nc')) as nc_h:
with xr.open_dataset(os.path.join(gdc.dir, 'climate_monthly.nc')) as nc_c:
# put on the same altitude
# (using default gradient because better)
temp_cor = nc_c.temp -0.0065 * (nc_h.ref_hgt - nc_c.ref_hgt)
totest = temp_cor - nc_h.temp
self.assertTrue(totest.mean() < 0.5)
# precip
totest = nc_c.prcp - nc_h.prcp
self.assertTrue(totest.mean() < 100)
def test_mu_candidates(self):
hef_file = get_demo_file('Hintereisferner.shp')
entity = gpd.GeoDataFrame.from_file(hef_file).iloc[0]
gdirs = []
gdir = oggm.GlacierDirectory(entity, base_dir=self.testdir)
gis.define_glacier_region(gdir, entity=entity)
gis.glacier_masks(gdir)
centerlines.compute_centerlines(gdir)
geometry.initialize_flowlines(gdir)
geometry.catchment_area(gdir)
geometry.catchment_width_geom(gdir)
geometry.catchment_width_correction(gdir)
gdirs.append(gdir)
climate.distribute_climate_data(gdirs)
climate.mu_candidates(gdir, div_id=0)
se = gdir.read_pickle('mu_candidates')
self.assertTrue(se.index[0] == 1802)
self.assertTrue(se.index[-1] == 2003)
df = pd.DataFrame()
df['mu'] = se
# Check that the moovin average of temp is negatively correlated
# with the mus
with netCDF4.Dataset(get_demo_file('histalp_merged_hef.nc')) as nc_r:
ref_t = nc_r.variables['temp'][:, 1, 1]
ref_t = np.mean(ref_t.reshape((len(df), 12)), 1)
ma = np.convolve(ref_t, np.ones(31) / float(31), 'same')
df['temp'] = ma
df = df.dropna()
self.assertTrue(np.corrcoef(df['mu'], df['temp'])[0, 1] < -0.75)
def test_mb_climate(self):
hef_file = get_demo_file('Hintereisferner.shp')
entity = gpd.GeoDataFrame.from_file(hef_file).iloc[0]
gdirs = []
gdir = oggm.GlacierDirectory(entity, base_dir=self.testdir)
gis.define_glacier_region(gdir, entity=entity)
gdirs.append(gdir)
climate.distribute_climate_data(gdirs)
with netCDF4.Dataset(get_demo_file('histalp_merged_hef.nc')) as nc_r:
ref_h = nc_r.variables['hgt'][1, 1]
ref_p = nc_r.variables['prcp'][:, 1, 1]
ref_p *= cfg.PARAMS['prcp_scaling_factor']
ref_t = nc_r.variables['temp'][:, 1, 1]
ref_t = np.where(ref_t < 0, 0, ref_t)
hgts = np.array([ref_h, ref_h, -8000, 8000])
time, temp, prcp = climate.mb_climate_on_height(gdir, hgts)
ref_nt = 202*12
self.assertTrue(len(time) == ref_nt)
self.assertTrue(temp.shape == (4, ref_nt))
self.assertTrue(prcp.shape == (4, ref_nt))
np.testing.assert_allclose(temp[0, :], ref_t)
np.testing.assert_allclose(temp[0, :], temp[1, :])
np.testing.assert_allclose(prcp[0, :], prcp[1, :])
np.testing.assert_allclose(prcp[3, :], ref_p)
np.testing.assert_allclose(prcp[2, :], ref_p*0)
np.testing.assert_allclose(temp[3, :], ref_p*0)
yr = [1802, 1802]
time, temp, prcp = climate.mb_climate_on_height(gdir, hgts,
year_range=yr)
ref_nt = 1*12
self.assertTrue(len(time) == ref_nt)
self.assertTrue(temp.shape == (4, ref_nt))
self.assertTrue(prcp.shape == (4, ref_nt))
np.testing.assert_allclose(temp[0, :], ref_t[0:12])
np.testing.assert_allclose(temp[0, :], temp[1, :])
np.testing.assert_allclose(prcp[0, :], prcp[1, :])
np.testing.assert_allclose(prcp[3, :], ref_p[0:12])
np.testing.assert_allclose(prcp[2, :], ref_p[0:12]*0)
np.testing.assert_allclose(temp[3, :], ref_p[0:12]*0)
yr = [1803, 1804]
time, temp, prcp = climate.mb_climate_on_height(gdir, hgts,
year_range=yr)
ref_nt = 2*12
self.assertTrue(len(time) == ref_nt)
self.assertTrue(temp.shape == (4, ref_nt))
self.assertTrue(prcp.shape == (4, ref_nt))
np.testing.assert_allclose(temp[0, :], ref_t[12:36])
np.testing.assert_allclose(temp[0, :], temp[1, :])
np.testing.assert_allclose(prcp[0, :], prcp[1, :])
np.testing.assert_allclose(prcp[3, :], ref_p[12:36])
np.testing.assert_allclose(prcp[2, :], ref_p[12:36]*0)
np.testing.assert_allclose(temp[3, :], ref_p[12:36]*0)
def test_distribute_climate_cru(self):
hef_file = get_demo_file('Hintereisferner.shp')
rgidf = gpd.GeoDataFrame.from_file(hef_file)
gdirs = []
# loop because for some reason indexing wont work
for index, entity in rgidf.iterrows():
gdir = oggm.GlacierDirectory(entity, base_dir=self.testdir)
gis.define_glacier_region(gdir, entity=entity)
gdirs.append(gdir)
for index, entity in rgidf.iterrows():
gdir = oggm.GlacierDirectory(entity, base_dir=self.testdir_cru)
gis.define_glacier_region(gdir, entity=entity)
gdirs.append(gdir)
climate.distribute_climate_data([gdirs[0]])
cru_dir = get_demo_file('cru_ts3.23.1901.2014.tmp.dat.nc')
cru_dir = os.path.dirname(cru_dir)
cfg.PATHS['climate_file'] = '~'
cfg.PATHS['cru_dir'] = cru_dir
climate.distribute_climate_data([gdirs[1]])
cfg.PATHS['cru_dir'] = '~'
cfg.PATHS['climate_file'] = get_demo_file('histalp_merged_hef.nc')
gdh = gdirs[0]
gdc = gdirs[1]
with xr.open_dataset(os.path.join(gdh.dir,
'climate_monthly.nc')) as nc_h:
with xr.open_dataset(os.path.join(gdc.dir,
'climate_monthly.nc')) as nc_c:
# put on the same altitude
# (using default gradient because better)
temp_cor = nc_c.temp - 0.0065 * (nc_h.ref_hgt - nc_c.ref_hgt)
totest = temp_cor - nc_h.temp
self.assertTrue(totest.mean() < 0.5)
# precip
totest = nc_c.prcp - nc_h.prcp
self.assertTrue(totest.mean() < 100)
def test_find_tstars(self):
hef_file = get_demo_file('Hintereisferner.shp')
rgidf = gpd.GeoDataFrame.from_file(hef_file)
# loop because for some reason indexing wont work
gdirs = []
for index, entity in rgidf.iterrows():
gdir = oggm.GlacierDirectory(entity, base_dir=self.testdir)
gis.define_glacier_region(gdir, entity=entity)
gis.glacier_masks(gdir)
centerlines.compute_centerlines(gdir)
geometry.initialize_flowlines(gdir)
geometry.catchment_area(gdir)
geometry.catchment_width_geom(gdir)
geometry.catchment_width_correction(gdir)
gdirs.append(gdir)
climate.distribute_climate_data(gdirs)
climate.mu_candidates(gdir, div_id=0)
hef_file = get_demo_file('mbdata_RGI40-11.00897.csv')
mbdf = pd.read_csv(hef_file).set_index('YEAR')
t_stars, bias = climate.t_star_from_refmb(gdir, mbdf['ANNUAL_BALANCE'])
y, t, p = climate.mb_yearly_climate_on_glacier(gdir, div_id=0)
# which years to look at
selind = np.searchsorted(y, mbdf.index)
t = t[selind]
p = p[selind]
mu_yr_clim = gdir.read_pickle('mu_candidates', div_id=0)
for t_s, rmd in zip(t_stars, bias):
mb_per_mu = p - mu_yr_clim.loc[t_s] * t
md = utils.md(mbdf['ANNUAL_BALANCE'], mb_per_mu)
np.testing.assert_allclose(md, rmd)
self.assertTrue(np.abs(md / np.mean(mbdf['ANNUAL_BALANCE'])) < 0.1)
r = utils.corrcoef(mbdf['ANNUAL_BALANCE'], mb_per_mu)
self.assertTrue(r > 0.8)
def test_find_tstars(self):
hef_file = get_demo_file('Hintereisferner.shp')
rgidf = gpd.GeoDataFrame.from_file(hef_file)
# loop because for some reason indexing wont work
gdirs = []
for index, entity in rgidf.iterrows():
gdir = oggm.GlacierDirectory(entity, base_dir=self.testdir)
gis.define_glacier_region(gdir, entity=entity)
gis.glacier_masks(gdir)
centerlines.compute_centerlines(gdir)
geometry.initialize_flowlines(gdir)
geometry.catchment_area(gdir)
geometry.catchment_width_geom(gdir)
geometry.catchment_width_correction(gdir)
gdirs.append(gdir)
climate.distribute_climate_data(gdirs)
climate.mu_candidates(gdir, div_id=0)
hef_file = get_demo_file('mbdata_RGI40-11.00897.csv')
mbdf = pd.read_csv(hef_file).set_index('YEAR')
t_stars, bias = climate.t_star_from_refmb(gdir, mbdf['ANNUAL_BALANCE'])
y, t, p = climate.mb_yearly_climate_on_glacier(gdir, div_id=0)
# which years to look at
selind = np.searchsorted(y, mbdf.index)
t = t[selind]
p = p[selind]
mu_yr_clim = gdir.read_pickle('mu_candidates', div_id=0)
for t_s, rmd in zip(t_stars, bias):
mb_per_mu = p - mu_yr_clim.loc[t_s] * t
md = utils.md(mbdf['ANNUAL_BALANCE'], mb_per_mu)
np.testing.assert_allclose(md, rmd)
self.assertTrue(np.abs(md/np.mean(mbdf['ANNUAL_BALANCE'])) < 0.1)
r = utils.corrcoef(mbdf['ANNUAL_BALANCE'], mb_per_mu)
self.assertTrue(r > 0.8)
def test_distribute_climate(self):
hef_file = get_demo_file('Hintereisferner.shp')
entity = gpd.GeoDataFrame.from_file(hef_file).iloc[0]
gdirs = []
gdir = oggm.GlacierDirectory(entity, base_dir=self.testdir)
gis.define_glacier_region(gdir, entity=entity)
gdirs.append(gdir)
climate.distribute_climate_data(gdirs)
with netCDF4.Dataset(get_demo_file('histalp_merged_hef.nc')) as nc_r:
ref_h = nc_r.variables['hgt'][1, 1]
ref_p = nc_r.variables['prcp'][:, 1, 1]
ref_p *= cfg.PARAMS['prcp_scaling_factor']
ref_t = nc_r.variables['temp'][:, 1, 1]
with netCDF4.Dataset(os.path.join(gdir.dir, 'climate_monthly.nc')) as nc_r:
self.assertTrue(ref_h == nc_r.ref_hgt)
np.testing.assert_allclose(ref_t, nc_r.variables['temp'][:])
np.testing.assert_allclose(ref_p, nc_r.variables['prcp'][:])
def init_hef(reset=False, border=40, invert_with_sliding=True):
# test directory
testdir = TESTDIR_BASE + '_border{}'.format(border)
if not invert_with_sliding:
testdir += '_withoutslide'
if not os.path.exists(testdir):
os.makedirs(testdir)
reset = True
if not os.path.exists(os.path.join(testdir, 'RGI40-11.00897')):
reset = True
if not os.path.exists(os.path.join(testdir, 'RGI40-11.00897',
'inversion_params.pkl')):
reset = True
# Init
cfg.initialize()
cfg.set_divides_db(get_demo_file('HEF_divided.shp'))
cfg.PATHS['dem_file'] = get_demo_file('hef_srtm.tif')
cfg.PATHS['climate_file'] = get_demo_file('histalp_merged_hef.nc')
cfg.PARAMS['border'] = border
# loop because for some reason indexing wont work
hef_file = get_demo_file('Hintereisferner.shp')
rgidf = gpd.GeoDataFrame.from_file(hef_file)
for index, entity in rgidf.iterrows():
gdir = oggm.GlacierDirectory(entity, base_dir=testdir, reset=reset)
if not reset:
return gdir
gis.define_glacier_region(gdir, entity=entity)
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.distribute_climate_data([gdir])
climate.mu_candidates(gdir, div_id=0)
hef_file = get_demo_file('mbdata_RGI40-11.00897.csv')
mbdf = pd.read_csv(hef_file).set_index('YEAR')
t_star, bias = climate.t_star_from_refmb(gdir, mbdf['ANNUAL_BALANCE'])
climate.local_mustar_apparent_mb(gdir, tstar=t_star[-1], bias=bias[-1])
inversion.prepare_for_inversion(gdir)
ref_v = 0.573 * 1e9
if invert_with_sliding:
def to_optimize(x):
# For backwards compat
_fd = 1.9e-24 * x[0]
glen_a = (cfg.N+2) * _fd / 2.
fs = 5.7e-20 * x[1]
v, _ = inversion.invert_parabolic_bed(gdir, fs=fs,
glen_a=glen_a)
return (v - ref_v)**2
import scipy.optimize as optimization
out = optimization.minimize(to_optimize, [1, 1],
bounds=((0.01, 10), (0.01, 10)),
tol=1e-4)['x']
_fd = 1.9e-24 * out[0]
glen_a = (cfg.N+2) * _fd / 2.
fs = 5.7e-20 * out[1]
v, _ = inversion.invert_parabolic_bed(gdir, fs=fs,
glen_a=glen_a,
write=True)
else:
def to_optimize(x):
glen_a = cfg.A * x[0]
v, _ = inversion.invert_parabolic_bed(gdir, fs=0.,
glen_a=glen_a)
return (v - ref_v)**2
import scipy.optimize as optimization
out = optimization.minimize(to_optimize, [1],
bounds=((0.01, 10),),
tol=1e-4)['x']
glen_a = cfg.A * out[0]
fs = 0.
v, _ = inversion.invert_parabolic_bed(gdir, fs=fs,
glen_a=glen_a,
write=True)
d = dict(fs=fs, glen_a=glen_a)
d['factor_glen_a'] = out[0]
try:
d['factor_fs'] = out[1]
except IndexError:
d['factor_fs'] = 0.
gdir.write_pickle(d, 'inversion_params')
inversion.distribute_thickness(gdir, how='per_altitude',
add_nc_name=True)
inversion.distribute_thickness(gdir, how='per_interpolation',
add_slope=False, smooth=False,
add_nc_name=True)
return gdir
def init_hef(reset=False, border=40, invert_with_sliding=True):
# test directory
testdir = TESTDIR_BASE + '_border{}'.format(border)
if not invert_with_sliding:
testdir += '_withoutslide'
if not os.path.exists(testdir):
os.makedirs(testdir)
reset = True
if not os.path.exists(os.path.join(testdir, 'RGI40-11.00897')):
reset = True
if not os.path.exists(os.path.join(testdir, 'RGI40-11.00897',
'inversion_params.pkl')):
reset = True
# Init
cfg.initialize()
cfg.set_divides_db(get_demo_file('HEF_divided.shp'))
cfg.PATHS['dem_file'] = get_demo_file('hef_srtm.tif')
cfg.PATHS['climate_file'] = get_demo_file('histalp_merged_hef.nc')
cfg.PARAMS['border'] = border
# loop because for some reason indexing wont work
hef_file = get_demo_file('Hintereisferner.shp')
rgidf = gpd.GeoDataFrame.from_file(hef_file)
for index, entity in rgidf.iterrows():
gdir = oggm.GlacierDirectory(entity, base_dir=testdir, reset=reset)
if not reset:
return gdir
gis.define_glacier_region(gdir, entity=entity)
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.distribute_climate_data([gdir])
climate.mu_candidates(gdir, div_id=0)
hef_file = get_demo_file('mbdata_RGI40-11.00897.csv')
mbdf = pd.read_csv(hef_file).set_index('YEAR')
t_star, bias = climate.t_star_from_refmb(gdir, mbdf['ANNUAL_BALANCE'])
climate.local_mustar_apparent_mb(gdir, tstar=t_star[-1], bias=bias[-1])
inversion.prepare_for_inversion(gdir)
ref_v = 0.573 * 1e9
if invert_with_sliding:
def to_optimize(x):
# For backwards compat
_fd = 1.9e-24 * x[0]
glen_a = (cfg.N+2) * _fd / 2.
fs = 5.7e-20 * x[1]
v, _ = inversion.invert_parabolic_bed(gdir, fs=fs,
glen_a=glen_a)
return (v - ref_v)**2
import scipy.optimize as optimization
out = optimization.minimize(to_optimize, [1, 1],
bounds=((0.01, 10), (0.01, 10)),
tol=1e-4)['x']
_fd = 1.9e-24 * out[0]
glen_a = (cfg.N+2) * _fd / 2.
fs = 5.7e-20 * out[1]
v, _ = inversion.invert_parabolic_bed(gdir, fs=fs,
glen_a=glen_a,
write=True)
else:
def to_optimize(x):
glen_a = cfg.A * x[0]
v, _ = inversion.invert_parabolic_bed(gdir, fs=0.,
glen_a=glen_a)
return (v - ref_v)**2
import scipy.optimize as optimization
out = optimization.minimize(to_optimize, [1],
bounds=((0.01, 10),),
tol=1e-4)['x']
glen_a = cfg.A * out[0]
fs = 0.
v, _ = inversion.invert_parabolic_bed(gdir, fs=fs,
glen_a=glen_a,
write=True)
d = dict(fs=fs, glen_a=glen_a)
d['factor_glen_a'] = out[0]
try:
d['factor_fs'] = out[1]
except IndexError:
d['factor_fs'] = 0.
gdir.write_pickle(d, 'inversion_params')
return gdir
def test_invert_hef_nofs(self):
hef_file = get_demo_file('Hintereisferner.shp')
rgidf = gpd.GeoDataFrame.from_file(hef_file)
# loop because for some reason indexing wont work
for index, entity in rgidf.iterrows():
gdir = oggm.GlacierDirectory(entity, base_dir=self.testdir)
gis.define_glacier_region(gdir, entity=entity)
gis.glacier_masks(gdir)
centerlines.compute_centerlines(gdir)
geometry.initialize_flowlines(gdir)
geometry.catchment_area(gdir)
geometry.catchment_width_geom(gdir)
geometry.catchment_width_correction(gdir)
climate.distribute_climate_data([gdir])
climate.mu_candidates(gdir, div_id=0)
hef_file = get_demo_file('mbdata_RGI40-11.00897.csv')
mbdf = pd.read_csv(hef_file).set_index('YEAR')
t_star, bias = climate.t_star_from_refmb(gdir, mbdf['ANNUAL_BALANCE'])
t_star = t_star[-1]
bias = bias[-1]
climate.local_mustar_apparent_mb(gdir, tstar=t_star, bias=bias)
# OK. Values from Fischer and Kuhn 2013
# Area: 8.55
# meanH = 67+-7
# Volume = 0.573+-0.063
# maxH = 242+-13
inversion.prepare_for_inversion(gdir)
ref_v = 0.573 * 1e9
def to_optimize(x):
glen_a = cfg.A * x[0]
fs = 0.
v, _ = inversion.invert_parabolic_bed(gdir, fs=fs,
glen_a=glen_a)
return (v - ref_v)**2
import scipy.optimize as optimization
out = optimization.minimize(to_optimize, [1],
bounds=((0.00001, 100000),),
tol=1e-4)['x']
self.assertTrue(out[0] > 0.1)
self.assertTrue(out[0] < 10)
glen_a = cfg.A * out[0]
fs = 0.
v, _ = inversion.invert_parabolic_bed(gdir, fs=fs,
glen_a=glen_a,
write=True)
np.testing.assert_allclose(ref_v, v)
lens = [len(gdir.read_pickle('centerlines', div_id=i)) for i in [1,2,3]]
pid = np.argmax(lens) + 1
cls = gdir.read_pickle('inversion_output', div_id=pid)
fls = gdir.read_pickle('inversion_flowlines', div_id=pid)
maxs = 0.
for cl, fl in zip(cls, fls):
thick = cl['thick']
_max = np.max(thick)
if _max > maxs:
maxs = _max
atol = 30 if HAS_NEW_GDAL else 10
np.testing.assert_allclose(242, maxs, atol=atol)
# check that its not tooo sensitive to the dx
cfg.PARAMS['flowline_dx'] = 1.
geometry.initialize_flowlines(gdir)
geometry.catchment_area(gdir)
geometry.catchment_width_geom(gdir)
geometry.catchment_width_correction(gdir)
climate.distribute_climate_data([gdir])
climate.mu_candidates(gdir, div_id=0)
hef_file = get_demo_file('mbdata_RGI40-11.00897.csv')
mbdf = pd.read_csv(hef_file).set_index('YEAR')
t_star, bias = climate.t_star_from_refmb(gdir, mbdf['ANNUAL_BALANCE'])
t_star = t_star[-1]
bias = bias[-1]
climate.local_mustar_apparent_mb(gdir, tstar=t_star, bias=bias)
inversion.prepare_for_inversion(gdir)
v, _ = inversion.invert_parabolic_bed(gdir, fs=fs,
glen_a=glen_a,
write=True)
np.testing.assert_allclose(ref_v, v, rtol=0.02)
cls = gdir.read_pickle('inversion_output', div_id=pid)
maxs = 0.
for cl in cls:
thick = cl['thick']
_max = np.max(thick)
if _max > maxs:
maxs = _max
np.testing.assert_allclose(242, maxs, atol=atol)
def test_invert_hef(self):
hef_file = get_demo_file('Hintereisferner.shp')
rgidf = gpd.GeoDataFrame.from_file(hef_file)
# loop because for some reason indexing wont work
for index, entity in rgidf.iterrows():
gdir = oggm.GlacierDirectory(entity, base_dir=self.testdir)
gis.define_glacier_region(gdir, entity=entity)
gis.glacier_masks(gdir)
centerlines.compute_centerlines(gdir)
geometry.initialize_flowlines(gdir)
geometry.catchment_area(gdir)
geometry.catchment_width_geom(gdir)
geometry.catchment_width_correction(gdir)
climate.distribute_climate_data([gdir])
climate.mu_candidates(gdir, div_id=0)
hef_file = get_demo_file('mbdata_RGI40-11.00897.csv')
mbdf = pd.read_csv(hef_file).set_index('YEAR')
t_star, bias = climate.t_star_from_refmb(gdir, mbdf['ANNUAL_BALANCE'])
t_star = t_star[-1]
bias = bias[-1]
climate.local_mustar_apparent_mb(gdir, tstar=t_star, bias=bias)
# OK. Values from Fischer and Kuhn 2013
# Area: 8.55
# meanH = 67+-7
# Volume = 0.573+-0.063
# maxH = 242+-13
inversion.prepare_for_inversion(gdir)
lens = [
len(gdir.read_pickle('centerlines', div_id=i)) for i in [1, 2, 3]
]
pid = np.argmax(lens) + 1
# Check how many clips:
cls = gdir.read_pickle('inversion_input', div_id=pid)
nabove = 0
maxs = 0.
npoints = 0.
for cl in cls:
# Clip slope to avoid negative and small slopes
slope = cl['slope_angle']
nm = np.where(slope < np.deg2rad(2.))
nabove += len(nm[0])
npoints += len(slope)
_max = np.max(slope)
if _max > maxs:
maxs = _max
self.assertTrue(nabove == 0)
self.assertTrue(np.rad2deg(maxs) < 40.)
ref_v = 0.573 * 1e9
def to_optimize(x):
glen_a = cfg.A * x[0]
fs = cfg.FS * x[1]
v, _ = inversion.invert_parabolic_bed(gdir, fs=fs, glen_a=glen_a)
return (v - ref_v)**2
import scipy.optimize as optimization
out = optimization.minimize(to_optimize, [1, 1],
bounds=((0.01, 10), (0.01, 10)),
tol=1e-4)['x']
self.assertTrue(out[0] > 0.1)
self.assertTrue(out[1] > 0.1)
self.assertTrue(out[0] < 1.1)
self.assertTrue(out[1] < 1.1)
glen_a = cfg.A * out[0]
fs = cfg.FS * out[1]
v, _ = inversion.invert_parabolic_bed(gdir,
fs=fs,
glen_a=glen_a,
write=True)
np.testing.assert_allclose(ref_v, v)
lens = [
len(gdir.read_pickle('centerlines', div_id=i)) for i in [1, 2, 3]
]
pid = np.argmax(lens) + 1
cls = gdir.read_pickle('inversion_output', div_id=pid)
fls = gdir.read_pickle('inversion_flowlines', div_id=pid)
maxs = 0.
for cl, fl in zip(cls, fls):
thick = cl['thick']
_max = np.max(thick)
if _max > maxs:
maxs = _max
np.testing.assert_allclose(242, maxs, atol=21)
def test_yearly_mb_climate(self):
hef_file = get_demo_file('Hintereisferner.shp')
rgidf = gpd.GeoDataFrame.from_file(hef_file)
# loop because for some reason indexing wont work
gdirs = []
for index, entity in rgidf.iterrows():
gdir = oggm.GlacierDirectory(entity, base_dir=self.testdir)
gis.define_glacier_region(gdir, entity=entity)
gdirs.append(gdir)
climate.distribute_climate_data(gdirs)
nc_r = netCDF4.Dataset(get_demo_file('histalp_merged_hef.nc'))
ref_h = nc_r.variables['hgt'][1, 1]
ref_p = nc_r.variables['prcp'][:, 1, 1]
ref_p *= cfg.PARAMS['prcp_scaling_factor']
ref_t = nc_r.variables['temp'][:, 1, 1]
ref_t = np.where(ref_t < 0, 0, ref_t)
nc_r.close()
# NORMAL --------------------------------------------------------------
hgts = np.array([ref_h, ref_h, -8000, 8000])
years, temp, prcp = climate.mb_yearly_climate_on_height(gdir, hgts)
ref_nt = 202
self.assertTrue(len(years) == ref_nt)
self.assertTrue(temp.shape == (4, ref_nt))
self.assertTrue(prcp.shape == (4, ref_nt))
yr = [1802, 1802]
years, temp, prcp = climate.mb_yearly_climate_on_height(gdir, hgts,
year_range=yr)
ref_nt = 1
self.assertTrue(len(years) == ref_nt)
self.assertTrue(years == 1802)
self.assertTrue(temp.shape == (4, ref_nt))
self.assertTrue(prcp.shape == (4, ref_nt))
np.testing.assert_allclose(temp[0, :], np.sum(ref_t[0:12]))
np.testing.assert_allclose(temp[0, :], temp[1, :])
np.testing.assert_allclose(prcp[0, :], prcp[1, :])
np.testing.assert_allclose(prcp[3, :], np.sum(ref_p[0:12]))
np.testing.assert_allclose(prcp[2, :], np.sum(ref_p[0:12])*0)
np.testing.assert_allclose(temp[3, :], np.sum(ref_p[0:12])*0)
yr = [1803, 1804]
years, temp, prcp = climate.mb_yearly_climate_on_height(gdir, hgts,
year_range=yr)
ref_nt = 2
self.assertTrue(len(years) == ref_nt)
np.testing.assert_allclose(years, yr)
self.assertTrue(temp.shape == (4, ref_nt))
self.assertTrue(prcp.shape == (4, ref_nt))
np.testing.assert_allclose(prcp[2, :], [0, 0])
np.testing.assert_allclose(temp[3, :], [0, 0])
# FLATTEN -------------------------------------------------------------
hgts = np.array([ref_h, ref_h, -8000, 8000])
years, temp, prcp = climate.mb_yearly_climate_on_height(gdir, hgts,
flatten=True)
ref_nt = 202
self.assertTrue(len(years) == ref_nt)
self.assertTrue(temp.shape == (ref_nt,))
self.assertTrue(prcp.shape == (ref_nt,))
yr = [1802, 1802]
hgts = np.array([ref_h])
years, temp, prcp = climate.mb_yearly_climate_on_height(gdir, hgts,
year_range=yr,
flatten=True)
ref_nt = 1
self.assertTrue(len(years) == ref_nt)
self.assertTrue(years == 1802)
self.assertTrue(temp.shape == (ref_nt,))
self.assertTrue(prcp.shape == (ref_nt,))
np.testing.assert_allclose(temp[:], np.sum(ref_t[0:12]))
yr = [1802, 1802]
hgts = np.array([8000])
years, temp, prcp = climate.mb_yearly_climate_on_height(gdir, hgts,
year_range=yr,
flatten=True)
np.testing.assert_allclose(prcp[:], np.sum(ref_p[0:12]))
def test_distribute(self):
hef_file = get_demo_file('Hintereisferner.shp')
entity = gpd.GeoDataFrame.from_file(hef_file).iloc[0]
gdir = oggm.GlacierDirectory(entity, base_dir=self.testdir)
gis.define_glacier_region(gdir, entity=entity)
gis.glacier_masks(gdir)
centerlines.compute_centerlines(gdir)
geometry.initialize_flowlines(gdir)
geometry.catchment_area(gdir)
geometry.catchment_width_geom(gdir)
geometry.catchment_width_correction(gdir)
climate.distribute_climate_data([gdir])
climate.mu_candidates(gdir, div_id=0)
hef_file = get_demo_file('mbdata_RGI40-11.00897.csv')
mbdf = pd.read_csv(hef_file).set_index('YEAR')
t_star, bias = climate.t_star_from_refmb(gdir, mbdf['ANNUAL_BALANCE'])
t_star = t_star[-1]
bias = bias[-1]
climate.local_mustar_apparent_mb(gdir, tstar=t_star, bias=bias)
# OK. Values from Fischer and Kuhn 2013
# Area: 8.55
# meanH = 67+-7
# Volume = 0.573+-0.063
# maxH = 242+-13
inversion.prepare_for_inversion(gdir)
ref_v = 0.573 * 1e9
def to_optimize(x):
glen_a = cfg.A * x[0]
fs = cfg.FS * x[1]
v, _ = inversion.invert_parabolic_bed(gdir, fs=fs, glen_a=glen_a)
return (v - ref_v)**2
import scipy.optimize as optimization
out = optimization.minimize(to_optimize, [1, 1],
bounds=((0.01, 10), (0.01, 10)),
tol=1e-1)['x']
glen_a = cfg.A * out[0]
fs = cfg.FS * out[1]
v, _ = inversion.invert_parabolic_bed(gdir,
fs=fs,
glen_a=glen_a,
write=True)
np.testing.assert_allclose(ref_v, v)
inversion.distribute_thickness(gdir,
how='per_altitude',
add_nc_name=True)
inversion.distribute_thickness(gdir,
how='per_interpolation',
add_slope=False,
add_nc_name=True)
grids_file = gdir.get_filepath('gridded_data')
with netCDF4.Dataset(grids_file) as nc:
t1 = nc.variables['thickness_per_altitude'][:]
t2 = nc.variables['thickness_per_interpolation'][:]
np.testing.assert_allclose(np.sum(t1), np.sum(t2))
if not HAS_NEW_GDAL:
np.testing.assert_allclose(np.max(t1), np.max(t2), atol=30)
def test_local_mustar(self):
hef_file = get_demo_file('Hintereisferner.shp')
rgidf = gpd.GeoDataFrame.from_file(hef_file)
# loop because for some reason indexing wont work
for index, entity in rgidf.iterrows():
gdir = oggm.GlacierDirectory(entity, base_dir=self.testdir)
gis.define_glacier_region(gdir, entity=entity)
gis.glacier_masks(gdir)
centerlines.compute_centerlines(gdir)
geometry.initialize_flowlines(gdir)
geometry.catchment_area(gdir)
geometry.catchment_width_geom(gdir)
geometry.catchment_width_correction(gdir)
climate.distribute_climate_data([gdir])
climate.mu_candidates(gdir, div_id=0)
hef_file = get_demo_file('mbdata_RGI40-11.00897.csv')
mbdf = pd.read_csv(hef_file).set_index('YEAR')
t_star, bias = climate.t_star_from_refmb(gdir, mbdf['ANNUAL_BALANCE'])
t_star = t_star[-1]
bias = bias[-1]
climate.local_mustar_apparent_mb(gdir, tstar=t_star, bias=bias)
df = pd.read_csv(gdir.get_filepath('local_mustar', div_id=0))
mu_ref = gdir.read_pickle('mu_candidates', div_id=0).loc[t_star]
np.testing.assert_allclose(mu_ref, df['mu_star'][0], atol=1e-3)
# Check for apparent mb to be zeros
for i in [0] + list(gdir.divide_ids):
fls = gdir.read_pickle('inversion_flowlines', div_id=i)
tmb = 0.
for fl in fls:
self.assertTrue(fl.apparent_mb.shape == fl.widths.shape)
tmb += np.sum(fl.apparent_mb * fl.widths)
np.testing.assert_allclose(tmb, 0., atol=0.01)
if i == 0: continue
np.testing.assert_allclose(fls[-1].flux[-1], 0., atol=0.01)
# ------ Look for gradient
# which years to look at
fls = gdir.read_pickle('inversion_flowlines', div_id=0)
mb_on_h = np.array([])
h = np.array([])
for fl in fls:
y, t, p = climate.mb_yearly_climate_on_height(gdir, fl.surface_h)
selind = np.searchsorted(y, mbdf.index)
t = np.mean(t[:, selind], axis=1)
p = np.mean(p[:, selind], axis=1)
mb_on_h = np.append(mb_on_h, p - mu_ref * t)
h = np.append(h, fl.surface_h)
dfg = pd.read_csv(get_demo_file('mbgrads_RGI40-11.00897.csv'),
index_col='ALTITUDE').mean(axis=1)
# Take the altitudes below 3100 and fit a line
dfg = dfg[dfg.index < 3100]
pok = np.where(h < 3100)
from scipy.stats import linregress
slope_obs, _, _, _, _ = linregress(dfg.index, dfg.values)
slope_our, _, _, _, _ = linregress(h[pok], mb_on_h[pok])
np.testing.assert_allclose(slope_obs, slope_our, rtol=0.1)
def test_yearly_mb_climate(self):
hef_file = get_demo_file('Hintereisferner.shp')
rgidf = gpd.GeoDataFrame.from_file(hef_file)
# loop because for some reason indexing wont work
gdirs = []
for index, entity in rgidf.iterrows():
gdir = oggm.GlacierDirectory(entity, base_dir=self.testdir)
gis.define_glacier_region(gdir, entity=entity)
gdirs.append(gdir)
climate.distribute_climate_data(gdirs)
nc_r = netCDF4.Dataset(get_demo_file('histalp_merged_hef.nc'))
ref_h = nc_r.variables['hgt'][1, 1]
ref_p = nc_r.variables['prcp'][:, 1, 1]
ref_p *= cfg.PARAMS['prcp_scaling_factor']
ref_t = nc_r.variables['temp'][:, 1, 1]
ref_t = np.where(ref_t < 0, 0, ref_t)
nc_r.close()
# NORMAL --------------------------------------------------------------
hgts = np.array([ref_h, ref_h, -8000, 8000])
years, temp, prcp = climate.mb_yearly_climate_on_height(gdir, hgts)
ref_nt = 202
self.assertTrue(len(years) == ref_nt)
self.assertTrue(temp.shape == (4, ref_nt))
self.assertTrue(prcp.shape == (4, ref_nt))
yr = [1802, 1802]
years, temp, prcp = climate.mb_yearly_climate_on_height(gdir,
hgts,
year_range=yr)
ref_nt = 1
self.assertTrue(len(years) == ref_nt)
self.assertTrue(years == 1802)
self.assertTrue(temp.shape == (4, ref_nt))
self.assertTrue(prcp.shape == (4, ref_nt))
np.testing.assert_allclose(temp[0, :], np.sum(ref_t[0:12]))
np.testing.assert_allclose(temp[0, :], temp[1, :])
np.testing.assert_allclose(prcp[0, :], prcp[1, :])
np.testing.assert_allclose(prcp[3, :], np.sum(ref_p[0:12]))
np.testing.assert_allclose(prcp[2, :], np.sum(ref_p[0:12]) * 0)
np.testing.assert_allclose(temp[3, :], np.sum(ref_p[0:12]) * 0)
yr = [1803, 1804]
years, temp, prcp = climate.mb_yearly_climate_on_height(gdir,
hgts,
year_range=yr)
ref_nt = 2
self.assertTrue(len(years) == ref_nt)
np.testing.assert_allclose(years, yr)
self.assertTrue(temp.shape == (4, ref_nt))
self.assertTrue(prcp.shape == (4, ref_nt))
np.testing.assert_allclose(prcp[2, :], [0, 0])
np.testing.assert_allclose(temp[3, :], [0, 0])
# FLATTEN -------------------------------------------------------------
hgts = np.array([ref_h, ref_h, -8000, 8000])
years, temp, prcp = climate.mb_yearly_climate_on_height(gdir,
hgts,
flatten=True)
ref_nt = 202
self.assertTrue(len(years) == ref_nt)
self.assertTrue(temp.shape == (ref_nt, ))
self.assertTrue(prcp.shape == (ref_nt, ))
yr = [1802, 1802]
hgts = np.array([ref_h])
years, temp, prcp = climate.mb_yearly_climate_on_height(gdir,
hgts,
year_range=yr,
flatten=True)
ref_nt = 1
self.assertTrue(len(years) == ref_nt)
self.assertTrue(years == 1802)
self.assertTrue(temp.shape == (ref_nt, ))
self.assertTrue(prcp.shape == (ref_nt, ))
np.testing.assert_allclose(temp[:], np.sum(ref_t[0:12]))
yr = [1802, 1802]
hgts = np.array([8000])
years, temp, prcp = climate.mb_yearly_climate_on_height(gdir,
hgts,
year_range=yr,
flatten=True)
np.testing.assert_allclose(prcp[:], np.sum(ref_p[0:12]))
def test_invert_hef(self):
hef_file = get_demo_file('Hintereisferner.shp')
rgidf = gpd.GeoDataFrame.from_file(hef_file)
# loop because for some reason indexing wont work
for index, entity in rgidf.iterrows():
gdir = oggm.GlacierDirectory(entity, base_dir=self.testdir)
gis.define_glacier_region(gdir, entity=entity)
gis.glacier_masks(gdir)
centerlines.compute_centerlines(gdir)
geometry.initialize_flowlines(gdir)
geometry.catchment_area(gdir)
geometry.catchment_width_geom(gdir)
geometry.catchment_width_correction(gdir)
climate.distribute_climate_data([gdir])
climate.mu_candidates(gdir, div_id=0)
hef_file = get_demo_file('mbdata_RGI40-11.00897.csv')
mbdf = pd.read_csv(hef_file).set_index('YEAR')
t_star, bias = climate.t_star_from_refmb(gdir, mbdf['ANNUAL_BALANCE'])
t_star = t_star[-1]
bias = bias[-1]
climate.local_mustar_apparent_mb(gdir, tstar=t_star, bias=bias)
# OK. Values from Fischer and Kuhn 2013
# Area: 8.55
# meanH = 67+-7
# Volume = 0.573+-0.063
# maxH = 242+-13
inversion.prepare_for_inversion(gdir)
lens = [len(gdir.read_pickle('centerlines', div_id=i)) for i in [1,2,3]]
pid = np.argmax(lens) + 1
# Check how many clips:
cls = gdir.read_pickle('inversion_input', div_id=pid)
nabove = 0
maxs = 0.
npoints = 0.
for cl in cls:
# Clip slope to avoid negative and small slopes
slope = cl['slope_angle']
nm = np.where(slope < np.deg2rad(2.))
nabove += len(nm[0])
npoints += len(slope)
_max = np.max(slope)
if _max > maxs:
maxs = _max
self.assertTrue(nabove == 0)
self.assertTrue(np.rad2deg(maxs) < 40.)
ref_v = 0.573 * 1e9
def to_optimize(x):
glen_a = cfg.A * x[0]
fs = cfg.FS * x[1]
v, _ = inversion.invert_parabolic_bed(gdir, fs=fs,
glen_a=glen_a)
return (v - ref_v)**2
import scipy.optimize as optimization
out = optimization.minimize(to_optimize, [1, 1],
bounds=((0.01, 10), (0.01, 10)),
tol=1e-4)['x']
self.assertTrue(out[0] > 0.1)
self.assertTrue(out[1] > 0.1)
self.assertTrue(out[0] < 1.1)
self.assertTrue(out[1] < 1.1)
glen_a = cfg.A * out[0]
fs = cfg.FS * out[1]
v, _ = inversion.invert_parabolic_bed(gdir, fs=fs,
glen_a=glen_a,
write=True)
np.testing.assert_allclose(ref_v, v)
lens = [len(gdir.read_pickle('centerlines', div_id=i)) for i in [1,2,3]]
pid = np.argmax(lens) + 1
cls = gdir.read_pickle('inversion_output', div_id=pid)
fls = gdir.read_pickle('inversion_flowlines', div_id=pid)
maxs = 0.
for cl, fl in zip(cls, fls):
thick = cl['thick']
_max = np.max(thick)
if _max > maxs:
maxs = _max
np.testing.assert_allclose(242, maxs, atol=21)
def test_local_mustar(self):
hef_file = get_demo_file('Hintereisferner.shp')
rgidf = gpd.GeoDataFrame.from_file(hef_file)
# loop because for some reason indexing wont work
for index, entity in rgidf.iterrows():
gdir = oggm.GlacierDirectory(entity, base_dir=self.testdir)
gis.define_glacier_region(gdir, entity=entity)
gis.glacier_masks(gdir)
centerlines.compute_centerlines(gdir)
geometry.initialize_flowlines(gdir)
geometry.catchment_area(gdir)
geometry.catchment_width_geom(gdir)
geometry.catchment_width_correction(gdir)
climate.distribute_climate_data([gdir])
climate.mu_candidates(gdir, div_id=0)
hef_file = get_demo_file('mbdata_RGI40-11.00897.csv')
mbdf = pd.read_csv(hef_file).set_index('YEAR')
t_star, bias = climate.t_star_from_refmb(gdir, mbdf['ANNUAL_BALANCE'])
t_star = t_star[-1]
bias = bias[-1]
climate.local_mustar_apparent_mb(gdir, tstar=t_star, bias=bias)
df = pd.read_csv(gdir.get_filepath('local_mustar', div_id=0))
mu_ref = gdir.read_pickle('mu_candidates', div_id=0).loc[t_star]
np.testing.assert_allclose(mu_ref, df['mu_star'][0], atol=1e-3)
# Check for apparent mb to be zeros
for i in [0] + list(gdir.divide_ids):
fls = gdir.read_pickle('inversion_flowlines', div_id=i)
tmb = 0.
for fl in fls:
self.assertTrue(fl.apparent_mb.shape == fl.widths.shape)
tmb += np.sum(fl.apparent_mb * fl.widths)
np.testing.assert_allclose(tmb, 0., atol=0.01)
if i == 0: continue
np.testing.assert_allclose(fls[-1].flux[-1], 0., atol=0.01)
# ------ Look for gradient
# which years to look at
fls = gdir.read_pickle('inversion_flowlines', div_id=0)
mb_on_h = np.array([])
h = np.array([])
for fl in fls:
y, t, p = climate.mb_yearly_climate_on_height(gdir, fl.surface_h)
selind = np.searchsorted(y, mbdf.index)
t = np.mean(t[:, selind], axis=1)
p = np.mean(p[:, selind], axis=1)
mb_on_h = np.append(mb_on_h, p - mu_ref * t)
h = np.append(h, fl.surface_h)
dfg = pd.read_csv(get_demo_file('mbgrads_RGI40-11.00897.csv'),
index_col='ALTITUDE').mean(axis=1)
# Take the altitudes below 3100 and fit a line
dfg = dfg[dfg.index < 3100]
pok = np.where(h < 3100)
from scipy.stats import linregress
slope_obs, _, _, _, _ = linregress(dfg.index, dfg.values)
slope_our, _, _, _, _ = linregress(h[pok], mb_on_h[pok])
np.testing.assert_allclose(slope_obs, slope_our, rtol=0.1)
def test_distribute(self):
hef_file = get_demo_file('Hintereisferner.shp')
rgidf = gpd.GeoDataFrame.from_file(hef_file)
# loop because for some reason indexing wont work
for index, entity in rgidf.iterrows():
gdir = oggm.GlacierDirectory(entity, base_dir=self.testdir)
gis.define_glacier_region(gdir, entity=entity)
gis.glacier_masks(gdir)
centerlines.compute_centerlines(gdir)
geometry.initialize_flowlines(gdir)
geometry.catchment_area(gdir)
geometry.catchment_width_geom(gdir)
geometry.catchment_width_correction(gdir)
climate.distribute_climate_data([gdir])
climate.mu_candidates(gdir, div_id=0)
hef_file = get_demo_file('mbdata_RGI40-11.00897.csv')
mbdf = pd.read_csv(hef_file).set_index('YEAR')
t_star, bias = climate.t_star_from_refmb(gdir, mbdf['ANNUAL_BALANCE'])
t_star = t_star[-1]
bias = bias[-1]
climate.local_mustar_apparent_mb(gdir, tstar=t_star, bias=bias)
# OK. Values from Fischer and Kuhn 2013
# Area: 8.55
# meanH = 67+-7
# Volume = 0.573+-0.063
# maxH = 242+-13
inversion.prepare_for_inversion(gdir)
ref_v = 0.573 * 1e9
def to_optimize(x):
glen_a = cfg.A * x[0]
fs = cfg.FS * x[1]
v, _ = inversion.invert_parabolic_bed(gdir, fs=fs,
glen_a=glen_a)
return (v - ref_v)**2
import scipy.optimize as optimization
out = optimization.minimize(to_optimize, [1, 1],
bounds=((0.01, 10), (0.01, 10)),
tol=1e-1)['x']
glen_a = cfg.A * out[0]
fs = cfg.FS * out[1]
v, _ = inversion.invert_parabolic_bed(gdir, fs=fs,
glen_a=glen_a,
write=True)
np.testing.assert_allclose(ref_v, v)
inversion.distribute_thickness(gdir, how='per_altitude',
add_nc_name=True)
inversion.distribute_thickness(gdir, how='per_interpolation',
add_slope=False,
add_nc_name=True)
grids_file = gdir.get_filepath('gridded_data')
with netCDF4.Dataset(grids_file) as nc:
t1 = nc.variables['thickness_per_altitude'][:]
t2 = nc.variables['thickness_per_interpolation'][:]
np.testing.assert_allclose(np.sum(t1), np.sum(t2))
if not HAS_NEW_GDAL:
np.testing.assert_allclose(np.max(t1), np.max(t2), atol=30)
def test_invert_hef_nofs(self):
hef_file = get_demo_file('Hintereisferner.shp')
rgidf = gpd.GeoDataFrame.from_file(hef_file)
# loop because for some reason indexing wont work
for index, entity in rgidf.iterrows():
gdir = oggm.GlacierDirectory(entity, base_dir=self.testdir)
gis.define_glacier_region(gdir, entity=entity)
gis.glacier_masks(gdir)
centerlines.compute_centerlines(gdir)
geometry.initialize_flowlines(gdir)
geometry.catchment_area(gdir)
geometry.catchment_width_geom(gdir)
geometry.catchment_width_correction(gdir)
climate.distribute_climate_data([gdir])
climate.mu_candidates(gdir, div_id=0)
hef_file = get_demo_file('mbdata_RGI40-11.00897.csv')
mbdf = pd.read_csv(hef_file).set_index('YEAR')
t_star, bias = climate.t_star_from_refmb(gdir, mbdf['ANNUAL_BALANCE'])
t_star = t_star[-1]
bias = bias[-1]
climate.local_mustar_apparent_mb(gdir, tstar=t_star, bias=bias)
# OK. Values from Fischer and Kuhn 2013
# Area: 8.55
# meanH = 67+-7
# Volume = 0.573+-0.063
# maxH = 242+-13
inversion.prepare_for_inversion(gdir)
ref_v = 0.573 * 1e9
def to_optimize(x):
glen_a = cfg.A * x[0]
fs = 0.
v, _ = inversion.invert_parabolic_bed(gdir, fs=fs, glen_a=glen_a)
return (v - ref_v)**2
import scipy.optimize as optimization
out = optimization.minimize(to_optimize, [1],
bounds=((0.00001, 100000), ),
tol=1e-4)['x']
self.assertTrue(out[0] > 0.1)
self.assertTrue(out[0] < 10)
glen_a = cfg.A * out[0]
fs = 0.
v, _ = inversion.invert_parabolic_bed(gdir,
fs=fs,
glen_a=glen_a,
write=True)
np.testing.assert_allclose(ref_v, v)
lens = [
len(gdir.read_pickle('centerlines', div_id=i)) for i in [1, 2, 3]
]
pid = np.argmax(lens) + 1
cls = gdir.read_pickle('inversion_output', div_id=pid)
fls = gdir.read_pickle('inversion_flowlines', div_id=pid)
maxs = 0.
for cl, fl in zip(cls, fls):
thick = cl['thick']
_max = np.max(thick)
if _max > maxs:
maxs = _max
atol = 30 if HAS_NEW_GDAL else 10
np.testing.assert_allclose(242, maxs, atol=atol)
# check that its not tooo sensitive to the dx
cfg.PARAMS['flowline_dx'] = 1.
geometry.initialize_flowlines(gdir)
geometry.catchment_area(gdir)
geometry.catchment_width_geom(gdir)
geometry.catchment_width_correction(gdir)
climate.distribute_climate_data([gdir])
climate.mu_candidates(gdir, div_id=0)
hef_file = get_demo_file('mbdata_RGI40-11.00897.csv')
mbdf = pd.read_csv(hef_file).set_index('YEAR')
t_star, bias = climate.t_star_from_refmb(gdir, mbdf['ANNUAL_BALANCE'])
t_star = t_star[-1]
bias = bias[-1]
climate.local_mustar_apparent_mb(gdir, tstar=t_star, bias=bias)
inversion.prepare_for_inversion(gdir)
v, _ = inversion.invert_parabolic_bed(gdir,
fs=fs,
glen_a=glen_a,
write=True)
np.testing.assert_allclose(ref_v, v, rtol=0.02)
cls = gdir.read_pickle('inversion_output', div_id=pid)
maxs = 0.
for cl in cls:
thick = cl['thick']
_max = np.max(thick)
if _max > maxs:
maxs = _max
np.testing.assert_allclose(242, maxs, atol=atol)
def test_mb_climate(self):
hef_file = get_demo_file('Hintereisferner.shp')
entity = gpd.GeoDataFrame.from_file(hef_file).iloc[0]
gdirs = []
gdir = oggm.GlacierDirectory(entity, base_dir=self.testdir)
gis.define_glacier_region(gdir, entity=entity)
gdirs.append(gdir)
climate.distribute_climate_data(gdirs)
with netCDF4.Dataset(get_demo_file('histalp_merged_hef.nc')) as nc_r:
ref_h = nc_r.variables['hgt'][1, 1]
ref_p = nc_r.variables['prcp'][:, 1, 1]
ref_p *= cfg.PARAMS['prcp_scaling_factor']
ref_t = nc_r.variables['temp'][:, 1, 1]
ref_t = np.where(ref_t < 0, 0, ref_t)
hgts = np.array([ref_h, ref_h, -8000, 8000])
time, temp, prcp = climate.mb_climate_on_height(gdir, hgts)
ref_nt = 202 * 12
self.assertTrue(len(time) == ref_nt)
self.assertTrue(temp.shape == (4, ref_nt))
self.assertTrue(prcp.shape == (4, ref_nt))
np.testing.assert_allclose(temp[0, :], ref_t)
np.testing.assert_allclose(temp[0, :], temp[1, :])
np.testing.assert_allclose(prcp[0, :], prcp[1, :])
np.testing.assert_allclose(prcp[3, :], ref_p)
np.testing.assert_allclose(prcp[2, :], ref_p * 0)
np.testing.assert_allclose(temp[3, :], ref_p * 0)
yr = [1802, 1802]
time, temp, prcp = climate.mb_climate_on_height(gdir,
hgts,
year_range=yr)
ref_nt = 1 * 12
self.assertTrue(len(time) == ref_nt)
self.assertTrue(temp.shape == (4, ref_nt))
self.assertTrue(prcp.shape == (4, ref_nt))
np.testing.assert_allclose(temp[0, :], ref_t[0:12])
np.testing.assert_allclose(temp[0, :], temp[1, :])
np.testing.assert_allclose(prcp[0, :], prcp[1, :])
np.testing.assert_allclose(prcp[3, :], ref_p[0:12])
np.testing.assert_allclose(prcp[2, :], ref_p[0:12] * 0)
np.testing.assert_allclose(temp[3, :], ref_p[0:12] * 0)
yr = [1803, 1804]
time, temp, prcp = climate.mb_climate_on_height(gdir,
hgts,
year_range=yr)
ref_nt = 2 * 12
self.assertTrue(len(time) == ref_nt)
self.assertTrue(temp.shape == (4, ref_nt))
self.assertTrue(prcp.shape == (4, ref_nt))
np.testing.assert_allclose(temp[0, :], ref_t[12:36])
np.testing.assert_allclose(temp[0, :], temp[1, :])
np.testing.assert_allclose(prcp[0, :], prcp[1, :])
np.testing.assert_allclose(prcp[3, :], ref_p[12:36])
np.testing.assert_allclose(prcp[2, :], ref_p[12:36] * 0)
np.testing.assert_allclose(temp[3, :], ref_p[12:36] * 0)
