def test_auto_topo(self):
# Test for combine
fdem, src = utils.get_topo_file([6, 14], [41, 41])
self.assertEqual(src, 'SRTM')
self.assertEqual(len(fdem), 2)
for fp in fdem:
self.assertTrue(os.path.exists(fp))
fdem, src = utils.get_topo_file([-143, -131], [61, 61])
self.assertEqual(src, 'DEM3')
self.assertEqual(len(fdem), 3)
for fp in fdem:
self.assertTrue(os.path.exists(fp))
def test_auto_topo(self):
# Test for combine
fdem, src = utils.get_topo_file([6, 14], [41, 41])
self.assertEqual(src, 'SRTM')
self.assertEqual(len(fdem), 2)
for fp in fdem:
self.assertTrue(os.path.exists(fp))
fdem, src = utils.get_topo_file([-143, -131], [61, 61])
self.assertEqual(src, 'DEM3')
self.assertEqual(len(fdem), 3)
for fp in fdem:
self.assertTrue(os.path.exists(fp))
def test_dem3(self):
def down_check(url, cache_name=None, reset=False):
expected = 'http://viewfinderpanoramas.org/dem3/T10.zip'
self.assertEqual(url, expected)
return self.dem3_testfile
with FakeDownloadManager('_progress_urlretrieve', down_check):
of, source = utils.get_topo_file([-120.2, -120.2], [76.8, 76.8])
assert os.path.exists(of[0])
assert source == 'DEM3'
def test_ramp(self):
def down_check(url):
expected = 'AntarcticDEM_wgs84.tif'
self.assertEqual(url, expected)
return 'yo'
with FakeDownloadManager('_download_alternate_topo_file', down_check):
of, source = utils.get_topo_file([-120.2, -120.2], [-88, -88],
rgi_region=19)
assert of[0] == 'yo'
assert source == 'RAMP'
def test_gimp(self):
def down_check(url):
expected = 'gimpdem_90m.tif'
self.assertEqual(url, expected)
return 'yo'
with FakeDownloadManager('_download_alternate_topo_file', down_check):
of, source = utils.get_topo_file([-120.2, -120.2], [-88, -88],
rgi_region=5)
assert of[0] == 'yo'
assert source == 'GIMP'
def test_srtm(self):
# Make a fake topo file
tf = make_fake_zipdir(os.path.join(self.dldir, 'srtm_39_03'),
fakefile='srtm_39_03.tif')
def down_check(url, cache_name=None, reset=False):
expected = 'http://droppr.org/srtm/v4.1/6_5x5_TIFs/srtm_39_03.zip'
self.assertEqual(url, expected)
return tf
with FakeDownloadManager('_progress_urlretrieve', down_check):
of, source = utils.get_topo_file([11.3, 11.3], [47.1, 47.1])
assert os.path.exists(of[0])
assert source == 'SRTM'
def test_srtm(self):
# Make a fake topo file
tf = make_fake_zipdir(os.path.join(self.dldir, 'srtm_39_03'),
fakefile='srtm_39_03.tif')
def down_check(url, cache_name=None, reset=False):
expected = ('http://srtm.csi.cgiar.org/SRT-ZIP/SRTM_V41/'
'SRTM_Data_GeoTiff/srtm_39_03.zip')
self.assertEqual(url, expected)
return tf
with FakeDownloadManager('_progress_urlretrieve', down_check):
of, source = utils.get_topo_file([11.3, 11.3], [47.1, 47.1])
assert os.path.exists(of[0])
assert source == 'SRTM'
def test_aster(self):
# Make a fake topo file
tf = make_fake_zipdir(os.path.join(self.dldir, 'ASTGTM2_S88W121'),
fakefile='ASTGTM2_S88W121_dem.tif')
def down_check(url):
expected = 'ASTGTM_V2/UNIT_S90W125/ASTGTM2_S88W121.zip'
self.assertEqual(url, expected)
return tf
with FakeDownloadManager('_aws_file_download_unlocked', down_check):
of, source = utils.get_topo_file([-120.2, -120.2], [-88, -88],
source='ASTER')
assert os.path.exists(of[0])
assert source == 'ASTER'
def test_iceland(self):
fp, z = utils.get_topo_file([-20, -20], [65, 65])
self.assertTrue(os.path.exists(fp[0]))
def test_gimp(self):
fp, z = utils.get_topo_file([], [], rgi_region=5)
self.assertTrue(os.path.exists(fp[0]))
self.assertEqual(z, 'GIMP')
def test_gimp(self):
fp, z = utils.get_topo_file([], [], rgi_region=5)
self.assertTrue(os.path.exists(fp[0]))
self.assertEqual(z, 'GIMP')
def test_iceland(self):
fp, z = utils.get_topo_file([-20, -20], [65, 65])
self.assertTrue(os.path.exists(fp))
def test_gimp(self):
fp, z = utils.get_topo_file([], [], region=5)
self.assertTrue(os.path.exists(fp))
def define_glacier_region(gdir, entity=None):
"""Very first task: define the glacier's local grid.
Defines the local projection (Transverse Mercator), centered on the
glacier. There is some options to set the resolution of the local grid.
It can be adapted depending on the size of the glacier with::
dx (m) = d1 * AREA (km) + d2 ; clipped to dmax
or be set to a fixed value. See ``params.cfg`` for setting these options.
Default values of the adapted mode lead to a resolution of 50 m for
Hintereisferner, which is approx. 8 km2 large.
After defining the grid, the topography and the outlines of the glacier
are transformed into the local projection. The default interpolation for
the topography is `cubic`.
Parameters
----------
gdir : :py:class:`oggm.GlacierDirectory`
where to write the data
entity : geopandas.GeoSeries
the glacier geometry to process
"""
# Make a local glacier map
proj_params = dict(name='tmerc', lat_0=0., lon_0=gdir.cenlon,
k=0.9996, x_0=0, y_0=0, datum='WGS84')
proj4_str = "+proj={name} +lat_0={lat_0} +lon_0={lon_0} +k={k} " \
"+x_0={x_0} +y_0={y_0} +datum={datum}".format(**proj_params)
proj_in = pyproj.Proj("+init=EPSG:4326", preserve_units=True)
proj_out = pyproj.Proj(proj4_str, preserve_units=True)
project = partial(pyproj.transform, proj_in, proj_out)
# transform geometry to map
geometry = shapely.ops.transform(project, entity['geometry'])
geometry = multi_to_poly(geometry, gdir=gdir)
xx, yy = geometry.exterior.xy
# Save transformed geometry to disk
entity = entity.copy()
entity['geometry'] = geometry
# Avoid fiona bug: https://github.com/Toblerity/Fiona/issues/365
for k, s in entity.iteritems():
if type(s) in [np.int32, np.int64]:
entity[k] = int(s)
towrite = gpd.GeoDataFrame(entity).T
towrite.crs = proj4_str
# Delete the source before writing
if 'DEM_SOURCE' in towrite:
del towrite['DEM_SOURCE']
# Define glacier area to use
area = entity['Area']
# Do we want to use the RGI area or ours?
if not cfg.PARAMS['use_rgi_area']:
area = geometry.area * 1e-6
entity['Area'] = area
towrite['Area'] = area
# Write shapefile
gdir.write_shapefile(towrite, 'outlines')
# Also transform the intersects if necessary
gdf = cfg.PARAMS['intersects_gdf']
if len(gdf) > 0:
gdf = gdf.loc[((gdf.RGIId_1 == gdir.rgi_id) |
(gdf.RGIId_2 == gdir.rgi_id))]
if len(gdf) > 0:
gdf = salem.transform_geopandas(gdf, to_crs=proj_out)
if hasattr(gdf.crs, 'srs'):
# salem uses pyproj
gdf.crs = gdf.crs.srs
gdir.write_shapefile(gdf, 'intersects')
else:
# Sanity check
if cfg.PARAMS['use_intersects']:
raise InvalidParamsError('You seem to have forgotten to set the '
'intersects file for this run. OGGM '
'works better with such a file. If you '
'know what your are doing, set '
"cfg.PARAMS['use_intersects'] = False to "
"suppress this error.")
# 6. choose a spatial resolution with respect to the glacier area
dxmethod = cfg.PARAMS['grid_dx_method']
if dxmethod == 'linear':
dx = np.rint(cfg.PARAMS['d1'] * area + cfg.PARAMS['d2'])
elif dxmethod == 'square':
dx = np.rint(cfg.PARAMS['d1'] * np.sqrt(area) + cfg.PARAMS['d2'])
elif dxmethod == 'fixed':
dx = np.rint(cfg.PARAMS['fixed_dx'])
else:
raise InvalidParamsError('grid_dx_method not supported: {}'
.format(dxmethod))
# Additional trick for varying dx
if dxmethod in ['linear', 'square']:
dx = np.clip(dx, cfg.PARAMS['d2'], cfg.PARAMS['dmax'])
log.debug('(%s) area %.2f km, dx=%.1f', gdir.rgi_id, area, dx)
# Safety check
border = cfg.PARAMS['border']
if border > 1000:
raise InvalidParamsError("You have set a cfg.PARAMS['border'] value "
"of {}. ".format(cfg.PARAMS['border']) +
'This a very large value, which is '
'currently not supported in OGGM.')
# For tidewater glaciers we force border to 10
if gdir.is_tidewater and cfg.PARAMS['clip_tidewater_border']:
border = 10
# Corners, incl. a buffer of N pix
ulx = np.min(xx) - border * dx
lrx = np.max(xx) + border * dx
uly = np.max(yy) + border * dx
lry = np.min(yy) - border * dx
# n pixels
nx = np.int((lrx - ulx) / dx)
ny = np.int((uly - lry) / dx)
# Back to lon, lat for DEM download/preparation
tmp_grid = salem.Grid(proj=proj_out, nxny=(nx, ny), x0y0=(ulx, uly),
dxdy=(dx, -dx), pixel_ref='corner')
minlon, maxlon, minlat, maxlat = tmp_grid.extent_in_crs(crs=salem.wgs84)
# Open DEM
source = entity.DEM_SOURCE if hasattr(entity, 'DEM_SOURCE') else None
dem_list, dem_source = get_topo_file((minlon, maxlon), (minlat, maxlat),
rgi_region=gdir.rgi_region,
rgi_subregion=gdir.rgi_subregion,
source=source)
log.debug('(%s) DEM source: %s', gdir.rgi_id, dem_source)
log.debug('(%s) N DEM Files: %s', gdir.rgi_id, len(dem_list))
# A glacier area can cover more than one tile:
if len(dem_list) == 1:
dem_dss = [rasterio.open(dem_list[0])] # if one tile, just open it
dem_data = rasterio.band(dem_dss[0], 1)
if LooseVersion(rasterio.__version__) >= LooseVersion('1.0'):
src_transform = dem_dss[0].transform
else:
src_transform = dem_dss[0].affine
else:
dem_dss = [rasterio.open(s) for s in dem_list] # list of rasters
dem_data, src_transform = merge_tool(dem_dss) # merged rasters
# Use Grid properties to create a transform (see rasterio cookbook)
dst_transform = rasterio.transform.from_origin(
ulx, uly, dx, dx # sign change (2nd dx) is done by rasterio.transform
)
# Set up profile for writing output
profile = dem_dss[0].profile
profile.update({
'crs': proj4_str,
'transform': dst_transform,
'width': nx,
'height': ny
})
# Could be extended so that the cfg file takes all Resampling.* methods
if cfg.PARAMS['topo_interp'] == 'bilinear':
resampling = Resampling.bilinear
elif cfg.PARAMS['topo_interp'] == 'cubic':
resampling = Resampling.cubic
else:
raise InvalidParamsError('{} interpolation not understood'
.format(cfg.PARAMS['topo_interp']))
dem_reproj = gdir.get_filepath('dem')
profile.pop('blockxsize', None)
profile.pop('blockysize', None)
profile.pop('compress', None)
nodata = dem_dss[0].meta.get('nodata', None)
if source == 'TANDEM' and nodata is None:
# badly tagged geotiffs, let's do it ourselves
nodata = -32767
with rasterio.open(dem_reproj, 'w', **profile) as dest:
dst_array = np.empty((ny, nx), dtype=dem_dss[0].dtypes[0])
reproject(
# Source parameters
source=dem_data,
src_crs=dem_dss[0].crs,
src_transform=src_transform,
src_nodata=nodata,
# Destination parameters
destination=dst_array,
dst_transform=dst_transform,
dst_crs=proj4_str,
dst_nodata=nodata,
# Configuration
resampling=resampling)
dest.write(dst_array, 1)
for dem_ds in dem_dss:
dem_ds.close()
# Glacier grid
x0y0 = (ulx+dx/2, uly-dx/2) # To pixel center coordinates
glacier_grid = salem.Grid(proj=proj_out, nxny=(nx, ny), dxdy=(dx, -dx),
x0y0=x0y0)
glacier_grid.to_json(gdir.get_filepath('glacier_grid'))
# Write DEM source info
gdir.add_to_diagnostics('dem_source', dem_source)
source_txt = DEM_SOURCE_INFO.get(dem_source, dem_source)
with open(gdir.get_filepath('dem_source'), 'w') as fw:
fw.write(source_txt)
fw.write('\n\n')
fw.write('# Data files\n\n')
for fname in dem_list:
fw.write('{}\n'.format(os.path.basename(fname)))
def define_nonrgi_glacier_region(gdir: NonRGIGlacierDirectory):
"""
Very first task: define the glacier's local grid.
Defines the local projection (Transverse Mercator), centered on the
glacier. The resolution of the local grid is dx.
After defining the grid, the topography is transformed into the local
projection. The default interpolation for the topography is `cubic`.
Parameters
----------
gdir : :py:class:`oggm.NonRGIGlacierDirectory`
where to write the data
dx : float
grid spacing
"""
xx, yy = gdir.extent_ll
dx = gdir.case.dx
# Make a local glacier map
proj_params = dict(name='tmerc',
lat_0=0.,
lon_0=gdir.cenlon,
k=0.9996,
x_0=0,
y_0=0,
datum='WGS84')
proj4_str = "+proj={name} +lat_0={lat_0} +lon_0={lon_0} +k={k} " \
"+x_0={x_0} +y_0={y_0} +datum={datum}".format(**proj_params)
# proj_in = pyproj.Proj("+init=EPSG:4326", preserve_units=True)
proj_out = pyproj.Proj(proj4_str, preserve_units=True)
merc_xx, merc_yy = salem.transform_proj(salem.wgs84, proj_out, xx, yy)
# Corners, incl. a buffer of N pix
ulx = np.min(merc_xx)
lrx = np.max(merc_xx)
uly = np.max(merc_yy)
lry = np.min(merc_yy)
# n pixels
nx = np.int((lrx - ulx) / dx)
ny = np.int((uly - lry) / dx)
# Back to lon, lat for DEM download/preparation
tmp_grid = salem.Grid(proj=proj_out,
nxny=(nx, ny),
x0y0=(ulx, uly),
dxdy=(dx, -dx),
pixel_ref='corner')
minlon, maxlon, minlat, maxlat = tmp_grid.extent_in_crs(crs=salem.wgs84)
dem_list, dem_source = get_topo_file((minlon, maxlon), (minlat, maxlat),
rgi_region=None,
rgi_subregion=None,
source='DEM3')
log.debug('(%s) DEM source: %s', gdir.name, dem_source)
# A glacier area can cover more than one tile:
if len(dem_list) == 1:
dem_dss = [rasterio.open(dem_list[0])] # if one tile, just open it
dem_data = rasterio.band(dem_dss[0], 1)
if LooseVersion(rasterio.__version__) >= LooseVersion('1.0'):
src_transform = dem_dss[0].transform
else:
src_transform = dem_dss[0].affine
else:
dem_dss = [rasterio.open(s) for s in dem_list] # list of rasters
dem_data, src_transform = merge_tool(dem_dss) # merged rasters
# Use Grid properties to create a transform (see rasterio cookbook)
dst_transform = rasterio.transform.from_origin(
ulx,
uly,
dx,
dx # sign change (2nd dx) is done by rasterio.transform
)
# Set up profile for writing output
profile = dem_dss[0].profile
profile.update({
'crs': proj4_str,
'transform': dst_transform,
'width': nx,
'height': ny
})
# Could be extended so that the cfg file takes all Resampling.* methods
if cfg.PARAMS['topo_interp'] == 'bilinear':
resampling = Resampling.bilinear
elif cfg.PARAMS['topo_interp'] == 'cubic':
resampling = Resampling.cubic
else:
raise ValueError('{} interpolation not understood'.format(
cfg.PARAMS['topo_interp']))
dem_reproj = gdir.get_filepath('dem')
with rasterio.open(dem_reproj, 'w', **profile) as dest:
dst_array = np.empty((ny, nx), dtype=dem_dss[0].dtypes[0])
reproject(
# Source parameters
source=dem_data,
src_crs=dem_dss[0].crs,
src_transform=src_transform,
# Destination parameters
destination=dst_array,
dst_transform=dst_transform,
dst_crs=proj4_str,
# Configuration
resampling=resampling)
# TODO: ugly
if gdir.case.name == 'Borden Peninsula':
print('Anti icepatch used')
dst_array[32, 27] = gdir.case.ela_h - 5
dst_array[:2, -4:] = gdir.case.ela_h - 5
if gdir.case.name == 'Borden Peninsula HR':
print('Anti icepatch HR used')
dst_array[-21:-16, 32:38] = gdir.case.ela_h - 5
dst_array[-8:-2, 88:98] = gdir.case.ela_h - 5
dst_array[:-109, 120:] = gdir.case.ela_h - 5
dest.write(dst_array, 1)
for dem_ds in dem_dss:
dem_ds.close()
# Glacier grid
x0y0 = (ulx + dx / 2, uly - dx / 2) # To pixel center coordinates
glacier_grid = salem.Grid(proj=proj_out,
nxny=(nx, ny),
dxdy=(dx, -dx),
x0y0=x0y0)
glacier_grid.to_json(gdir.get_filepath('glacier_grid'))
# Write DEM source info
source_txt = DEM_SOURCE_INFO.get(dem_source, dem_source)
with open(gdir.get_filepath('dem_source'), 'w') as fw:
fw.write(source_txt)
rgi_df = utils.get_rgi_glacier_entities([rgi_id])
# set name, since not delivered with RGI
if rgi_df.loc[int(rgi_id[-5:]) - 1, 'Name'] is None:
rgi_df.loc[int(rgi_id[-5:]) - 1, 'Name'] = glacier_name
# select single entry
rgi_entity = rgi_df.iloc[0]
## GlacierDirectory
# specify the working directory and define the glacier directory
cfg.PATHS['working_dir'] = wdir
gdir = oggm.GlacierDirectory(rgi_entity)
# DEM and GIS tasks
# get the path to the DEM file (will download if necessary)
dem = utils.get_topo_file(gdir.cenlon, gdir.cenlat)
# set path in config file
cfg.PATHS['dem_file'] = dem[0][0]
cfg.PARAMS['border'] = 10
cfg.PARAMS['use_intersects'] = False
# run GIS tasks
gis.define_glacier_region(gdir, entity=rgi_entity)
gis.glacier_masks(gdir)
## Climate data
# using HistAlp
cfg.PARAMS['baseline_climate'] = 'HISTALP'
# climate records before 1850 are hardly reliable, which is not so drastic for
# qualitative experiments (could be driven with random climate anyway)
# cfg.PARAMS['baseline_y0'] = 1850
# change hyper parameters for HistAlp
def define_glacier_region(gdir, entity=None):
"""Very first task: define the glacier's local grid.
Defines the local projection (Transverse Mercator), centered on the
glacier. There is some options to set the resolution of the local grid.
It can be adapted depending on the size of the glacier with::
dx (m) = d1 * AREA (km) + d2 ; clipped to dmax
or be set to a fixed value. See ``params.cfg`` for setting these options.
Default values of the adapted mode lead to a resolution of 50 m for
Hintereisferner, which is approx. 8 km2 large.
After defining the grid, the topography and the outlines of the glacier
are transformed into the local projection. The default interpolation for
the topography is `cubic`.
Parameters
----------
gdir : :py:class:`oggm.GlacierDirectory`
where to write the data
entity : geopandas.GeoSeries
the glacier geometry to process
"""
# Make a local glacier map
proj_params = dict(name='tmerc',
lat_0=0.,
lon_0=gdir.cenlon,
k=0.9996,
x_0=0,
y_0=0,
datum='WGS84')
proj4_str = "+proj={name} +lat_0={lat_0} +lon_0={lon_0} +k={k} " \
"+x_0={x_0} +y_0={y_0} +datum={datum}".format(**proj_params)
proj_in = pyproj.Proj("+init=EPSG:4326", preserve_units=True)
proj_out = pyproj.Proj(proj4_str, preserve_units=True)
project = partial(pyproj.transform, proj_in, proj_out)
# transform geometry to map
geometry = shapely.ops.transform(project, entity['geometry'])
geometry = multi_to_poly(geometry, gdir=gdir)
xx, yy = geometry.exterior.xy
# Save transformed geometry to disk
entity = entity.copy()
entity['geometry'] = geometry
# Avoid fiona bug: https://github.com/Toblerity/Fiona/issues/365
for k, s in entity.iteritems():
if type(s) in [np.int32, np.int64]:
entity[k] = int(s)
towrite = gpd.GeoDataFrame(entity).T
towrite.crs = proj4_str
# Delete the source before writing
if 'DEM_SOURCE' in towrite:
del towrite['DEM_SOURCE']
# Define glacier area to use
area = entity['Area']
# Do we want to use the RGI area or ours?
if not cfg.PARAMS['use_rgi_area']:
area = geometry.area * 1e-6
entity['Area'] = area
towrite['Area'] = area
# Write shapefile
gdir.write_shapefile(towrite, 'outlines')
# Also transform the intersects if necessary
gdf = cfg.PARAMS['intersects_gdf']
if len(gdf) > 0:
gdf = gdf.loc[((gdf.RGIId_1 == gdir.rgi_id) |
(gdf.RGIId_2 == gdir.rgi_id))]
if len(gdf) > 0:
gdf = salem.transform_geopandas(gdf, to_crs=proj_out)
if hasattr(gdf.crs, 'srs'):
# salem uses pyproj
gdf.crs = gdf.crs.srs
gdir.write_shapefile(gdf, 'intersects')
else:
# Sanity check
if cfg.PARAMS['use_intersects']:
raise InvalidParamsError('You seem to have forgotten to set the '
'intersects file for this run. OGGM '
'works better with such a file. If you '
'know what your are doing, set '
"cfg.PARAMS['use_intersects'] = False to "
"suppress this error.")
# 6. choose a spatial resolution with respect to the glacier area
dxmethod = cfg.PARAMS['grid_dx_method']
if dxmethod == 'linear':
dx = np.rint(cfg.PARAMS['d1'] * area + cfg.PARAMS['d2'])
elif dxmethod == 'square':
dx = np.rint(cfg.PARAMS['d1'] * np.sqrt(area) + cfg.PARAMS['d2'])
elif dxmethod == 'fixed':
dx = np.rint(cfg.PARAMS['fixed_dx'])
else:
raise InvalidParamsError(
'grid_dx_method not supported: {}'.format(dxmethod))
# Additional trick for varying dx
if dxmethod in ['linear', 'square']:
dx = np.clip(dx, cfg.PARAMS['d2'], cfg.PARAMS['dmax'])
log.debug('(%s) area %.2f km, dx=%.1f', gdir.rgi_id, area, dx)
# Safety check
border = cfg.PARAMS['border']
if border > 1000:
raise InvalidParamsError("You have set a cfg.PARAMS['border'] value "
"of {}. ".format(cfg.PARAMS['border']) +
'This a very large value, which is '
'currently not supported in OGGM.')
# For tidewater glaciers we force border to 10
if gdir.is_tidewater and cfg.PARAMS['clip_tidewater_border']:
border = 10
# Corners, incl. a buffer of N pix
ulx = np.min(xx) - border * dx
lrx = np.max(xx) + border * dx
uly = np.max(yy) + border * dx
lry = np.min(yy) - border * dx
# n pixels
nx = np.int((lrx - ulx) / dx)
ny = np.int((uly - lry) / dx)
# Back to lon, lat for DEM download/preparation
tmp_grid = salem.Grid(proj=proj_out,
nxny=(nx, ny),
x0y0=(ulx, uly),
dxdy=(dx, -dx),
pixel_ref='corner')
minlon, maxlon, minlat, maxlat = tmp_grid.extent_in_crs(crs=salem.wgs84)
# Open DEM
source = entity.DEM_SOURCE if hasattr(entity, 'DEM_SOURCE') else None
dem_list, dem_source = get_topo_file((minlon, maxlon), (minlat, maxlat),
rgi_region=gdir.rgi_region,
rgi_subregion=gdir.rgi_subregion,
source=source)
log.debug('(%s) DEM source: %s', gdir.rgi_id, dem_source)
log.debug('(%s) N DEM Files: %s', gdir.rgi_id, len(dem_list))
# A glacier area can cover more than one tile:
if len(dem_list) == 1:
dem_dss = [rasterio.open(dem_list[0])] # if one tile, just open it
dem_data = rasterio.band(dem_dss[0], 1)
if LooseVersion(rasterio.__version__) >= LooseVersion('1.0'):
src_transform = dem_dss[0].transform
else:
src_transform = dem_dss[0].affine
else:
dem_dss = [rasterio.open(s) for s in dem_list] # list of rasters
dem_data, src_transform = merge_tool(dem_dss) # merged rasters
# Use Grid properties to create a transform (see rasterio cookbook)
dst_transform = rasterio.transform.from_origin(
ulx,
uly,
dx,
dx # sign change (2nd dx) is done by rasterio.transform
)
# Set up profile for writing output
profile = dem_dss[0].profile
profile.update({
'crs': proj4_str,
'transform': dst_transform,
'width': nx,
'height': ny
})
# Could be extended so that the cfg file takes all Resampling.* methods
if cfg.PARAMS['topo_interp'] == 'bilinear':
resampling = Resampling.bilinear
elif cfg.PARAMS['topo_interp'] == 'cubic':
resampling = Resampling.cubic
else:
raise InvalidParamsError('{} interpolation not understood'.format(
cfg.PARAMS['topo_interp']))
dem_reproj = gdir.get_filepath('dem')
profile.pop('blockxsize', None)
profile.pop('blockysize', None)
profile.pop('compress', None)
nodata = dem_dss[0].meta.get('nodata', None)
if source == 'TANDEM' and nodata is None:
# badly tagged geotiffs, let's do it ourselves
nodata = -32767
with rasterio.open(dem_reproj, 'w', **profile) as dest:
dst_array = np.empty((ny, nx), dtype=dem_dss[0].dtypes[0])
reproject(
# Source parameters
source=dem_data,
src_crs=dem_dss[0].crs,
src_transform=src_transform,
src_nodata=nodata,
# Destination parameters
destination=dst_array,
dst_transform=dst_transform,
dst_crs=proj4_str,
dst_nodata=nodata,
# Configuration
resampling=resampling)
dest.write(dst_array, 1)
for dem_ds in dem_dss:
dem_ds.close()
# Glacier grid
x0y0 = (ulx + dx / 2, uly - dx / 2) # To pixel center coordinates
glacier_grid = salem.Grid(proj=proj_out,
nxny=(nx, ny),
dxdy=(dx, -dx),
x0y0=x0y0)
glacier_grid.to_json(gdir.get_filepath('glacier_grid'))
# Write DEM source info
gdir.add_to_diagnostics('dem_source', dem_source)
source_txt = DEM_SOURCE_INFO.get(dem_source, dem_source)
with open(gdir.get_filepath('dem_source'), 'w') as fw:
fw.write(source_txt)
fw.write('\n\n')
fw.write('# Data files\n\n')
for fname in dem_list:
fw.write('{}\n'.format(os.path.basename(fname)))
def define_glacier_region(gdir, entity=None):
"""
Very first task: define the glacier's grid.
Defines the local glacier projection (Transverse Mercator), chooses a
resolution for the grid, and transforms the DEM as well as the RGI shape
into it.
Parameters
----------
gdir : oggm.GlacierDirectory
entity : geopandas entity
the glacier geometry to process
"""
# choose a spatial resolution with respect to the glacier area
dxmethod = cfg.PARAMS['grid_dx_method']
area = gdir.rgi_area_km2
if dxmethod == 'linear':
dx = np.rint(cfg.PARAMS['d1'] * area + cfg.PARAMS['d2'])
elif dxmethod == 'square':
dx = np.rint(cfg.PARAMS['d1'] * np.sqrt(area) + cfg.PARAMS['d2'])
else:
raise ValueError('grid_dx_method not supported: {}'.format(dxmethod))
dx = np.clip(dx, cfg.PARAMS['d2'], cfg.PARAMS['dmax'])
log.debug('%s: area %.2f km, dx=%.1f', gdir.rgi_id, area, dx)
# Make a local glacier map
proj_params = dict(name='tmerc',
lat_0=0.,
lon_0=gdir.cenlon,
k=0.9996,
x_0=0,
y_0=0,
datum='WGS84')
proj4_str = "+proj={name} +lat_0={lat_0} +lon_0={lon_0} +k={k} " \
"+x_0={x_0} +y_0={y_0} +datum={datum}".format(**proj_params)
proj_in = pyproj.Proj("+init=EPSG:4326", preserve_units=True)
proj_out = pyproj.Proj(proj4_str, preserve_units=True)
project = partial(pyproj.transform, proj_in, proj_out)
geometry = shapely.ops.transform(project, entity['geometry'])
geometry = _check_geometry(geometry)
xx, yy = geometry.exterior.xy
# Corners, incl. a buffer of N pix
ulx = np.min(xx) - cfg.PARAMS['border'] * dx
lrx = np.max(xx) + cfg.PARAMS['border'] * dx
uly = np.max(yy) + cfg.PARAMS['border'] * dx
lry = np.min(yy) - cfg.PARAMS['border'] * dx
# n pixels
nx = np.int((lrx - ulx) / dx)
ny = np.int((uly - lry) / dx)
# Back to lon, lat for DEM download/preparation
tmp_grid = salem.Grid(proj=proj_out,
nxny=(nx, ny),
ul_corner=(ulx, uly),
dxdy=(dx, -dx),
pixel_ref='corner')
minlon, maxlon, minlat, maxlat = tmp_grid.extent_in_crs(crs=salem.wgs84)
# save transformed geometry to disk
entity['geometry'] = geometry
towrite = gpd.GeoDataFrame(entity).T
towrite.crs = proj4_str
towrite.to_file(gdir.get_filepath('outlines'))
# Open DEM
dem_file, dem_source = get_topo_file((minlon, maxlon), (minlat, maxlat),
region=gdir.rgi_region)
log.debug('%s: DEM source: %s', gdir.rgi_id, dem_source)
dem = gdal.Open(dem_file)
geo_t = dem.GetGeoTransform()
# Input proj
dem_proj = dem.GetProjection()
if dem_proj == '':
# Assume defaults
wgs84 = osr.SpatialReference()
wgs84.ImportFromEPSG(4326)
dem_proj = wgs84.ExportToWkt()
# Dest proj
gproj = osr.SpatialReference()
gproj.SetProjCS('Local transverse Mercator')
gproj.SetWellKnownGeogCS("WGS84")
gproj.SetTM(np.float(0), gdir.cenlon, np.float(0.9996), np.float(0),
np.float(0))
# Create an in-memory raster
mem_drv = gdal.GetDriverByName('MEM')
# GDALDataset Create (char *pszName, int nXSize, int nYSize,
# int nBands, GDALDataType eType)
dest = mem_drv.Create('', nx, ny, 1, gdal.GDT_Float32)
# Calculate the new geotransform
new_geo = (ulx, dx, geo_t[2], uly, geo_t[4], -dx)
# Set the geotransform
dest.SetGeoTransform(new_geo)
dest.SetProjection(gproj.ExportToWkt())
# Perform the projection/resampling
if cfg.PARAMS['topo_interp'] == 'bilinear':
interp = gdal.GRA_Bilinear
elif cfg.PARAMS['topo_interp'] == 'cubic':
interp = gdal.GRA_Cubic
else:
raise ValueError('{} interpolation not understood'.format(
cfg.PARAMS['topo_interp']))
res = gdal.ReprojectImage(dem, dest, dem_proj, gproj.ExportToWkt(), interp)
# Let's save it as a GeoTIFF.
driver = gdal.GetDriverByName("GTiff")
tmp = driver.CreateCopy(gdir.get_filepath('dem'), dest, 0)
tmp = None # without this, GDAL is getting crazy in python3
dest = None # the memfree above is necessary, this one is to be sure...
# Glacier grid
ul_corner = (ulx + dx / 2, uly - dx / 2) # To pixel center coordinates
glacier_grid = salem.Grid(proj=proj_out,
nxny=(nx, ny),
dxdy=(dx, -dx),
ul_corner=ul_corner)
gdir.write_pickle(glacier_grid, 'glacier_grid')
gdir.write_pickle(dem_source, 'dem_source')
# Looks in the database if the glacier has divides.
gdf = cfg.PARAMS['divides_gdf']
if gdir.rgi_id in gdf.index.values:
divdf = [g for g in gdf.loc[gdir.rgi_id].geometry]
log.debug('%s: number of divides: %d', gdir.rgi_id, len(divdf))
# Reproject the shape
def proj(lon, lat):
return salem.transform_proj(salem.wgs84, gdir.grid.proj, lon, lat)
divdf = [shapely.ops.transform(proj, g) for g in divdf]
# Write the directories and the files
for i, g in enumerate(divdf):
_dir = os.path.join(gdir.dir, 'divide_{0:0=2d}'.format(i + 1))
if not os.path.exists(_dir):
os.makedirs(_dir)
# File
entity['geometry'] = g
towrite = gpd.GeoDataFrame(entity).T
towrite.crs = proj4_str
towrite.to_file(os.path.join(_dir, cfg.BASENAMES['outlines']))
else:
# Make a single directory and link the files
log.debug('%s: number of divides: %d', gdir.rgi_id, 1)
_dir = os.path.join(gdir.dir, 'divide_01')
if not os.path.exists(_dir):
os.makedirs(_dir)
linkname = os.path.join(_dir, cfg.BASENAMES['outlines'])
sourcename = gdir.get_filepath('outlines')
# TODO: temporary suboptimal solution
try:
# we are on UNIX
os.link(sourcename, linkname)
except AttributeError:
# we are on windows
copyfile(sourcename, linkname)
def define_glacier_region(gdir, entity=None):
"""
Very first task: define the glacier's local grid.
Defines the local projection (Transverse Mercator), centered on the
glacier. There is some options to set the resolution of the local grid.
It can be adapted depending on the size of the glacier with::
dx (m) = d1 * AREA (km) + d2 ; clipped to dmax
or be set to a fixed value. See ``params.cfg`` for setting these options.
Default values of the adapted mode lead to a resolution of 50 m for
Hintereisferner, which is approx. 8 km2 large.
After defining the grid, the topography and the outlines of the glacier
are transformed into the local projection. The default interpolation for
the topography is `cubic`.
Parameters
----------
gdir : :py:class:`oggm.GlacierDirectory`
where to write the data
entity : geopandas GeoSeries
the glacier geometry to process
"""
# choose a spatial resolution with respect to the glacier area
dxmethod = cfg.PARAMS['grid_dx_method']
area = gdir.rgi_area_km2
if dxmethod == 'linear':
dx = np.rint(cfg.PARAMS['d1'] * area + cfg.PARAMS['d2'])
elif dxmethod == 'square':
dx = np.rint(cfg.PARAMS['d1'] * np.sqrt(area) + cfg.PARAMS['d2'])
elif dxmethod == 'fixed':
dx = np.rint(cfg.PARAMS['fixed_dx'])
else:
raise ValueError('grid_dx_method not supported: {}'.format(dxmethod))
# Additional trick for varying dx
if dxmethod in ['linear', 'square']:
dx = np.clip(dx, cfg.PARAMS['d2'], cfg.PARAMS['dmax'])
log.debug('%s: area %.2f km, dx=%.1f', gdir.rgi_id, area, dx)
# Make a local glacier map
proj_params = dict(name='tmerc', lat_0=0., lon_0=gdir.cenlon,
k=0.9996, x_0=0, y_0=0, datum='WGS84')
proj4_str = "+proj={name} +lat_0={lat_0} +lon_0={lon_0} +k={k} " \
"+x_0={x_0} +y_0={y_0} +datum={datum}".format(**proj_params)
proj_in = pyproj.Proj("+init=EPSG:4326", preserve_units=True)
proj_out = pyproj.Proj(proj4_str, preserve_units=True)
project = partial(pyproj.transform, proj_in, proj_out)
# transform geometry to map
geometry = shapely.ops.transform(project, entity['geometry'])
geometry = _check_geometry(geometry)
xx, yy = geometry.exterior.xy
# Corners, incl. a buffer of N pix
ulx = np.min(xx) - cfg.PARAMS['border'] * dx
lrx = np.max(xx) + cfg.PARAMS['border'] * dx
uly = np.max(yy) + cfg.PARAMS['border'] * dx
lry = np.min(yy) - cfg.PARAMS['border'] * dx
# n pixels
nx = np.int((lrx - ulx) / dx)
ny = np.int((uly - lry) / dx)
# Back to lon, lat for DEM download/preparation
tmp_grid = salem.Grid(proj=proj_out, nxny=(nx, ny), x0y0=(ulx, uly),
dxdy=(dx, -dx), pixel_ref='corner')
minlon, maxlon, minlat, maxlat = tmp_grid.extent_in_crs(crs=salem.wgs84)
# save transformed geometry to disk
entity = entity.copy()
entity['geometry'] = geometry
# Avoid fiona bug: https://github.com/Toblerity/Fiona/issues/365
for k, s in entity.iteritems():
if type(s) in [np.int32, np.int64]:
entity[k] = int(s)
towrite = gpd.GeoDataFrame(entity).T
towrite.crs = proj4_str
# Delete the source before writing
if 'DEM_SOURCE' in towrite:
del towrite['DEM_SOURCE']
towrite.to_file(gdir.get_filepath('outlines'))
# Also transform the intersects if necessary
gdf = cfg.PARAMS['intersects_gdf']
gdf = gdf.loc[(gdf.RGIId_1 == gdir.rgi_id) | (gdf.RGIId_2 == gdir.rgi_id)]
if len(gdf) > 0:
gdf = salem.transform_geopandas(gdf, to_crs=proj_out)
if hasattr(gdf.crs, 'srs'):
# salem uses pyproj
gdf.crs = gdf.crs.srs
gdf.to_file(gdir.get_filepath('intersects'))
# Open DEM
source = entity.DEM_SOURCE if hasattr(entity, 'DEM_SOURCE') else None
dem_list, dem_source = get_topo_file((minlon, maxlon), (minlat, maxlat),
rgi_region=gdir.rgi_region,
source=source)
log.debug('%s: DEM source: %s', gdir.rgi_id, dem_source)
# A glacier area can cover more than one tile:
if len(dem_list) == 1:
dem_dss = [rasterio.open(dem_list[0])] # if one tile, just open it
dem_data = rasterio.band(dem_dss[0], 1)
if LooseVersion(rasterio.__version__) >= LooseVersion('1.0'):
src_transform = dem_dss[0].transform
else:
src_transform = dem_dss[0].affine
else:
dem_dss = [rasterio.open(s) for s in dem_list] # list of rasters
dem_data, src_transform = merge_tool(dem_dss) # merged rasters
# Use Grid properties to create a transform (see rasterio cookbook)
dst_transform = rasterio.transform.from_origin(
ulx, uly, dx, dx # sign change (2nd dx) is done by rasterio.transform
)
# Set up profile for writing output
profile = dem_dss[0].profile
profile.update({
'crs': proj4_str,
'transform': dst_transform,
'width': nx,
'height': ny
})
# Could be extended so that the cfg file takes all Resampling.* methods
if cfg.PARAMS['topo_interp'] == 'bilinear':
resampling = Resampling.bilinear
elif cfg.PARAMS['topo_interp'] == 'cubic':
resampling = Resampling.cubic
else:
raise ValueError('{} interpolation not understood'
.format(cfg.PARAMS['topo_interp']))
dem_reproj = gdir.get_filepath('dem')
with rasterio.open(dem_reproj, 'w', **profile) as dest:
dst_array = np.empty((ny, nx), dtype=dem_dss[0].dtypes[0])
reproject(
# Source parameters
source=dem_data,
src_crs=dem_dss[0].crs,
src_transform=src_transform,
# Destination parameters
destination=dst_array,
dst_transform=dst_transform,
dst_crs=proj4_str,
# Configuration
resampling=resampling)
dest.write(dst_array, 1)
for dem_ds in dem_dss:
dem_ds.close()
# Glacier grid
x0y0 = (ulx+dx/2, uly-dx/2) # To pixel center coordinates
glacier_grid = salem.Grid(proj=proj_out, nxny=(nx, ny), dxdy=(dx, -dx),
x0y0=x0y0)
glacier_grid.to_json(gdir.get_filepath('glacier_grid'))
gdir.write_pickle(dem_source, 'dem_source')
# Looks in the database if the glacier has divides.
gdf = cfg.PARAMS['divides_gdf']
if gdir.rgi_id in gdf.index.values:
div_gdf = gdf.loc[gdir.rgi_id]
# Compute the intersections between them for later bedshapes
gdf_inter = polygon_intersections(div_gdf)
if len(gdf_inter) > 0:
if hasattr(div_gdf.crs, 'srs'):
# salem uses pyproj
gdf_inter.crs = div_gdf.crs.srs
else:
gdf_inter.crs = div_gdf.crs
gdf_inter.to_file(gdir.get_filepath('divides_intersects'))
# Ok go on
divlist = [g for g in div_gdf.geometry]
# Reproject the shape
def proj(lon, lat):
return salem.transform_proj(salem.wgs84, gdir.grid.proj,
lon, lat)
divlist = [shapely.ops.transform(proj, g) for g in divlist]
# Keep only the ones large enough
log.debug('%s: divide candidates: %d', gdir.rgi_id, len(divlist))
divlist = [g for g in divlist if (g.area >= (50 * dx ** 2))]
log.debug('%s: number of divides: %d', gdir.rgi_id, len(divlist))
divlist = np.asarray(divlist)
# Sort them by area
divlist = divlist[np.argsort([g.area for g in divlist])[::-1]]
# Write the directories and the files
for i, g in enumerate(divlist):
_dir = os.path.join(gdir.dir, 'divide_{0:0=2d}'.format(i + 1))
if not os.path.exists(_dir):
os.makedirs(_dir)
# File
entity['geometry'] = g
towrite = gpd.GeoDataFrame(entity).T
towrite.crs = proj4_str
towrite.to_file(os.path.join(_dir, cfg.BASENAMES['outlines']))
else:
# Make a single directory and link the files
log.debug('%s: number of divides: %d', gdir.rgi_id, 1)
_dir = os.path.join(gdir.dir, 'divide_01')
if not os.path.exists(_dir):
os.makedirs(_dir)
linkname = os.path.join(_dir, cfg.BASENAMES['outlines'])
sourcename = gdir.get_filepath('outlines')
for ending in ['.cpg', '.dbf', '.shp', '.shx', '.prj']:
_s = sourcename.replace('.shp', ending)
_l = linkname.replace('.shp', ending)
if os.path.exists(_s):
try:
# we are on UNIX
os.link(_s, _l)
except AttributeError:
# we are on windows
copyfile(_s, _l)
def define_glacier_region(gdir, entity=None):
"""
Very first task: define the glacier's local grid.
Defines the local projection (Transverse Mercator), centered on the
glacier. The resolution of the local grid depends on the size of the
glacier::
dx (m) = d1 * AREA (km) + d2 ; clipped to dmax
See ``params.cfg`` for setting these options. Default values lead to a
resolution of 50 m for Hintereisferner, which is approx. 8 km2 large.
After defining the grid, the topography and the outlines of the glacier
are transformed into the local projection. The default interpolation for
the topography is `cubic`.
Parameters
----------
gdir : :py:class:`oggm.GlacierDirectory`
where to write the data
entity : geopandas GeoSeries
the glacier geometry to process
"""
# choose a spatial resolution with respect to the glacier area
dxmethod = cfg.PARAMS['grid_dx_method']
area = gdir.rgi_area_km2
if dxmethod == 'linear':
dx = np.rint(cfg.PARAMS['d1'] * area + cfg.PARAMS['d2'])
elif dxmethod == 'square':
dx = np.rint(cfg.PARAMS['d1'] * np.sqrt(area) + cfg.PARAMS['d2'])
else:
raise ValueError('grid_dx_method not supported: {}'.format(dxmethod))
dx = np.clip(dx, cfg.PARAMS['d2'], cfg.PARAMS['dmax'])
log.debug('%s: area %.2f km, dx=%.1f', gdir.rgi_id, area, dx)
# Make a local glacier map
proj_params = dict(name='tmerc', lat_0=0., lon_0=gdir.cenlon,
k=0.9996, x_0=0, y_0=0, datum='WGS84')
proj4_str = "+proj={name} +lat_0={lat_0} +lon_0={lon_0} +k={k} " \
"+x_0={x_0} +y_0={y_0} +datum={datum}".format(**proj_params)
proj_in = pyproj.Proj("+init=EPSG:4326", preserve_units=True)
proj_out = pyproj.Proj(proj4_str, preserve_units=True)
project = partial(pyproj.transform, proj_in, proj_out)
geometry = shapely.ops.transform(project, entity['geometry'])
geometry = _check_geometry(geometry)
xx, yy = geometry.exterior.xy
# Corners, incl. a buffer of N pix
ulx = np.min(xx) - cfg.PARAMS['border'] * dx
lrx = np.max(xx) + cfg.PARAMS['border'] * dx
uly = np.max(yy) + cfg.PARAMS['border'] * dx
lry = np.min(yy) - cfg.PARAMS['border'] * dx
# n pixels
nx = np.int((lrx - ulx) / dx)
ny = np.int((uly - lry) / dx)
# Back to lon, lat for DEM download/preparation
tmp_grid = salem.Grid(proj=proj_out, nxny=(nx, ny), ul_corner=(ulx, uly),
dxdy=(dx, -dx), pixel_ref='corner')
minlon, maxlon, minlat, maxlat = tmp_grid.extent_in_crs(crs=salem.wgs84)
# save transformed geometry to disk
entity = entity.copy()
entity['geometry'] = geometry
# Avoid fiona bug: https://github.com/Toblerity/Fiona/issues/365
for k, s in entity.iteritems():
if type(s) in [np.int32, np.int64]:
entity[k] = int(s)
towrite = gpd.GeoDataFrame(entity).T
towrite.crs = proj4_str
towrite.to_file(gdir.get_filepath('outlines'))
# Open DEM
dem_file, dem_source = get_topo_file((minlon, maxlon), (minlat, maxlat),
region=gdir.rgi_region)
log.debug('%s: DEM source: %s', gdir.rgi_id, dem_source)
dem = gdal.Open(dem_file)
geo_t = dem.GetGeoTransform()
# Input proj
dem_proj = dem.GetProjection()
if dem_proj == '':
# Assume defaults
wgs84 = osr.SpatialReference()
wgs84.ImportFromEPSG(4326)
dem_proj = wgs84.ExportToWkt()
# Dest proj
gproj = osr.SpatialReference()
gproj.SetProjCS('Local transverse Mercator')
gproj.SetWellKnownGeogCS("WGS84")
gproj.SetTM(np.float(0), gdir.cenlon,
np.float(0.9996), np.float(0), np.float(0))
# Create an in-memory raster
mem_drv = gdal.GetDriverByName('MEM')
# GDALDataset Create (char *pszName, int nXSize, int nYSize,
# int nBands, GDALDataType eType)
dest = mem_drv.Create('', nx, ny, 1, gdal.GDT_Float32)
# Calculate the new geotransform
new_geo = (ulx, dx, geo_t[2], uly, geo_t[4], -dx)
# Set the geotransform
dest.SetGeoTransform(new_geo)
dest.SetProjection(gproj.ExportToWkt())
# Perform the projection/resampling
if cfg.PARAMS['topo_interp'] == 'bilinear':
interp = gdal.GRA_Bilinear
elif cfg.PARAMS['topo_interp'] == 'cubic':
interp = gdal.GRA_Cubic
else:
raise ValueError('{} interpolation not understood'
.format(cfg.PARAMS['topo_interp']))
res = gdal.ReprojectImage(dem, dest, dem_proj,
gproj.ExportToWkt(), interp)
# Let's save it as a GeoTIFF.
driver = gdal.GetDriverByName("GTiff")
tmp = driver.CreateCopy(gdir.get_filepath('dem'), dest, 0)
tmp = None # without this, GDAL is getting crazy in python3
dest = None # the memfree above is necessary, this one is to be sure...
# Glacier grid
ul_corner = (ulx+dx/2, uly-dx/2) # To pixel center coordinates
glacier_grid = salem.Grid(proj=proj_out, nxny=(nx, ny), dxdy=(dx, -dx),
ul_corner=ul_corner)
gdir.write_pickle(glacier_grid, 'glacier_grid')
gdir.write_pickle(dem_source, 'dem_source')
# Looks in the database if the glacier has divides.
gdf = cfg.PARAMS['divides_gdf']
if gdir.rgi_id in gdf.index.values:
divdf = [g for g in gdf.loc[gdir.rgi_id].geometry]
# Reproject the shape
def proj(lon, lat):
return salem.transform_proj(salem.wgs84, gdir.grid.proj,
lon, lat)
divdf = [shapely.ops.transform(proj, g) for g in divdf]
# Keep only the ones large enough
log.debug('%s: divide candidates: %d', gdir.rgi_id, len(divdf))
divdf = [g for g in divdf if (g.area >= (25*dx**2))]
log.debug('%s: number of divides: %d', gdir.rgi_id, len(divdf))
# Write the directories and the files
for i, g in enumerate(divdf):
_dir = os.path.join(gdir.dir, 'divide_{0:0=2d}'.format(i + 1))
if not os.path.exists(_dir):
os.makedirs(_dir)
# File
entity['geometry'] = g
towrite = gpd.GeoDataFrame(entity).T
towrite.crs = proj4_str
towrite.to_file(os.path.join(_dir, cfg.BASENAMES['outlines']))
else:
# Make a single directory and link the files
log.debug('%s: number of divides: %d', gdir.rgi_id, 1)
_dir = os.path.join(gdir.dir, 'divide_01')
if not os.path.exists(_dir):
os.makedirs(_dir)
linkname = os.path.join(_dir, cfg.BASENAMES['outlines'])
sourcename = gdir.get_filepath('outlines')
# TODO: temporary suboptimal solution
try:
# we are on UNIX
os.link(sourcename, linkname)
except AttributeError:
# we are on windows
copyfile(sourcename, linkname)
def define_glacier_region(gdir, entity=None):
"""
Very first task: define the glacier's local grid.
Defines the local projection (Transverse Mercator), centered on the
glacier. There is some options to set the resolution of the local grid.
It can be adapted depending on the size of the glacier with::
dx (m) = d1 * AREA (km) + d2 ; clipped to dmax
or be set to a fixed value. See ``params.cfg`` for setting these options.
Default values of the adapted mode lead to a resolution of 50 m for
Hintereisferner, which is approx. 8 km2 large.
After defining the grid, the topography and the outlines of the glacier
are transformed into the local projection. The default interpolation for
the topography is `cubic`.
Parameters
----------
gdir : :py:class:`oggm.GlacierDirectory`
where to write the data
entity : geopandas GeoSeries
the glacier geometry to process
"""
# choose a spatial resolution with respect to the glacier area
dxmethod = cfg.PARAMS['grid_dx_method']
area = gdir.rgi_area_km2
if dxmethod == 'linear':
dx = np.rint(cfg.PARAMS['d1'] * area + cfg.PARAMS['d2'])
elif dxmethod == 'square':
dx = np.rint(cfg.PARAMS['d1'] * np.sqrt(area) + cfg.PARAMS['d2'])
elif dxmethod == 'fixed':
dx = np.rint(cfg.PARAMS['fixed_dx'])
else:
raise ValueError('grid_dx_method not supported: {}'.format(dxmethod))
# Additional trick for varying dx
if dxmethod in ['linear', 'square']:
dx = np.clip(dx, cfg.PARAMS['d2'], cfg.PARAMS['dmax'])
log.debug('%s: area %.2f km, dx=%.1f', gdir.rgi_id, area, dx)
# Make a local glacier map
proj_params = dict(name='tmerc',
lat_0=0.,
lon_0=gdir.cenlon,
k=0.9996,
x_0=0,
y_0=0,
datum='WGS84')
proj4_str = "+proj={name} +lat_0={lat_0} +lon_0={lon_0} +k={k} " \
"+x_0={x_0} +y_0={y_0} +datum={datum}".format(**proj_params)
proj_in = pyproj.Proj("+init=EPSG:4326", preserve_units=True)
proj_out = pyproj.Proj(proj4_str, preserve_units=True)
project = partial(pyproj.transform, proj_in, proj_out)
# transform geometry to map
geometry = shapely.ops.transform(project, entity['geometry'])
geometry = _check_geometry(geometry)
xx, yy = geometry.exterior.xy
# Corners, incl. a buffer of N pix
ulx = np.min(xx) - cfg.PARAMS['border'] * dx
lrx = np.max(xx) + cfg.PARAMS['border'] * dx
uly = np.max(yy) + cfg.PARAMS['border'] * dx
lry = np.min(yy) - cfg.PARAMS['border'] * dx
# n pixels
nx = np.int((lrx - ulx) / dx)
ny = np.int((uly - lry) / dx)
# Back to lon, lat for DEM download/preparation
tmp_grid = salem.Grid(proj=proj_out,
nxny=(nx, ny),
x0y0=(ulx, uly),
dxdy=(dx, -dx),
pixel_ref='corner')
minlon, maxlon, minlat, maxlat = tmp_grid.extent_in_crs(crs=salem.wgs84)
# save transformed geometry to disk
entity = entity.copy()
entity['geometry'] = geometry
# Avoid fiona bug: https://github.com/Toblerity/Fiona/issues/365
for k, s in entity.iteritems():
if type(s) in [np.int32, np.int64]:
entity[k] = int(s)
towrite = gpd.GeoDataFrame(entity).T
towrite.crs = proj4_str
# Delete the source before writing
if 'DEM_SOURCE' in towrite:
del towrite['DEM_SOURCE']
towrite.to_file(gdir.get_filepath('outlines'))
# Also transform the intersects if necessary
gdf = cfg.PARAMS['intersects_gdf']
gdf = gdf.loc[(gdf.RGIId_1 == gdir.rgi_id) | (gdf.RGIId_2 == gdir.rgi_id)]
if len(gdf) > 0:
gdf = salem.transform_geopandas(gdf, to_crs=proj_out)
if hasattr(gdf.crs, 'srs'):
# salem uses pyproj
gdf.crs = gdf.crs.srs
gdf.to_file(gdir.get_filepath('intersects'))
# Open DEM
source = entity.DEM_SOURCE if hasattr(entity, 'DEM_SOURCE') else None
dem_list, dem_source = get_topo_file((minlon, maxlon), (minlat, maxlat),
rgi_region=gdir.rgi_region,
source=source)
log.debug('%s: DEM source: %s', gdir.rgi_id, dem_source)
# A glacier area can cover more than one tile:
if len(dem_list) == 1:
dem_dss = [rasterio.open(dem_list[0])] # if one tile, just open it
dem_data = rasterio.band(dem_dss[0], 1)
src_transform = dem_dss[0].transform
else:
dem_dss = [rasterio.open(s) for s in dem_list] # list of rasters
dem_data, src_transform = merge_tool(dem_dss) # merged rasters
# Use Grid properties to create a transform (see rasterio cookbook)
dst_transform = rasterio.transform.from_origin(
ulx,
uly,
dx,
dx # sign change (2nd dx) is done by rasterio.transform
)
# Set up profile for writing output
profile = dem_dss[0].profile
profile.update({
'crs': proj4_str,
'transform': dst_transform,
'width': nx,
'height': ny
})
# Could be extended so that the cfg file takes all Resampling.* methods
if cfg.PARAMS['topo_interp'] == 'bilinear':
resampling = Resampling.bilinear
elif cfg.PARAMS['topo_interp'] == 'cubic':
resampling = Resampling.cubic
else:
raise ValueError('{} interpolation not understood'.format(
cfg.PARAMS['topo_interp']))
dem_reproj = gdir.get_filepath('dem')
with rasterio.open(dem_reproj, 'w', **profile) as dest:
dst_array = np.empty((ny, nx), dtype=dem_dss[0].dtypes[0])
reproject(
# Source parameters
source=dem_data,
src_crs=dem_dss[0].crs,
src_transform=src_transform,
# Destination parameters
destination=dst_array,
dst_transform=dst_transform,
dst_crs=proj4_str,
# Configuration
resampling=resampling)
dest.write(dst_array, 1)
for dem_ds in dem_dss:
dem_ds.close()
# Glacier grid
x0y0 = (ulx + dx / 2, uly - dx / 2) # To pixel center coordinates
glacier_grid = salem.Grid(proj=proj_out,
nxny=(nx, ny),
dxdy=(dx, -dx),
x0y0=x0y0)
glacier_grid.to_json(gdir.get_filepath('glacier_grid'))
gdir.write_pickle(dem_source, 'dem_source')
# Looks in the database if the glacier has divides.
gdf = cfg.PARAMS['divides_gdf']
if gdir.rgi_id in gdf.index.values:
divdf = [g for g in gdf.loc[gdir.rgi_id].geometry]
# Reproject the shape
def proj(lon, lat):
return salem.transform_proj(salem.wgs84, gdir.grid.proj, lon, lat)
divdf = [shapely.ops.transform(proj, g) for g in divdf]
# Keep only the ones large enough
log.debug('%s: divide candidates: %d', gdir.rgi_id, len(divdf))
divdf = [g for g in divdf if (g.area >= (25 * dx**2))]
log.debug('%s: number of divides: %d', gdir.rgi_id, len(divdf))
# Write the directories and the files
for i, g in enumerate(divdf):
_dir = os.path.join(gdir.dir, 'divide_{0:0=2d}'.format(i + 1))
if not os.path.exists(_dir):
os.makedirs(_dir)
# File
entity['geometry'] = g
towrite = gpd.GeoDataFrame(entity).T
towrite.crs = proj4_str
towrite.to_file(os.path.join(_dir, cfg.BASENAMES['outlines']))
else:
# Make a single directory and link the files
log.debug('%s: number of divides: %d', gdir.rgi_id, 1)
_dir = os.path.join(gdir.dir, 'divide_01')
if not os.path.exists(_dir):
os.makedirs(_dir)
linkname = os.path.join(_dir, cfg.BASENAMES['outlines'])
sourcename = gdir.get_filepath('outlines')
for ending in ['.cpg', '.dbf', '.shp', '.shx', '.prj']:
_s = sourcename.replace('.shp', ending)
_l = linkname.replace('.shp', ending)
if os.path.exists(_s):
try:
# we are on UNIX
os.link(_s, _l)
except AttributeError:
# we are on windows
copyfile(_s, _l)
def compare(rgi_id, glacier_name):
"""
:param rgi_id:
:param glacier_name:
:return:
"""
# ---------------------
# PREPROCESSING TASKS
# ---------------------
# create test directory
wdir = os.path.join(os.path.abspath('.'), 'comparison_wdir')
if not os.path.exists(wdir):
os.makedirs(wdir)
shutil.rmtree(wdir)
os.makedirs(wdir)
# load default parameter file
cfg.initialize()
# RGI entity
# get/downlaod the rgi entity including the outline shapefile
rgi_df = utils.get_rgi_glacier_entities([rgi_id])
# set name, since not delivered with RGI
if rgi_df.loc[int(rgi_id[-5:])-1, 'Name'] is None:
rgi_df.loc[int(rgi_id[-5:])-1, 'Name'] = glacier_name
# select single entry
rgi_entity = rgi_df.iloc[0]
# GlacierDirectory
# specify the working directory and define the glacier directory
cfg.PATHS['working_dir'] = wdir
gdir = oggm.GlacierDirectory(rgi_entity)
# DEM and GIS tasks
# get the path to the DEM file (will download if necessary)
dem = utils.get_topo_file(gdir.cenlon, gdir.cenlat)
# set path in config file
cfg.PATHS['dem_file'] = dem[0][0]
cfg.PARAMS['border'] = 10
cfg.PARAMS['use_intersects'] = False
# run GIS tasks
gis.define_glacier_region(gdir, entity=rgi_entity)
gis.glacier_masks(gdir)
# Climate data
# using HistAlp
cfg.PARAMS['baseline_climate'] = 'HISTALP'
# climate records before 1850 are hardly reliable, which is not so drastic for
# qualitative experiments (could be driven with random climate anyway)
# cfg.PARAMS['baseline_y0'] = 1850
# change hyper parameters for HistAlp
cfg.PARAMS['prcp_scaling_factor'] = 1.75
cfg.PARAMS['temp_melt'] = -1.75
# run climate task
climate.process_histalp_data(gdir)
# run center line preprocessing tasks
centerlines.compute_centerlines(gdir)
centerlines.initialize_flowlines(gdir)
centerlines.compute_downstream_line(gdir)
centerlines.compute_downstream_bedshape(gdir)
centerlines.catchment_area(gdir)
centerlines.catchment_intersections(gdir)
centerlines.catchment_width_geom(gdir)
centerlines.catchment_width_correction(gdir)
# --------------------
# SCALING MODEL
# --------------------
# compute local t* and the corresponding mu*
vascaling.local_t_star(gdir)
# instance the mass balance models
vas_mb_mod = vascaling.VAScalingMassBalance(gdir)
# get reference area
a0 = gdir.rgi_area_m2
# get reference year
y0 = gdir.read_pickle('climate_info')['baseline_hydro_yr_0']
y1 = gdir.read_pickle('climate_info')['baseline_hydro_yr_1']
# get min and max glacier surface elevation
h0, h1 = vascaling.get_min_max_elevation(gdir)
# instance VAS model
vas_model = vascaling.VAScalingModel(year_0=y0, area_m2_0=a0,
min_hgt=h0, max_hgt=h1,
mb_model=vas_mb_mod)
# run model over all HistAlp climate period
vas_df = vas_model.run_and_store(y1, reset=True)
# get relevant parameters
years_vas = vas_df.index.values
length_m_vas = vas_df.length_m.values
area_m2_vas = vas_df.area_m2.values
volume_m3_vas = vas_df.volume_m3.values
# ------
# OGGM
# ------
# compute local t* and the corresponding mu*
climate.local_t_star(gdir)
climate.mu_star_calibration(gdir)
# instance the mass balance models
mb_mod = massbalance.PastMassBalance(gdir)
# run inversion tasks
inversion.prepare_for_inversion(gdir)
inversion.mass_conservation_inversion(gdir)
inversion.filter_inversion_output(gdir)
# initialize present time glacier
flowline.init_present_time_glacier(gdir)
# instance flowline model
fls = gdir.read_pickle('model_flowlines')
y0 = gdir.read_pickle('climate_info')['baseline_hydro_yr_0']
y1 = gdir.read_pickle('climate_info')['baseline_hydro_yr_1']
fl_mod = flowline.FluxBasedModel(flowlines=fls, mb_model=mb_mod, y0=y0)
# run model and store output as xarray data set
_, oggm_ds = fl_mod.run_until_and_store(y1)
years_oggm = oggm_ds.hydro_year.values
# annual index must be equal
np.testing.assert_array_equal(years_oggm, years_vas)
length_m_oggm = oggm_ds.length_m.values
area_m2_oggm = oggm_ds.area_m2.values
volume_m3_oggm = oggm_ds.volume_m3.values
# define column names for DataFrame
names = ['length_vas', 'length_oggm',
'area_vas', 'area_oggm',
'volume_vas', 'volume_oggm']
# combine glacier geometries into DataFrame
df = pd.DataFrame(np.array([length_m_vas, length_m_oggm,
area_m2_vas, area_m2_oggm,
volume_m3_vas, volume_m3_oggm]).T,
index=years_vas, columns=names)
# save to file
store = True
if store:
# define path and file names
folder = '/Users/oberrauch/work/master/data/'
df.to_csv(folder+'run_comparison.csv')
def plot_both(vas_df, oggm_df, ref=None, correct_bias=False,
title='', ylabel='', file_path='', exp=0):
""" Plot geometric parameters of both models.
If a `file_path` is given, the figure will be saved.
:param vas_df: (pandas.Series) geometric glacier parameter of the VAS model
:param oggm_df: (pandas.Series) geometric glacier parameter of the OGGM
:param ref: (pandas.Series) measured glacier parameter, optional
:param title: (string) figure title, optional
:param ylabel: (string) label for y-axis, optional
:param file_path: (string) where to store the figure, optional
:param exp: (int) exponent for labels in scientific notation, optional
"""
beamer = True
if beamer:
mpl.rc('axes', titlesize=18)
mpl.rc('axes', labelsize=14)
mpl.rc('xtick', labelsize=14)
mpl.rc('ytick', labelsize=14)
mpl.rc('legend', fontsize=10)
# create figure and first axes
fig = plt.figure(figsize=[6, 4])
ax = fig.add_axes([0.15, 0.1, 0.8, 0.8])
# define colors
c1 = 'C0'
c2 = 'C1'
c3 = 'C3'
# plot vas and OGGM parameters
ax.plot(oggm_df.index, oggm_df.values, c=c2, label='OGGM')
ax.plot(vas_df.index, vas_df.values, c=c1, label='VAS')
if ref:
# plot reference parameter if given
ax.plot(ref.index, ref.values, c=c3, label='measurements')
if correct_bias:
# plot bias corrected vas
df_ = pd.DataFrame([oggm_df, vas_df]).T
bias = vas_df.values - df_.mean().diff().iloc[1]
ax.plot(vas_df.index, bias, c=c1, ls='--',
label='VAS, bias corrected')
# add RMSD as text
ax.text(0.05, 0.05,
'RMSD: {:.1e}'.format(utils.rmsd(oggm_df, bias)),
transform=plt.gca().transAxes)
# add correlation coefficient as text
ax.text(0.05, 0.11, 'Corr. Coef.: {:.2f}'.format(
utils.corrcoef(oggm_df, vas_df)),
transform=plt.gca().transAxes)
# add title, labels, legend
ax.set_title(title)
ax.set_ylabel(ylabel)
ax.legend()
import matplotlib.ticker
class OOMFormatter(matplotlib.ticker.ScalarFormatter):
def __init__(self, order=0, fformat="%1.1f", offset=False, mathText=False):
self.oom = order
self.fformat = fformat
matplotlib.ticker.ScalarFormatter.__init__(self, useOffset=offset, useMathText=mathText)
def _set_orderOfMagnitude(self, nothing):
self.orderOfMagnitude = self.oom
def _set_format(self, vmin, vmax):
self.format = self.fformat
if self._useMathText:
self.format = '$%s$' % matplotlib.ticker._mathdefault(self.format)
# use scientific notation with fixed exponent according
ax.yaxis.set_major_formatter(OOMFormatter(exp, "%1.2f"))
# store to file
if file_path:
plt.savefig(file_path, bbox_inches='tight',
format=file_path.split('.')[-1])
# specify plot directory
folder = '/Users/oberrauch/work/master/plots/'
# plot length
plot_both(df.length_vas, df.length_oggm, correct_bias=True,
title='Glacier length - {}'.format(glacier_name),
ylabel=r'Length [m]',
file_path=os.path.join(folder, '{}_length.pdf'.format(rgi_id)),
exp=3)
# plot area
plot_both(df.area_vas, df.area_oggm, correct_bias=True,
title='Surface area - {}'.format(glacier_name),
ylabel=r'Area [m$^2$]',
file_path=os.path.join(folder, '{}_area.pdf'.format(rgi_id)),
exp=6)
# plot volume
plot_both(df.volume_vas, df.volume_oggm, correct_bias=True,
title='Glacier volume - {}'.format(glacier_name),
ylabel=r'Volume [m$^3$]',
file_path=os.path.join(folder, '{}_volume.pdf'.format(rgi_id)),
exp=9)
