def setup_cache(self):
utils.mkdir(self.testdir, reset=True)
self.cfg_init()
hef_file = get_demo_file('Hintereisferner_RGI5.shp')
entity = gpd.read_file(hef_file).iloc[0]
gdir = oggm.GlacierDirectory(entity, base_dir=self.testdir)
tasks.define_glacier_region(gdir, entity=entity)
tasks.glacier_masks(gdir)
tasks.compute_centerlines(gdir)
tasks.initialize_flowlines(gdir)
tasks.compute_downstream_line(gdir)
tasks.compute_downstream_bedshape(gdir)
tasks.catchment_area(gdir)
tasks.catchment_intersections(gdir)
tasks.catchment_width_geom(gdir)
tasks.catchment_width_correction(gdir)
tasks.process_custom_climate_data(gdir)
tasks.mu_candidates(gdir)
mbdf = gdir.get_ref_mb_data()['ANNUAL_BALANCE']
res = climate.t_star_from_refmb(gdir, mbdf)
tasks.local_mustar(gdir, tstar=res['t_star'], bias=res['bias'])
tasks.apparent_mb(gdir)
tasks.prepare_for_inversion(gdir)
tasks.mass_conservation_inversion(gdir)
return gdir
def setup_cache(self):
setattr(full_workflow.setup_cache, "timeout", 360)
utils.mkdir(self.testdir, reset=True)
self.cfg_init()
entity = gpd.read_file(get_demo_file('01_rgi60_Columbia.shp')).iloc[0]
gdir = oggm.GlacierDirectory(entity, base_dir=self.testdir)
tasks.define_glacier_region(gdir, entity=entity)
tasks.glacier_masks(gdir)
tasks.compute_centerlines(gdir)
tasks.initialize_flowlines(gdir)
tasks.compute_downstream_line(gdir)
tasks.compute_downstream_bedshape(gdir)
tasks.catchment_area(gdir)
tasks.catchment_intersections(gdir)
tasks.catchment_width_geom(gdir)
tasks.catchment_width_correction(gdir)
climate.process_dummy_cru_file(gdir, seed=0)
# Test default k (it overshoots)
df1 = utils.find_inversion_calving(gdir)
# Test with smaller k (it doesn't overshoot)
cfg.PARAMS['k_calving'] = 0.2
df2 = utils.find_inversion_calving(gdir)
return (df1.calving_flux.values, df1.mu_star.values,
df2.calving_flux.values, df2.mu_star.values)
def test_from_dem(self, class_case_dir, monkeypatch):
# Init
cfg.initialize()
cfg.PATHS['working_dir'] = class_case_dir
cfg.PARAMS['border'] = 10
monkeypatch.setattr(
rgitopo, 'DEMS_URL', 'https://cluster.klima.uni-br'
'emen.de/~oggm/test_gdirs/dem'
's_v1/default/')
gd = rgitopo.init_glacier_directories_from_rgitopo(['RGI60-09.01004'])
gd = gd[0]
assert gd.has_file('dem')
assert gd.has_file('dem_source')
assert gd.has_file('outlines')
assert gd.has_file('intersects')
# we can work from here
tasks.glacier_masks(gd)
import geopandas as gpd
import oggm
from oggm import cfg, tasks
from oggm.utils import get_demo_file
# Set up the input data for this example
cfg.initialize()
cfg.PATHS['working_dir'] = oggm.utils.get_temp_dir('oggmcontrib_inv')
cfg.PATHS['dem_file'] = get_demo_file('srtm_oetztal.tif')
cfg.set_intersects_db(get_demo_file('rgi_intersect_oetztal.shp'))
# Glacier directory for Hintereisferner in Austria
entity = gpd.read_file(get_demo_file('Hintereisferner_RGI5.shp')).iloc[0]
gdir = oggm.GlacierDirectory(entity)
# The usual OGGM preprecessing
tasks.define_glacier_region(gdir, entity=entity)
tasks.glacier_masks(gdir)
def test_add_consensus(self, class_case_dir, monkeypatch):
# Init
cfg.initialize()
cfg.PARAMS['use_intersects'] = False
cfg.PATHS['working_dir'] = class_case_dir
cfg.PATHS['dem_file'] = get_demo_file('hef_srtm.tif')
entity = gpd.read_file(get_demo_file('Hintereisferner_RGI5.shp'))
entity['RGIId'] = 'RGI60-11.00897'
gdir = workflow.init_glacier_directories(entity)[0]
tasks.define_glacier_region(gdir)
tasks.glacier_masks(gdir)
ft = utils.get_demo_file('RGI60-11.00897_thickness.tif')
monkeypatch.setattr(utils, 'file_downloader', lambda x: ft)
bedtopo.add_consensus_thickness(gdir)
# Check with rasterio
cfg.add_to_basenames('consensus', 'consensus.tif')
gis.rasterio_to_gdir(gdir, ft, 'consensus', resampling='bilinear')
with xr.open_dataset(gdir.get_filepath('gridded_data')) as ds:
mine = ds.consensus_ice_thickness
with xr.open_rasterio(gdir.get_filepath('consensus')) as ds:
ref = ds.isel(band=0)
# Check area
my_area = np.sum(np.isfinite(mine.data)) * gdir.grid.dx**2
np.testing.assert_allclose(my_area, gdir.rgi_area_m2, rtol=0.07)
rio_area = np.sum(ref.data > 0) * gdir.grid.dx**2
np.testing.assert_allclose(rio_area, gdir.rgi_area_m2, rtol=0.15)
np.testing.assert_allclose(my_area, rio_area, rtol=0.15)
# They are not same:
# - interpolation not 1to1 same especially at borders
# - we preserve total volume
np.testing.assert_allclose(mine.sum(), ref.sum(), rtol=0.01)
assert utils.rmsd(ref, mine) < 2
# Check vol
cdf = pd.read_hdf(utils.get_demo_file('rgi62_itmix_df.h5'))
ref_vol = cdf.loc[gdir.rgi_id].vol_itmix_m3
my_vol = mine.sum() * gdir.grid.dx**2
np.testing.assert_allclose(my_vol, ref_vol)
# Now check the rest of the workflow
# Check that no error when var not there
vn = 'consensus_ice_thickness'
centerlines.elevation_band_flowline(gdir, bin_variables=[vn, 'foo'])
# Check vol
df = pd.read_csv(gdir.get_filepath('elevation_band_flowline'),
index_col=0)
my_vol = (df[vn] * df['area']).sum()
np.testing.assert_allclose(my_vol, ref_vol)
centerlines.fixed_dx_elevation_band_flowline(gdir,
bin_variables=[vn, 'foo'])
fdf = pd.read_csv(gdir.get_filepath('elevation_band_flowline',
filesuffix='_fixed_dx'),
index_col=0)
# Check vol
my_vol = (fdf[vn] * fdf['area_m2']).sum()
np.testing.assert_allclose(my_vol, ref_vol)
def test_repro_to_glacier(self, class_case_dir, monkeypatch):
# Init
cfg.initialize()
cfg.PATHS['working_dir'] = class_case_dir
cfg.PARAMS['use_intersects'] = False
cfg.PATHS['dem_file'] = get_demo_file('dem_Columbia.tif')
cfg.PARAMS['border'] = 10
entity = gpd.read_file(get_demo_file('RGI60-01.10689.shp')).iloc[0]
gdir = oggm.GlacierDirectory(entity)
tasks.define_glacier_region(gdir)
tasks.glacier_masks(gdir)
# use our files
region_files = {
'ALA': {
'vx': get_demo_file('crop_ALA_G0120_0000_vx.tif'),
'vy': get_demo_file('crop_ALA_G0120_0000_vy.tif')
}
}
monkeypatch.setattr(its_live, 'region_files', region_files)
monkeypatch.setattr(utils, 'file_downloader', lambda x: x)
with warnings.catch_warnings():
warnings.filterwarnings("ignore", category=RuntimeWarning)
its_live.velocity_to_gdir(gdir)
with xr.open_dataset(gdir.get_filepath('gridded_data')) as ds:
mask = ds.glacier_mask.data.astype(bool)
vx = ds.obs_icevel_x.where(mask).data
vy = ds.obs_icevel_y.where(mask).data
vel = np.sqrt(vx**2 + vy**2)
assert np.nanmax(vel) > 2900
assert np.nanmin(vel) < 2
# We reproject with rasterio and check no big diff
cfg.BASENAMES['its_live_vx'] = ('its_live_vx.tif', '')
cfg.BASENAMES['its_live_vy'] = ('its_live_vy.tif', '')
gis.rasterio_to_gdir(gdir,
region_files['ALA']['vx'],
'its_live_vx',
resampling='bilinear')
gis.rasterio_to_gdir(gdir,
region_files['ALA']['vy'],
'its_live_vy',
resampling='bilinear')
with xr.open_rasterio(gdir.get_filepath('its_live_vx')) as da:
_vx = da.where(mask).data.squeeze()
with xr.open_rasterio(gdir.get_filepath('its_live_vy')) as da:
_vy = da.where(mask).data.squeeze()
_vel = np.sqrt(_vx**2 + _vy**2)
np.testing.assert_allclose(utils.rmsd(vel[mask], _vel[mask]),
0,
atol=40)
np.testing.assert_allclose(utils.md(vel[mask], _vel[mask]), 0, atol=8)
if DO_PLOT:
import matplotlib.pyplot as plt
smap = salem.Map(gdir.grid.center_grid, countries=False)
smap.set_shapefile(gdir.read_shapefile('outlines'))
with warnings.catch_warnings():
warnings.filterwarnings('ignore', category=RuntimeWarning)
smap.set_topography(gdir.get_filepath('dem'))
vel = np.sqrt(vx**2 + vy**2)
smap.set_data(vel)
smap.set_plot_params(cmap='Blues', vmin=None, vmax=None)
xx, yy = gdir.grid.center_grid.xy_coordinates
xx, yy = smap.grid.transform(xx, yy, crs=gdir.grid.proj)
yy = yy[2::5, 2::5]
xx = xx[2::5, 2::5]
vx = vx[2::5, 2::5]
vy = vy[2::5, 2::5]
f, ax = plt.subplots()
smap.visualize(ax=ax,
title='ITS_LIVE velocity',
cbar_title='m yr-1')
ax.quiver(xx, yy, vx, vy)
plt.show()
from oggm.utils import get_demo_file
from oggm.core.preprocessing.climate import mb_yearly_climate_on_glacier, \
t_star_from_refmb
cfg.initialize()
cfg.PATHS['dem_file'] = get_demo_file('hef_srtm.tif')
cfg.PATHS['wgms_rgi_links'] = get_demo_file('RGI_WGMS_oetztal.csv')
pcp_fac = 2.6
cfg.PARAMS['prcp_scaling_factor'] = pcp_fac
base_dir = os.path.join(os.path.expanduser('~'), 'Climate')
entity = gpd.read_file(get_demo_file('Hintereisferner.shp')).iloc[0]
gdir = oggm.GlacierDirectory(entity, base_dir=base_dir)
tasks.define_glacier_region(gdir, entity=entity)
tasks.glacier_masks(gdir)
tasks.compute_centerlines(gdir)
tasks.compute_centerlines(gdir)
tasks.initialize_flowlines(gdir)
tasks.catchment_area(gdir)
tasks.catchment_width_geom(gdir)
tasks.catchment_width_correction(gdir)
cfg.PATHS['climate_file'] = get_demo_file('histalp_merged_hef.nc')
tasks.process_custom_climate_data(gdir)
tasks.mu_candidates(gdir)
# For plots
mu_yr_clim = gdir.read_pickle('mu_candidates')[pcp_fac]
mbdf = gdir.get_ref_mb_data()
years, temp_yr, prcp_yr = mb_yearly_climate_on_glacier(gdir, pcp_fac, div_id=0)
def setup_cache(self):
setattr(full_workflow.setup_cache, "timeout", 360)
utils.mkdir(self.testdir, reset=True)
self.cfg_init()
entity = gpd.read_file(get_demo_file('01_rgi60_Columbia.shp')).iloc[0]
gdir = oggm.GlacierDirectory(entity, base_dir=self.testdir)
tasks.define_glacier_region(gdir, entity=entity)
tasks.glacier_masks(gdir)
tasks.compute_centerlines(gdir)
tasks.initialize_flowlines(gdir)
tasks.compute_downstream_line(gdir)
tasks.compute_downstream_bedshape(gdir)
tasks.catchment_area(gdir)
tasks.catchment_intersections(gdir)
tasks.catchment_width_geom(gdir)
tasks.catchment_width_correction(gdir)
climate.process_dummy_cru_file(gdir, seed=0)
rho = cfg.PARAMS['ice_density']
i = 0
calving_flux = []
mu_star = []
ite = []
cfg.PARAMS['clip_mu_star'] = False
cfg.PARAMS['min_mu_star'] = 0 # default is now 1
while i < 12:
# Calculates a calving flux from model output
if i == 0:
# First call we set to zero (not very necessary,
# this first loop could be removed)
f_calving = 0
elif i == 1:
# Second call we set a very small positive calving
f_calving = utils.calving_flux_from_depth(gdir, water_depth=1)
elif cfg.PARAMS['clip_mu_star']:
# If we have to clip mu the calving becomes the real flux
fl = gdir.read_pickle('inversion_flowlines')[-1]
f_calving = fl.flux[-1] * (gdir.grid.dx**2) * 1e-9 / rho
else:
# Otherwise it is parameterized
f_calving = utils.calving_flux_from_depth(gdir)
# Give it back to the inversion and recompute
gdir.inversion_calving_rate = f_calving
# At this step we might raise a MassBalanceCalibrationError
mu_is_zero = False
try:
climate.local_t_star(gdir)
df = gdir.read_json('local_mustar')
except MassBalanceCalibrationError as e:
assert 'mu* out of specified bounds' in str(e)
# When this happens we clip mu* to zero and store the
# bad value (just for plotting)
cfg.PARAMS['clip_mu_star'] = True
df = gdir.read_json('local_mustar')
df['mu_star_glacierwide'] = float(str(e).split(':')[-1])
climate.local_t_star(gdir)
climate.mu_star_calibration(gdir)
tasks.prepare_for_inversion(gdir, add_debug_var=True)
v_inv, _ = tasks.mass_conservation_inversion(gdir)
# Store the data
calving_flux = np.append(calving_flux, f_calving)
mu_star = np.append(mu_star, df['mu_star_glacierwide'])
ite = np.append(ite, i)
# Do we have to do another_loop?
if i > 0:
avg_one = np.mean(calving_flux[-4:])
avg_two = np.mean(calving_flux[-5:-1])
difference = abs(avg_two - avg_one)
conv = (difference < 0.05 * avg_two or calving_flux[-1] == 0
or calving_flux[-1] == calving_flux[-2])
if mu_is_zero or conv:
break
i += 1
assert i < 8
assert calving_flux[-1] < np.max(calving_flux)
assert calving_flux[-1] > 2
assert mu_star[-1] == 0
mbmod = massbalance.MultipleFlowlineMassBalance
mb = mbmod(gdir,
use_inversion_flowlines=True,
mb_model_class=massbalance.ConstantMassBalance,
bias=0)
flux_mb = (mb.get_specific_mb() * gdir.rgi_area_m2) * 1e-9 / rho
np.testing.assert_allclose(flux_mb, calving_flux[-1], atol=0.001)
return calving_flux, mu_star
cfg.PARAMS['fixed_dx'] = 40
cfg.PARAMS['border'] = 10
entity = gpd.read_file(get_demo_file('Hintereisferner.shp'))
hef = workflow.init_glacier_regions(entity, reset=False)[0]
input_shp = hef.get_filepath('outlines', div_id=0)
input_dem = hef.get_filepath('dem', div_id=0)
# filter options
f_area = False
f_alt_range = True
f_perc_alt_range = True
# set paths to python 2.7 and to the partitioning package
python = 'path to python 2.7'
project = 'path to the partitioning package'
script = os.path.join(project, 'partitioning/examples/run_divides.py')
os.system(python + ' ' + script + ' ' + input_shp + ' ' + input_dem + ' ' +
str(f_area) + ' ' + str(f_alt_range) + ' ' +
str(f_perc_alt_range))
print('Hintereisferner is divided into', hef.n_divides, 'parts.')
tasks.glacier_masks(hef)
tasks.compute_centerlines(hef)
graphics.plot_centerlines(hef)
plt.show()