def test_multiple_inversion():
# test directory
testdir = os.path.join(get_test_dir(), 'tmp_mdir')
if not os.path.exists(testdir):
os.makedirs(testdir)
# Init
cfg.initialize()
cfg.set_intersects_db(get_demo_file('rgi_intersect_oetztal.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'] = 40
cfg.PARAMS['baseline_climate'] = 'CUSTOM'
cfg.PARAMS['trapezoid_lambdas'] = 1
cfg.PATHS['working_dir'] = testdir
apply_test_ref_tstars()
# Get the RGI ID
hef_rgi = gpd.read_file(get_demo_file('divides_hef.shp'))
hef_rgi.loc[0, 'RGIId'] = 'RGI50-11.00897'
gdirs = workflow.init_glacier_directories(hef_rgi)
workflow.gis_prepro_tasks(gdirs)
workflow.climate_tasks(gdirs)
workflow.inversion_tasks(gdirs)
fig, ax = plt.subplots()
graphics.plot_inversion(gdirs, ax=ax)
fig.tight_layout()
shutil.rmtree(testdir)
return fig
def hef_gdir(test_dir):
cfg.initialize(logging_level='CRITICAL')
cfg.PARAMS['use_multiple_flowlines'] = False
cfg.PARAMS['use_rgi_area'] = False
cfg.PATHS['working_dir'] = test_dir
rgi_ids = ['RGI60-11.00897']
gl = utils.get_rgi_glacier_entities(rgi_ids)
gdirs = workflow.init_glacier_directories(gl, from_prepro_level=1)
global_tasks.gis_prepro_tasks(gdirs)
cfg.PARAMS['baseline_climate'] = 'CRU'
global_tasks.climate_tasks(
gdirs,
base_url='https://cluster.klima.uni-bremen.de/~oggm/ref_mb_params'
'/oggm_v1.4/RGIV62/CRU/centerlines/qc3/pcp2.5')
execute_entity_task(tasks.prepare_for_inversion,
gdirs,
invert_all_trapezoid=True)
execute_entity_task(tasks.mass_conservation_inversion, gdirs)
execute_entity_task(tasks.init_present_time_glacier, gdirs)
return gdirs[0]
def test_vdr(self, class_case_dir):
# 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')
hef_file = get_demo_file('Hintereisferner_RGI5.shp')
gdir = workflow.init_glacier_directories(gpd.read_file(hef_file))[0]
exps = ['ERA5', 'ERA5dr']
files = []
ref_hgts = []
for base in exps:
cfg.PARAMS['baseline_climate'] = base
tasks.process_climate_data(gdir, output_filesuffix=base)
files.append(
gdir.get_filepath('climate_historical', filesuffix=base))
with xr.open_dataset(files[-1]) as ds:
ref_hgts.append(ds.ref_hgt)
assert ds.ref_pix_dis < 10000
with xr.open_dataset(files[0]) as d1, xr.open_dataset(files[1]) as d2:
np.testing.assert_allclose(d1.temp, d2.temp)
np.testing.assert_allclose(d1.prcp, d2.prcp)
# Fake tests, the plots look plausible
np.testing.assert_allclose(d2.gradient.mean(), -0.0058, atol=.001)
np.testing.assert_allclose(d2.temp_std.mean(), 3.35, atol=0.1)
def up_to_climate(reset=False):
"""Run the tasks you want."""
# test directory
if not os.path.exists(_TEST_DIR):
os.makedirs(_TEST_DIR)
if reset:
clean_dir(_TEST_DIR)
if not os.path.exists(CLI_LOGF):
with open(CLI_LOGF, 'wb') as f:
pickle.dump('none', f)
# Init
cfg.initialize()
# Use multiprocessing
cfg.PARAMS['use_multiprocessing'] = use_multiprocessing()
# Working dir
cfg.PATHS['working_dir'] = _TEST_DIR
cfg.PATHS['dem_file'] = get_demo_file('srtm_oetztal.tif')
cfg.set_intersects_db(get_demo_file('rgi_intersect_oetztal.shp'))
# Read in the RGI file
rgi_file = get_demo_file('rgi_oetztal.shp')
rgidf = gpd.read_file(rgi_file)
# Make a fake marine and lake terminating glacier
cfg.PARAMS['tidewater_type'] = 4 # make lake also calve
rgidf.loc[0, 'GlacType'] = '0199'
rgidf.loc[1, 'GlacType'] = '0299'
# Use RGI6
rgidf['RGIId'] = [s.replace('RGI50', 'RGI60') for s in rgidf.RGIId]
# Be sure data is downloaded
cru.get_cru_cl_file()
# Params
cfg.PARAMS['border'] = 70
cfg.PARAMS['tstar_search_window'] = [1902, 0]
cfg.PARAMS['prcp_scaling_factor'] = 1.75
cfg.PARAMS['temp_melt'] = -1.75
cfg.PARAMS['use_kcalving_for_inversion'] = True
cfg.PARAMS['use_kcalving_for_run'] = True
# Go
gdirs = workflow.init_glacier_directories(rgidf)
try:
tasks.catchment_width_correction(gdirs[0])
except Exception:
reset = True
if reset:
# First preprocessing tasks
workflow.gis_prepro_tasks(gdirs)
return gdirs
def test_ecmwf_workflow(self, class_case_dir):
# 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')
hef_file = get_demo_file('Hintereisferner_RGI5.shp')
gdir = workflow.init_glacier_directories(gpd.read_file(hef_file))[0]
cfg.PARAMS['baseline_climate'] = 'CERA+ERA5L'
tasks.process_climate_data(gdir)
f_ref = gdir.get_filepath('climate_historical')
with xr.open_dataset(f_ref) as his:
# Let's do some basic checks
ci = gdir.get_climate_info()
assert ci['baseline_climate_source'] == 'CERA+ERA5L'
assert ci['baseline_hydro_yr_0'] == 1902
assert ci['baseline_hydro_yr_1'] == 2018
cfg.PARAMS['baseline_climate'] = 'CERA|ERA5'
tasks.process_climate_data(gdir)
f_ref = gdir.get_filepath('climate_historical')
with xr.open_dataset(f_ref) as his:
# Let's do some basic checks
ci = gdir.get_climate_info()
assert ci['baseline_climate_source'] == 'CERA|ERA5'
assert ci['baseline_hydro_yr_0'] == 1902
assert ci['baseline_hydro_yr_1'] == 2010
def test_ice_cap():
testdir = os.path.join(get_test_dir(), 'tmp_icecap')
utils.mkdir(testdir, reset=True)
cfg.initialize()
cfg.PARAMS['use_intersects'] = False
cfg.PATHS['dem_file'] = get_demo_file('dem_RGI50-05.08389.tif')
cfg.PARAMS['border'] = 60
cfg.PATHS['working_dir'] = testdir
cfg.PARAMS['trapezoid_lambdas'] = 1
df = gpd.read_file(get_demo_file('divides_RGI50-05.08389.shp'))
df['Area'] = df.Area * 1e-6 # cause it was in m2
df['RGIId'] = ['RGI50-05.08389_d{:02d}'.format(d + 1) for d in df.index]
df['GlacType'] = '1099' # Make an ice cap
gdirs = workflow.init_glacier_directories(df)
workflow.gis_prepro_tasks(gdirs)
from salem import mercator_grid, Map
smap = mercator_grid((gdirs[0].cenlon, gdirs[0].cenlat),
extent=[20000, 23000])
smap = Map(smap)
fig, ax = plt.subplots()
graphics.plot_catchment_width(gdirs,
ax=ax,
add_intersects=True,
add_touches=True,
smap=smap)
fig.tight_layout()
shutil.rmtree(testdir)
return fig
def test_all_at_once(self, class_case_dir):
# 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')
hef_file = get_demo_file('Hintereisferner_RGI5.shp')
gdir = workflow.init_glacier_directories(gpd.read_file(hef_file))[0]
exps = ['CRU', 'HISTALP', 'ERA5', 'ERA5L', 'CERA']
files = []
ref_hgts = []
for base in exps:
cfg.PARAMS['baseline_climate'] = base
tasks.process_climate_data(gdir, output_filesuffix=base)
files.append(
gdir.get_filepath('climate_historical', filesuffix=base))
with xr.open_dataset(files[-1]) as ds:
ref_hgts.append(ds.ref_hgt)
assert ds.ref_pix_dis < 30000
# TEMP
with xr.open_mfdataset(files, concat_dim=exps) as ds:
dft = ds.temp.to_dataframe().unstack().T
dft.index = dft.index.levels[1]
# Common period
dfy = dft.resample('AS').mean().dropna().iloc[1:]
dfm = dft.groupby(dft.index.month).mean()
assert dfy.corr().min().min() > 0.44 # ERA5L and CERA do no correlate
assert dfm.corr().min().min() > 0.97
dfavg = dfy.describe()
# Correct for hgt
ref_h = ref_hgts[0]
for h, d in zip(ref_hgts, exps):
dfy[d] = dfy[d] - 0.0065 * (ref_h - h)
dfm[d] = dfm[d] - 0.0065 * (ref_h - h)
dfavg_cor = dfy.describe()
# After correction less spread
assert dfavg_cor.loc['mean'].std() < 0.8 * dfavg.loc['mean'].std()
assert dfavg_cor.loc['mean'].std() < 2.1
# PRECIP
with xr.open_mfdataset(files, concat_dim=exps) as ds:
dft = ds.prcp.to_dataframe().unstack().T
dft.index = dft.index.levels[1]
# Common period
dfy = dft.resample('AS').mean().dropna().iloc[1:] * 12
dfm = dft.groupby(dft.index.month).mean()
assert dfy.corr().min().min() > 0.5
assert dfm.corr().min().min() > 0.8
dfavg = dfy.describe()
assert dfavg.loc['mean'].std() / dfavg.loc['mean'].mean() < 0.25 # %
def test_workflow(self):
# This is a check that the inversion workflow works fine
# Download the RGI file for the run
# Make a new dataframe of those
rgidf = gpd.read_file(get_demo_file('SouthGlacier.shp'))
# Go - initialize working directories
gdirs = workflow.init_glacier_directories(rgidf)
# Preprocessing tasks
task_list = [
tasks.define_glacier_region,
tasks.glacier_masks,
tasks.compute_centerlines,
tasks.initialize_flowlines,
tasks.catchment_area,
tasks.catchment_intersections,
tasks.catchment_width_geom,
tasks.catchment_width_correction,
tasks.compute_downstream_line,
tasks.compute_downstream_bedshape,
]
for task in task_list:
execute_entity_task(task, gdirs)
execute_entity_task(tasks.process_cru_data,
gdirs,
tmp_file=self.tf,
pre_file=self.pf)
execute_entity_task(tasks.local_t_star, gdirs)
execute_entity_task(tasks.mu_star_calibration, gdirs)
# Inversion tasks
execute_entity_task(tasks.prepare_for_inversion, gdirs)
# We use the default parameters for this run
execute_entity_task(tasks.mass_conservation_inversion, gdirs)
execute_entity_task(tasks.filter_inversion_output, gdirs)
df = utils.compile_glacier_statistics(gdirs)
df['inv_thickness_m'] = df['inv_volume_km3'] / df['rgi_area_km2'] * 1e3
assert df.inv_thickness_m[0] < 100
df = utils.compile_fixed_geometry_mass_balance(gdirs)
assert len(df) > 100
if do_plot:
import matplotlib.pyplot as plt
from oggm.graphics import plot_inversion
plot_inversion(gdirs)
plt.show()
def test_extend_past_climate():
# wip
from MBsandbox.mbmod_daily_oneflowline import (
compile_fixed_geometry_mass_balance_TIModel,
extend_past_climate_run_TIModel)
cfg.initialize()
cfg.PATHS[
'working_dir'] = '/home/lilianschuster/Schreibtisch/PhD/oggm_files/all'
gdirs = workflow.init_glacier_directories(['RGI60-11.00897'])
gdir = gdirs[0]
dataset = 'WFDE5_CRU'
typ = 'mb_pseudo_daily_cte'
ensemble = 'mri-esm2-0_r1i1p1f1'
cfg.PARAMS['hydro_month_nh'] = 1
ssp = 'ssp126'
#process_w5e5_data(gdir, temporal_resol='monthly',
# output_filesuffix='_monthly_WFDE5_CRU')
#process_isimip_data(gdir, ensemble=ensemble, ssp=ssp,
# climate_historical_filesuffix='_monthly_WFDE5_CRU',
# temporal_resol='monthly'
# )
utils._workflow.compile_glacier_statistics([gdir], filesuffix=dataset)
oggm.utils._workflow.compile_run_output(
[gdir],
input_filesuffix='_ISIMIP3b_{}_mri-esm2-0_r1i1p1f1_{}_historical_test'.
format(dataset, typ))
compile_fixed_geometry_mass_balance_TIModel(
[gdir],
climate_input_filesuffix=dataset,
filesuffix='_{}_{}'.format(dataset, typ),
csv=True,
ys=1999,
ye=2013,
prcp_fac=2,
melt_f=200)
gpath = '/home/lilianschuster/Schreibtisch/PhD/oggm_files/all/per_glacier/RGI60-11/RGI60-11.00/RGI60-11.00897/'
extend_past_climate_run_TIModel(
past_run_file=
'/home/lilianschuster/Schreibtisch/PhD/oggm_files/all/run_output_ISIMIP3b_WFDE5_CRU_mri-esm2-0_r1i1p1f1_mb_pseudo_daily_cte_historical_test.nc',
fixed_geometry_mb_file=
'/home/lilianschuster/Schreibtisch/PhD/oggm_files/all/fixed_geometry_mass_balance_{}_{}.csv'
.format(dataset, typ),
glacier_statistics_file=
'/home/lilianschuster/Schreibtisch/PhD/oggm_files/all/glacier_statistics_{}_{}.csv'
.format(dataset, typ),
path=gpath + 'extended_test.nc',
use_compression=True)
def test_ensemble_workflow(self, case_dir):
cfg.initialize()
cfg.PARAMS['prcp_scaling_factor'] = 1.6
cfg.PATHS['working_dir'] = case_dir
cfg.PARAMS['use_multiprocessing'] = True
cfg.PARAMS['store_diagnostic_variables'] = ['volume', 'area']
# Go - get the pre-processed glacier directories
rgi_ids = ['RGI60-03.04384']
gdirs = workflow.init_glacier_directories(
rgi_ids,
from_prepro_level=5,
prepro_base_url=prepro_base_url,
prepro_border=80,
prepro_rgi_version='62')
workflow.execute_entity_task(parse_dt_per_dt, gdirs)
exp = 'netzero_py2050_fac1.0_decr0.3'
magicc_file = magicc_dir + exp + '.nc'
with xr.open_dataset(utils.file_downloader(magicc_file),
decode_times=False) as ds:
ds = ds.load()
odf = pd.DataFrame()
for q in ds['quantile'].data:
df = ds.global_mean_temperature.sel(quantile=q).to_series()
workflow.execute_entity_task(tasks.run_with_hydro,
gdirs,
run_task=run_from_magicc_data,
magicc_ts=df,
init_model_filesuffix='_historical',
output_filesuffix='_{:.2f}'.format(q))
ods = utils.compile_run_output(gdirs,
filesuffix='_{:.2f}'.format(q))
odf[q] = ods.volume.isel(rgi_id=0).to_series()
odf = odf / odf.iloc[0, 0]
assert odf.loc[2150].std() > 0.05
assert_allclose(odf.loc[2010].std(), 0, atol=1e-3)
assert_allclose(odf.loc[2300].std(), 0, atol=1e-2)
if DO_PLOT:
odf.plot(title='Ensemble stuff')
plt.show()
def pre_process_tasks(run_for_test=False):
path10 = utils.get_rgi_region_file('10', '61')
path13 = utils.get_rgi_region_file('13', '61')
path14 = utils.get_rgi_region_file('14', '61')
path15 = utils.get_rgi_region_file('15', '61')
rgidf10 = gpd.read_file(path10)
rgidf10 = rgidf10[rgidf10.O2Region == '4']
rgidf13 = gpd.read_file(path13)
rgidf14 = gpd.read_file(path14)
rgidf15 = gpd.read_file(path15)
rgidf = pd.concat([rgidf10, rgidf13, rgidf14, rgidf15])
if (not run_in_cluster) or run_for_test:
rgidf = rgidf10.iloc[0:5, :]
cfg.initialize()
cfg.PARAMS['border'] = 160
cfg.PATHS['working_dir'] = utils.mkdir(working_dir)
cfg.PARAMS['continue_on_error'] = True
cfg.PARAMS['use_multiprocessing'] = True
gdirs = workflow.init_glacier_directories(rgidf, from_prepro_level=1,
reset=True, force=True)
task_list = [
tasks.define_glacier_region,
tasks.glacier_masks,
tasks.compute_centerlines,
tasks.initialize_flowlines,
tasks.compute_downstream_line,
tasks.compute_downstream_bedshape,
tasks.catchment_area,
tasks.catchment_intersections,
tasks.catchment_width_geom,
tasks.catchment_width_correction,
tasks.process_cru_data,
tasks.local_t_star,
tasks.mu_star_calibration,
tasks.prepare_for_inversion,
tasks.mass_conservation_inversion,
tasks.filter_inversion_output,
tasks.init_present_time_glacier
]
for task in task_list:
workflow.execute_entity_task(task, gdirs)
return gdirs
def gdir():
cfg.initialize()
test_dir = '/home/lilianschuster/Schreibtisch/PhD/oggm_files/MBsandbox_tests'
if not os.path.exists(test_dir):
test_dir = utils.gettempdir(dirname='OGGM_MBsandbox_test', reset=True)
cfg.PATHS['working_dir'] = test_dir
base_url = ('https://cluster.klima.uni-bremen.de/~oggm/gdirs/oggm_v1.4/'
'L1-L2_files/elev_bands')
df = ['RGI60-11.00897']
gdirs = workflow.init_glacier_directories(df,
from_prepro_level=2,
prepro_border=10,
prepro_base_url=base_url,
prepro_rgi_version='62')
return gdirs[0]
def test_dt_per_dt(self, case_dir):
cfg.initialize()
cfg.PARAMS['prcp_scaling_factor'] = 1.6
cfg.PATHS['working_dir'] = case_dir
# Go - get the pre-processed glacier directories
gdirs = workflow.init_glacier_directories(
['RGI60-11.00897', 'RGI60-03.04384'],
from_prepro_level=5,
prepro_base_url=prepro_base_url,
prepro_border=80,
prepro_rgi_version='62')
workflow.execute_entity_task(parse_dt_per_dt, gdirs)
dt1 = gdirs[0].get_diagnostics()['magicc_dt_per_dt']
dt2 = gdirs[1].get_diagnostics()['magicc_dt_per_dt']
assert dt1 < 0.7 * dt2
dp1 = gdirs[0].get_diagnostics()['magicc_dp_per_dt']
dp2 = gdirs[1].get_diagnostics()['magicc_dp_per_dt']
assert dp1 < dp2
assert dp2 < 0.2
workflow.execute_entity_task(parse_dt_per_dt, gdirs, monthly=True)
dt1m = np.asarray(gdirs[0].get_diagnostics()['magicc_dt_per_dt'])
dt2m = np.asarray(gdirs[1].get_diagnostics()['magicc_dt_per_dt'])
assert_allclose(dt1m.mean(), dt1, atol=1e-3)
assert_allclose(dt2m.mean(), dt2, atol=1e-3)
dp1m = np.asarray(gdirs[0].get_diagnostics()['magicc_dp_per_dt'])
dp2m = np.asarray(gdirs[1].get_diagnostics()['magicc_dp_per_dt'])
# This is not always so the same because of averaging months with
# different precips
assert_allclose(dp1m.mean(), dp1, atol=3e-2)
assert_allclose(dp2m.mean(), dp2, atol=3e-2)
def test_multiple_models():
# test directory
testdir = os.path.join(get_test_dir(), 'tmp_mdir')
utils.mkdir(testdir, reset=True)
# Init
cfg.initialize()
cfg.set_intersects_db(get_demo_file('rgi_intersect_oetztal.shp'))
cfg.PATHS['dem_file'] = get_demo_file('hef_srtm.tif')
cfg.PATHS['climate_file'] = get_demo_file('histalp_merged_hef.nc')
cfg.PATHS['working_dir'] = testdir
cfg.PARAMS['baseline_climate'] = 'CUSTOM'
cfg.PARAMS['trapezoid_lambdas'] = 1
cfg.PARAMS['border'] = 40
apply_test_ref_tstars()
# Get the RGI ID
hef_rgi = gpd.read_file(get_demo_file('divides_hef.shp'))
hef_rgi.loc[0, 'RGIId'] = 'RGI50-11.00897'
gdirs = workflow.init_glacier_directories(hef_rgi)
workflow.gis_prepro_tasks(gdirs)
workflow.climate_tasks(gdirs)
workflow.inversion_tasks(gdirs)
models = []
for gdir in gdirs:
flowline.init_present_time_glacier(gdir)
fls = gdir.read_pickle('model_flowlines')
models.append(flowline.FlowlineModel(fls))
fig, ax = plt.subplots()
graphics.plot_modeloutput_map(gdirs, ax=ax, model=models)
fig.tight_layout()
shutil.rmtree(testdir)
return fig
def test_geodetic_glaciologicalMB_HEF():
cfg.initialize()
cfg.PARAMS['use_multiprocessing'] = False
working_dir = '/home/lilianschuster/Schreibtisch/PhD/oggm_files/oneFlowline'
# this needs to be changed if working on another computer
if not os.path.exists(working_dir):
working_dir = utils.gettempdir(dirname='OGGM_mb_type_intercomparison', reset=True)
cfg.PATHS['working_dir'] = working_dir
# use Huss flowlines
base_url = ('https://cluster.klima.uni-bremen.de/~oggm/gdirs/oggm_v1.4/'
'L1-L2_files/elev_bands')
# get HEF glacier
df = utils.get_rgi_glacier_entities(['RGI60-11.00897'])
gdirs = workflow.init_glacier_directories(df, from_prepro_level=2,
prepro_border=10,
prepro_base_url=base_url,
prepro_rgi_version='62')
gd = gdirs[0]
h, w = gd.get_inversion_flowline_hw()
fls = gd.read_pickle('inversion_flowlines')
cfg.PARAMS['baseline_climate'] = 'ERA5dr'
oggm.shop.ecmwf.process_ecmwf_data(gd, dataset='ERA5dr')
######################
# test area is similar to OGGM gdir HEF area
np.testing.assert_allclose(pd_geodetic_alps.loc['RGI60-11.00897'].area, gd.rgi_area_km2, rtol=0.01)
glaciological_mb_data_HEF_mean = gd.get_ref_mb_data()['ANNUAL_BALANCE'].loc[2000:].mean() #.sel(2000,2020)
# test if mass balance in period 2000 and 2020 of glaciological method is similar to the geodetic one
np.testing.assert_allclose(pd_geodetic_alps.loc['RGI60-11.00897'].dmdtda*1000,
glaciological_mb_data_HEF_mean, rtol = 0.05 )
def test_chhota_shigri():
testdir = os.path.join(get_test_dir(), 'tmp_chhota')
utils.mkdir(testdir, reset=True)
# Init
cfg.initialize()
cfg.PATHS['dem_file'] = get_demo_file('dem_chhota_shigri.tif')
cfg.PARAMS['border'] = 80
cfg.PARAMS['use_intersects'] = False
cfg.PATHS['working_dir'] = testdir
cfg.PARAMS['trapezoid_lambdas'] = 1
hef_file = get_demo_file('divides_RGI50-14.15990.shp')
df = gpd.read_file(hef_file)
df['Area'] = df.Area * 1e-6 # cause it was in m2
df['RGIId'] = ['RGI50-14.15990' + d for d in ['_d01', '_d02']]
gdirs = workflow.init_glacier_directories(df)
workflow.gis_prepro_tasks(gdirs)
for gdir in gdirs:
climate.apparent_mb_from_linear_mb(gdir)
workflow.execute_entity_task(inversion.prepare_for_inversion, gdirs)
workflow.execute_entity_task(inversion.mass_conservation_inversion, gdirs)
workflow.execute_entity_task(inversion.filter_inversion_output, gdirs)
workflow.execute_entity_task(flowline.init_present_time_glacier, gdirs)
models = []
for gdir in gdirs:
flowline.init_present_time_glacier(gdir)
fls = gdir.read_pickle('model_flowlines')
models.append(flowline.FlowlineModel(fls))
fig, ax = plt.subplots()
graphics.plot_modeloutput_map(gdirs, ax=ax, model=models)
fig.tight_layout()
shutil.rmtree(testdir)
return fig
def test_varying_bias_workflow(self, case_dir):
cfg.initialize()
cfg.PARAMS['prcp_scaling_factor'] = 1.6
cfg.PATHS['working_dir'] = case_dir
cfg.PARAMS['use_multiprocessing'] = True
# Go - get the pre-processed glacier directories
gdirs = workflow.init_glacier_directories(
['RGI60-11.00897'],
from_prepro_level=5,
prepro_base_url=prepro_base_url,
prepro_border=80,
prepro_rgi_version='62')
workflow.execute_entity_task(parse_dt_per_dt, gdirs)
gdir = gdirs[0]
exp = 'netzero_py2020_fac1.0_decr0.3'
magicc_file = magicc_dir + exp + '.nc'
with xr.open_dataset(utils.file_downloader(magicc_file),
decode_times=False) as ds:
ds = ds.load()
df = ds['ens_avg'].to_dataframe()
run_from_magicc_data(gdir,
magicc_ts=df['ens_avg'],
init_model_filesuffix='_historical',
output_filesuffix='_' + exp)
with xr.open_dataset(
gdir.get_filepath('model_diagnostics',
filesuffix='_' + exp)) as ds:
df['vol'] = ds.volume_m3.to_series()
assert ds.time[0] == 2009
assert ds.time[-1] == 2301
assert ds.volume_m3.isel(time=0) > ds.volume_m3.isel(time=-1)
assert ds.volume_m3.min() < ds.volume_m3.isel(time=-1)
def test_ssp585_problem():
from oggm import cfg, utils, workflow, tasks, graphics
from oggm.core import massbalance, flowline, climate
import logging
log = logging.getLogger(__name__)
cfg.initialize()
cfg.PATHS['working_dir'] = utils.gettempdir(dirname='test', reset=False)
gdirs = workflow.init_glacier_directories(
['RGI60-11.03238'], #'RGI60-11.03677'], #'RGI60-11.03471'],
from_prepro_level=2,
prepro_border=10,
prepro_base_url=base_url,
prepro_rgi_version='62',
)
gdir = gdirs[0]
cfg.PARAMS['hydro_month_nh'] = 1
ssp = 'ssp585'
process_w5e5_data(gdir, temporal_resol='monthly', climate_type='WFDE5_CRU')
process_isimip_data(gdir,
ensemble=ensemble,
ssp=ssp,
climate_historical_filesuffix='_monthly_WFDE5_CRU',
temporal_resol='monthly')
def gdir():
""" Provides a copy of the base Hintereisenferner glacier directory in
a case directory specific to the current test class using the single
elev_bands as flowlines. All cases in
the test class will use the same copy of this glacier directory.
"""
cfg.initialize()
cfg.PARAMS['use_multiprocessing'] = False
test_dir = '/home/lilianschuster/Schreibtisch/PhD/oggm_files/MBsandbox_tests'
if not os.path.exists(test_dir):
test_dir = utils.gettempdir(dirname='OGGM_MBsandbox_test',
reset=True)
cfg.PATHS['working_dir'] = test_dir
base_url = ('https://cluster.klima.uni-bremen.de/~oggm/gdirs/oggm_v1.4/'
'L1-L2_files/elev_bands')
df = ['RGI60-11.00897']
gdirs = workflow.init_glacier_directories(df, from_prepro_level=2,
prepro_border=10,
prepro_base_url=base_url,
prepro_rgi_version='62')
return gdirs[0]
#!/usr/bin/env python
# coding: utf-8
# Extract glacier directories
import os
import geopandas as gpd
from oggm import cfg, utils, workflow
# define paths
prepro_dir = '/home/users/moberrauch/run_output/vas_prepro'
working_dir = '/home/users/moberrauch/wdirs/historical'
# OGGM initialization
cfg.initialize()
cfg.PATHS['working_dir'] = working_dir
# specify RGI version and regions
rgi_version = '62'
rgi_regions = [11, 13, 14, 15]
# get RGI IDs
for rgi_region in rgi_regions:
fpath = utils.get_rgi_region_file(rgi_region, rgi_version)
if rgi_region == rgi_regions[0]:
rgi_ids = gpd.read_file(fpath)
else:
rgi_ids = rgi_ids.append(gpd.read_file(fpath))
# extract working directories from *.tar files
workflow.init_glacier_directories(rgi_ids, from_tar=prepro_dir)
pd_geodetic_comp_alps = pd_geodetic_comp_alps.loc[
pd_geodetic_comp_alps['solid_prcp_mean_nopf_weighted_{}_{}'.format(
dataset, typ)] >= 0]
pd_geodetic_comp_alps = pd_geodetic_comp_alps[[
'dmdtda', 'err_dmdtda', 'dmdtda_2000_2010', 'err_dmdtda_2000_2010',
'dmdtda_2010_2020', 'err_dmdtda_2010_2020', 'reg', 'area',
'solid_prcp_mean_nopf_weighted_{}_{}'.format(dataset, typ),
'max_allowed_specificMB'
]].astype(float)
# pd_geodetic_comp_alps = pd_geodetic_comp.loc[pd_geodetic_comp.reg==11.0]
if reset_gdir:
gdirs = workflow.init_glacier_directories(
pd_geodetic_comp_alps.dropna().index[start_ind:end_ind].values,
from_prepro_level=2,
prepro_border=10,
prepro_base_url=base_url,
prepro_rgi_version='62')
if mb_type != 'mb_real_daily':
cfg.PARAMS['baseline_climate'] = 'ERA5dr'
workflow.execute_entity_task(tasks.process_ecmwf_data,
gdirs,
dataset='ERA5dr')
else:
cfg.PARAMS['baseline_climate'] = 'ERA5_daily'
for gd in pd_geodetic_comp_alps.index[start_ind:end_ind]:
process_era5_daily_data(gd)
elif compute_missing:
#raise NotImplementedError('this has to be adapted')
def seek_start_area(rgi_id,
name,
show=False,
path='',
ref=np.NaN,
adjust_term_elev=False,
legend=True,
instant_geometry_change=False):
""" Set up an VAS model from scratch and run/test the start area seeking
tasks. The result is a plot showing the modeled glacier area evolution for
different start values. The plots can be displayed and/or stored to file.
Parameters
----------
rgi_id: string
RGI ID denoting the glacier on which to perform the tasks
name: string
Name og glacier, since it is not always given (or correct) in RGI
show: bool, optional, default=False
Flag deciding whether or not to show the created plots.
path: string, optional, default=''
Path under which the modeled area plot should be stored.
ref: float, optional, default=np.NaN
Historic (1851) reference area with which a reference model run is
performed.
"""
# Initialization and load default parameter file
vascaling.initialize()
# compute RGI region and version from RGI IDs
# assuming they all are all the same
rgi_region = (rgi_id.split('-')[-1]).split('.')[0]
rgi_version = (rgi_id.split('-')[0])[-2:-1]
# specify working directory and output directory
working_dir = os.path.abspath('../working_directories/start_area/')
# output_dir = os.path.abspath('./vas_run_output')
output_dir = os.path.abspath('../data/vas_run_output')
# create working directory
utils.mkdir(working_dir, reset=False)
utils.mkdir(output_dir)
# set path to working directory
cfg.PATHS['working_dir'] = working_dir
# set RGI version and region
cfg.PARAMS['rgi_version'] = rgi_version
# define how many grid points to use around the glacier,
# if you expect the glacier to grow large use a larger border
cfg.PARAMS['border'] = 20
# we use HistAlp climate data
cfg.PARAMS['baseline_climate'] = 'HISTALP'
# set the mb hyper parameters accordingly
cfg.PARAMS['prcp_scaling_factor'] = 1.75
cfg.PARAMS['temp_melt'] = -1.75
cfg.PARAMS['run_mb_calibration'] = False
# the bias is defined to be zero during the calibration process,
# which is why we don't use it here to reproduce the results
cfg.PARAMS['use_bias_for_run'] = True
# get/downlaod the rgi entity including the outline shapefile
rgi_df = utils.get_rgi_glacier_entities([rgi_id])
# set name, if 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'] = name
# get and set path to intersect shapefile
intersects_db = utils.get_rgi_intersects_region_file(region=rgi_region)
cfg.set_intersects_db(intersects_db)
# initialize the GlacierDirectory
gdir = workflow.init_glacier_directories(rgi_df)[0]
# # DEM and GIS tasks
# # get the path to the DEM file (will download if necessary)
# dem = utils.get_topo_file(gdir.cenlon, gdir.cenlat)
# print('DEM source: {}, path to DEM file: {}'.format(dem[1], dem[0][0]))
# # 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)
gis.glacier_masks(gdir)
# process climate data
climate.process_climate_data(gdir)
# compute local t* and the corresponding mu*
vascaling.local_t_star(gdir)
# create mass balance model
mb_mod = vascaling.VAScalingMassBalance(gdir)
# look at specific mass balance over climate data period
min_hgt, max_hgt = vascaling.get_min_max_elevation(gdir)
y0 = 1851
y1 = 2014
# run scalar minimization
minimize_res = vascaling.find_start_area(
gdir,
adjust_term_elev=adjust_term_elev,
instant_geometry_change=instant_geometry_change)
# print(minimize_res)
# stop script if minimization was not successful
if minimize_res.status and False:
sys.exit(minimize_res.status)
# instance glacier with today's values
model_ref = vascaling.VAScalingModel(year_0=gdir.rgi_date,
area_m2_0=gdir.rgi_area_m2,
min_hgt=min_hgt,
max_hgt=max_hgt,
mb_model=mb_mod)
# instance guessed starting areas
num = 9
area_guess = np.linspace(1e6,
np.floor(gdir.rgi_area_m2 * 2),
num,
endpoint=True)
# create empty containers
area_list = list()
volume_list = list()
spec_mb_list = list()
# iterate over all starting areas
for area_ in area_guess:
# instance iteration model
model_guess = vascaling.VAScalingModel(year_0=gdir.rgi_date,
area_m2_0=gdir.rgi_area_m2,
min_hgt=min_hgt,
max_hgt=max_hgt,
mb_model=mb_mod)
# set new starting values
model_guess.create_start_glacier(area_,
y0,
adjust_term_elev=adjust_term_elev)
# run model and save years and area
best_guess_ds = model_guess.run_until_and_store(
year_end=model_ref.year,
instant_geometry_change=instant_geometry_change)
# create series and store in container
area_list.append(best_guess_ds.area_m2.to_dataframe()['area_m2'])
volume_list.append(best_guess_ds.volume_m3.to_dataframe()['volume_m3'])
spec_mb_list.append(best_guess_ds.spec_mb.to_dataframe()['spec_mb'])
# create DataFrame
area_df = pd.DataFrame(
area_list, index=['{:.2f}'.format(a / 1e6) for a in area_guess])
area_df.index.name = 'Start Area [km$^2$]'
volume_df = pd.DataFrame(
volume_list, index=['{:.2f}'.format(a / 1e6) for a in area_guess])
volume_df.index.name = 'Start Area [km$^2$]'
# set up model with resulted starting area
model = vascaling.VAScalingModel(year_0=model_ref.year_0,
area_m2_0=model_ref.area_m2_0,
min_hgt=model_ref.min_hgt_0,
max_hgt=model_ref.max_hgt,
mb_model=model_ref.mb_model)
model.create_start_glacier(minimize_res.x,
y0,
adjust_term_elev=adjust_term_elev)
# run model with best guess initial area
best_guess_ds = model.run_until_and_store(
year_end=model_ref.year,
instant_geometry_change=instant_geometry_change)
# run model with historic reference area
if ref:
model.reset()
model.create_start_glacier(ref * 1e6,
y0,
adjust_term_elev=adjust_term_elev)
ref_ds = model.run_until_and_store(
year_end=model_ref.year,
instant_geometry_change=instant_geometry_change)
# create figure and add axes
fig = plt.figure(figsize=[5, 5])
ax = fig.add_axes([0.125, 0.075, 0.85, 0.9])
# plot model output
ax = (area_df / 1e6).T.plot(legend=False, colormap='Spectral', ax=ax)
# plot best guess
ax.plot(
best_guess_ds.time,
best_guess_ds.area_m2 / 1e6,
color='k',
ls='--',
lw=1.2,
label=
f'{best_guess_ds.area_m2.isel(time=0).values/1e6:.2f} km$^2$ (best result)'
)
# plot reference
if ref:
ax.plot(
ref_ds.time,
ref_ds.area_m2 / 1e6,
color='k',
ls='-.',
lw=1.2,
label=
f'{ref_ds.area_m2.isel(time=0).values/1e6:.2f} km$^2$ (1850 ref.)')
# plot 2003 reference line
ax.axhline(
model_ref.area_m2_0 / 1e6,
c='k',
ls=':',
label=f'{model_ref.area_m2_0/1e6:.2f} km$^2$ ({gdir.rgi_date} obs.)')
# add legend
if legend:
handels, labels = ax.get_legend_handles_labels()
labels[:-3] = [r'{} km$^2$'.format(l) for l in labels[:-3]]
leg = ax.legend(handels, labels, loc='upper right', ncol=2)
# leg.set_title('Start area $A_0$', prop={'size': 12})
# replot best guess estimate and reference (in case it lies below another
# guess)
ax.plot(best_guess_ds.time,
best_guess_ds.area_m2 / 1e6,
color='k',
ls='--',
lw=1.2)
if ref:
ax.plot(ref_ds.time, ref_ds.area_m2 / 1e6, color='k', ls='-.', lw=1.2)
# labels, title
ax.set_xlim([best_guess_ds.time.values[0], best_guess_ds.time.values[-1]])
ax.set_xlabel('')
ax.set_ylabel('Glacier area [km$^2$]')
# save figure to file
if path:
fig.savefig(path)
# show plot
if show:
plt.show()
plt.clf()
# plot and store volume evolution
(volume_df / 1e9).T.plot(legend=False, colormap='viridis')
plt.gcf().savefig(path[:-4] + '_volume.pdf')
# check geometries
#for idx, row in entity.iterrows():
# if entity.geometry.iloc[idx].type != 'Polygon':
# print(row['RGIId'] + row.geometry.type)
# Local working directory (where OGGM will write its output)
WORKING_DIR = utils.gettempdir('User_past_mb', reset=True)
utils.mkdir(WORKING_DIR, reset=True)
cfg.PATHS['working_dir'] = WORKING_DIR
#cfg.PATHS['working_dir'] = utils.gettempdir('user', reset=True)
#cfg.PATHS['working_dir'] = utils.gettempdir(dirname='OGGM-GettingStarted', reset=True)
# glacier directory
gdirs = workflow.init_glacier_directories(
entity
) #, prepro_base_url=base_url) # <- from prepro_level uses preprocessed files
#rgi_id = gdir.rgi_id
#gdir.rgi_date = outline_year
# update gdir outline year
for gdir in gdirs:
gdir.rgi_date = outline_year
# glacier region
#tasks.define_glacier_region(gdir, source='USER') # set user dem, this works for single glacier
workflow.execute_entity_task(tasks.define_glacier_region, gdirs,
source='USER') # when using multiple glaciers
# plot glacier
#graphics.plot_domain(gdirs[0])
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_ecmwf_historical_delta_method(self, class_case_dir):
# 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')
hef_file = get_demo_file('Hintereisferner_RGI5.shp')
gdir = workflow.init_glacier_directories(gpd.read_file(hef_file))[0]
tasks.process_ecmwf_data(gdir,
dataset='ERA5',
output_filesuffix='ERA5')
tasks.process_ecmwf_data(gdir,
dataset='CERA',
output_filesuffix='CERA')
# Original BC
tasks.historical_delta_method(gdir,
replace_with_ref_data=False,
delete_input_files=False,
ref_filesuffix='ERA5',
hist_filesuffix='CERA',
output_filesuffix='CERA_alone')
f_ref = gdir.get_filepath('climate_historical', filesuffix='ERA5')
f_h = gdir.get_filepath('climate_historical', filesuffix='CERA_alone')
with xr.open_dataset(f_ref) as ref, xr.open_dataset(f_h) as his:
# Let's do some basic checks
assert ref.attrs['ref_hgt'] == his.attrs['ref_hgt']
ci = gdir.get_climate_info('CERA_alone')
assert ci['baseline_climate_source'] == 'CERA|ERA5'
assert ci['baseline_hydro_yr_0'] == 1902
assert ci['baseline_hydro_yr_1'] == 2010
# Climate on common period
# (minus one year because of the automated stuff in code
sref = ref.sel(time=slice(ref.time[12], his.time[-1]))
shis = his.sel(time=slice(ref.time[12], his.time[-1]))
# Climate during the chosen period should be the same
np.testing.assert_allclose(sref.temp.mean(),
shis.temp.mean(),
atol=1e-3)
np.testing.assert_allclose(sref.prcp.mean(),
shis.prcp.mean(),
rtol=1e-3)
# And also the annual cycle
srefm = sref.groupby('time.month').mean(dim='time')
shism = shis.groupby('time.month').mean(dim='time')
np.testing.assert_allclose(srefm.temp, shism.temp, atol=1e-3)
np.testing.assert_allclose(srefm.prcp, shism.prcp, rtol=1e-3)
# And its std dev - but less strict
srefm = sref.groupby('time.month').std(dim='time')
shism = shis.groupby('time.month').std(dim='time')
np.testing.assert_allclose(srefm.temp, shism.temp, rtol=5e-2)
with pytest.raises(AssertionError):
# This clearly is not scaled
np.testing.assert_allclose(srefm.prcp, shism.prcp, rtol=0.5)
# Replaced
tasks.historical_delta_method(gdir,
replace_with_ref_data=True,
delete_input_files=False,
ref_filesuffix='ERA5',
hist_filesuffix='CERA',
output_filesuffix='CERA_repl')
f_ref = gdir.get_filepath('climate_historical', filesuffix='ERA5')
f_h = gdir.get_filepath('climate_historical', filesuffix='CERA_repl')
f_hr = gdir.get_filepath('climate_historical', filesuffix='CERA')
with xr.open_dataset(f_ref) as ref, xr.open_dataset(f_h) as his, \
xr.open_dataset(f_hr) as his_ref:
# Let's do some basic checks
assert ref.attrs['ref_hgt'] == his.attrs['ref_hgt']
ci = gdir.get_climate_info('CERA_repl')
assert ci['baseline_climate_source'] == 'CERA+ERA5'
assert ci['baseline_hydro_yr_0'] == 1902
assert ci['baseline_hydro_yr_1'] == 2018
# Climate on common period
sref = ref.sel(time=slice(ref.time[0], his.time[-1]))
shis = his.sel(time=slice(ref.time[0], his.time[-1]))
# Climate during the chosen period should be the same
np.testing.assert_allclose(sref.temp.mean(), shis.temp.mean())
np.testing.assert_allclose(sref.prcp.mean(), shis.prcp.mean())
# And also the annual cycle
srefm = sref.groupby('time.month').mean(dim='time')
shism = shis.groupby('time.month').mean(dim='time')
np.testing.assert_allclose(srefm.temp, shism.temp)
np.testing.assert_allclose(srefm.prcp, shism.prcp)
# And its std dev - should be same
srefm = sref.groupby('time.month').std(dim='time')
shism = shis.groupby('time.month').std(dim='time')
np.testing.assert_allclose(srefm.temp, shism.temp)
np.testing.assert_allclose(srefm.prcp, shism.prcp)
# In the past the two CERA datasets are different
his_ref = his_ref.sel(time=slice('1910', '1940'))
his = his.sel(time=slice('1910', '1940'))
assert np.abs(his.temp.mean() - his_ref.temp.mean()) > 1
assert np.abs(his.temp.std() - his_ref.temp.std()) > 0.3
# Delete files
tasks.historical_delta_method(gdir,
ref_filesuffix='ERA5',
hist_filesuffix='CERA')
assert not os.path.exists(
gdir.get_filepath('climate_historical', filesuffix='ERA5'))
assert not os.path.exists(
gdir.get_filepath('climate_historical', filesuffix='CERA'))
cfg.PARAMS['hydro_month_nh']=1
pd_geodetic_comp_alps = pd.read_csv(
'/home/users/lschuster/bayesian_calibration/WFDE5_ISIMIP/alps_geodetic_solid_prcp.csv',
)
pd_geodetic_comp_alps.index = pd_geodetic_comp_alps.rgiid
# TODO: check if this is right!!!
y0 = 1979
ye = 2018+1
if step=='ice_thickness_calibration':
print(len(pd_geodetic_comp_alps.dropna().index.values))
gdirs = workflow.init_glacier_directories( pd_geodetic_comp_alps.dropna().index.values)
print(len(gdirs))
# cfg.set_logging_config(logging_level='WARNING')
# Get end date. The first gdir might have blown up, try some others
#if start_ind != 0 and end_ind < 3400:
# sys.exit(
print('we want to calibrate for all Alpine glaciers at once, so all glaciers are selected, even if start_ind or end_ind are given')
for mb_type in ['mb_monthly', 'mb_pseudo_daily', 'mb_real_daily']:
for grad_type in ['cte', 'var_an_cycle']:
# compute apparent mb from any mb ...
print(mb_type, grad_type)
if glen_a == 'single':
#This is old code that doesn't work and is less efficient but left here just in case
#rgidf = rgidf.drop(rgidf[rgidf.Area < 1.0].index)
##Added in section to convert to pandas dataframe and print out file if needed/check data
#rgidf.to_file('/Users/louis/workflow_test/rgidf.shp')
##Convert to pandas dataframe then print
#rgipdf = pd.DataFrame(rgidf)
#rgipdf.to_csv('/Users/louis/workflow_test/rgipdf.csv')
#Start the run
log.workflow('Starting OGGM run')
log.workflow('Number of glaciers: {}'.format(len(rgidf)))
#Go get the pre-processed glacier directories, this will eventually be reduced to prepro = 1 but for now need the climate files in the glacier directories.
gdirs = workflow.init_glacier_directories(rgidf, from_prepro_level=1)
#Run the prepro tasks on the dem to get flowlines using the generic processing etc. This could be broken down if we don't want certain tasks.
workflow.gis_prepro_tasks(gdirs)
#Process the climate data
log.info('Process the climate data...')
workflow.execute_entity_task(tasks.process_climate_data, gdirs, y1=2018)
#Run the climate calibrations based on the new mass balance data, this mass balance data should be in the Working directory folder.
workflow.execute_entity_task(tasks.local_t_star, gdirs)
workflow.execute_entity_task(tasks.mu_star_calibration, gdirs)
#Run the inversion tools ahead of the model runs
#First set the paramters we can change, currently OGGM default ones:
# Deformation: from Cuffey and Patterson 2010
glen_a = 2.4e-24
# Sliding: from Oerlemans 1997
fs = 5.7e-20
#Prep the data for inversion
# Other params: see https://oggm.org/2018/08/10/histalp-parameters/
cfg.PARAMS['prcp_scaling_factor'] = 1.75
cfg.PARAMS['temp_melt'] = -1.75
# Local paths (where to find the OGGM run output)
dirname = 'OGGM_ref_mb_{}_RGIV{}_OGGM{}'.format(baseline, rgi_version,
oggm.__version__)
WORKING_DIR = utils.gettempdir(dirname, home=True)
cfg.PATHS['working_dir'] = WORKING_DIR
# Read the rgi ids of the reference glaciers
rids = pd.read_csv(os.path.join(WORKING_DIR, 'mb_ref_glaciers.csv'),
index_col=0, squeeze=True)
# Go - initialize glacier directories
gdirs = workflow.init_glacier_directories(rids)
# Cross-validation
file = os.path.join(cfg.PATHS['working_dir'], 'ref_tstars.csv')
ref_df = pd.read_csv(file, index_col=0)
for i, gdir in enumerate(gdirs):
print('Cross-validation iteration {} of {}'.format(i + 1, len(ref_df)))
# Now recalibrate the model blindly
tmp_ref_df = ref_df.loc[ref_df.index != gdir.rgi_id]
tasks.local_t_star(gdir, ref_df=tmp_ref_df)
tasks.mu_star_calibration(gdir)
# Mass-balance model with cross-validated parameters instead
mb_mod = MultipleFlowlineMassBalance(gdir, mb_model_class=PastMassBalance,
# Module logger
log = logging.getLogger(__name__)
log.workflow('Starting run for RGI reg {}'.format(rgi_reg))
# RGI glaciers
rgi_ids = gpd.read_file(
utils.get_rgi_region_file(rgi_reg, version=rgi_version))
# For greenland we omit connectivity level 2
if rgi_reg == '05':
rgi_ids = rgi_ids.loc[rgi_ids['Connect'] != 2]
# Go - get the pre-processed glacier directories
base_url = 'https://cluster.klima.uni-bremen.de/~fmaussion/gdirs/final_prepro_cmip6/era5_eb'
gdirs = workflow.init_glacier_directories(rgi_ids,
from_prepro_level=5,
prepro_base_url=base_url,
prepro_rgi_version=rgi_version)
gcms = pd.read_csv('/home/www/oggm/cmip6/all_gcm_list.csv', index_col=0)
n_gcms = len(sys.argv) - 1
for gcm in sys.argv[1:]:
df1 = gcms.loc[gcms.gcm == gcm]
for ssp in df1.ssp.unique():
df2 = df1.loc[df1.ssp == ssp]
assert len(df2) == 2
ft = df2.loc[df2['var'] == 'tas'].iloc[0]
fp = df2.loc[df2['var'] == 'pr'].iloc[0].path
rid = ft.fname.replace('_r1i1p1f1_tas.nc', '')
ft = ft.path
def test_mb(self):
# This is a function to produce the MB function needed by Anna
# Download the RGI file for the run
# Make a new dataframe of those
rgidf = gpd.read_file(get_demo_file('SouthGlacier.shp'))
# Go - initialize working directories
gdirs = workflow.init_glacier_directories(rgidf)
# Preprocessing tasks
task_list = [
tasks.define_glacier_region,
tasks.glacier_masks,
tasks.compute_centerlines,
tasks.initialize_flowlines,
tasks.catchment_area,
tasks.catchment_intersections,
tasks.catchment_width_geom,
tasks.catchment_width_correction,
]
for task in task_list:
execute_entity_task(task, gdirs)
execute_entity_task(tasks.process_cru_data,
gdirs,
tmp_file=self.tf,
pre_file=self.pf)
execute_entity_task(tasks.local_t_star, gdirs)
execute_entity_task(tasks.mu_star_calibration, gdirs)
mbref = salem.GeoTiff(get_demo_file('mb_SouthGlacier.tif'))
demref = salem.GeoTiff(get_demo_file('dem_SouthGlacier.tif'))
mbref = mbref.get_vardata()
mbref[mbref == -9999] = np.NaN
demref = demref.get_vardata()[np.isfinite(mbref)]
mbref = mbref[np.isfinite(mbref)] * 1000
# compute the bias to make it 0 SMB on the 2D DEM
rho = cfg.PARAMS['ice_density']
mbmod = ConstantMassBalance(gdirs[0], bias=0)
mymb = mbmod.get_annual_mb(demref) * cfg.SEC_IN_YEAR * rho
mbmod = ConstantMassBalance(gdirs[0], bias=np.average(mymb))
mymb = mbmod.get_annual_mb(demref) * cfg.SEC_IN_YEAR * rho
np.testing.assert_allclose(np.average(mymb), 0., atol=1e-3)
# Same for ref
mbref = mbref - np.average(mbref)
np.testing.assert_allclose(np.average(mbref), 0., atol=1e-3)
# Fit poly
p = np.polyfit(demref, mbref, deg=2)
poly = np.poly1d(p)
myfit = poly(demref)
np.testing.assert_allclose(np.average(myfit), 0., atol=1e-3)
if do_plot:
import matplotlib.pyplot as plt
plt.scatter(mbref,
demref,
s=5,
label='Obs (2007-2012), shifted to Avg(SMB) = 0')
plt.scatter(mymb, demref, s=5, label='OGGM MB at t*')
plt.scatter(myfit, demref, s=5, label='Polyfit', c='C3')
plt.xlabel('MB (mm w.e yr-1)')
plt.ylabel('Altidude (m)')
plt.legend()
plt.show()
