def test_init_present_time_glacier(self): gdirs = up_to_inversion() # Inversion Results cfg.PARAMS['invert_with_sliding'] = True cfg.PARAMS['optimize_thick'] = True workflow.inversion_tasks(gdirs) fpath = os.path.join(cfg.PATHS['working_dir'], 'inversion_optim_results.csv') df = pd.read_csv(fpath, index_col=0) r1 = rmsd(df['ref_volume_km3'], df['oggm_volume_km3']) r2 = rmsd(df['ref_volume_km3'], df['vas_volume_km3']) self.assertTrue(r1 < r2) cfg.PARAMS['invert_with_sliding'] = False cfg.PARAMS['optimize_thick'] = False workflow.inversion_tasks(gdirs) fpath = os.path.join(cfg.PATHS['working_dir'], 'inversion_optim_results.csv') df = pd.read_csv(fpath, index_col=0) r1 = rmsd(df['ref_volume_km3'], df['oggm_volume_km3']) r2 = rmsd(df['ref_volume_km3'], df['vas_volume_km3']) self.assertTrue(r1 < r2) # Init glacier d = gdirs[0].read_pickle('inversion_params') fs = d['fs'] glen_a = d['glen_a'] maxs = cfg.PARAMS['max_shape_param'] for gdir in gdirs: flowline.init_present_time_glacier(gdir) mb_mod = massbalance.ConstantMassBalanceModel(gdir) fls = gdir.read_pickle('model_flowlines') model = flowline.FluxBasedModel(fls, mb_model=mb_mod, y0=0., fs=fs, glen_a=glen_a) _vol = model.volume_km3 _area = model.area_km2 if gdir.rgi_id in df.index: gldf = df.loc[gdir.rgi_id] # TODO: broken but should work # assert_allclose(gldf['oggm_volume_km3'], _vol, rtol=0.03) # assert_allclose(gldf['ref_area_km2'], _area, rtol=0.03) maxo = max([fl.order for fl in model.fls]) for fl in model.fls: self.assertTrue(np.all(fl.bed_shape > 0)) self.assertTrue(np.all(fl.bed_shape <= maxs)) if len(model.fls) > 1: if fl.order == (maxo-1): self.assertTrue(fl.flows_to is fls[-1]) # Test the glacier charac dfc = utils.glacier_characteristics(gdirs) self.assertTrue(np.all(dfc.terminus_type == 'Land-terminating')) cc = dfc[['dem_mean_elev', 'clim_temp_avgh']].corr().values[0, 1] self.assertTrue(cc > 0.4)
def test_init_present_time_glacier(self): gdirs = up_to_inversion() # Inversion Results cfg.PARAMS['invert_with_sliding'] = True cfg.PARAMS['optimize_thick'] = True workflow.inversion_tasks(gdirs) fpath = os.path.join(cfg.PATHS['working_dir'], 'inversion_optim_results.csv') df = pd.read_csv(fpath, index_col=0) r1 = rmsd(df['ref_volume_km3'], df['oggm_volume_km3']) assert r1 < 0.1 cfg.PARAMS['invert_with_sliding'] = False cfg.PARAMS['optimize_thick'] = False workflow.inversion_tasks(gdirs) fpath = os.path.join(cfg.PATHS['working_dir'], 'inversion_optim_results.csv') df = pd.read_csv(fpath, index_col=0) r1 = rmsd(df['ref_volume_km3'], df['oggm_volume_km3']) assert r1 < 0.12 # Init glacier d = gdirs[0].read_pickle('inversion_params') fs = d['fs'] glen_a = d['glen_a'] for gdir in gdirs: flowline.init_present_time_glacier(gdir) mb_mod = massbalance.ConstantMassBalance(gdir) fls = gdir.read_pickle('model_flowlines') model = flowline.FluxBasedModel(fls, mb_model=mb_mod, y0=0., fs=fs, glen_a=glen_a) _vol = model.volume_km3 _area = model.area_km2 if gdir.rgi_id in df.index: gldf = df.loc[gdir.rgi_id] assert_allclose(gldf['oggm_volume_km3'], _vol, rtol=0.05) assert_allclose(gldf['ref_area_km2'], _area, rtol=0.05) maxo = max([fl.order for fl in model.fls]) for fl in model.fls: if len(model.fls) > 1: if fl.order == (maxo-1): self.assertTrue(fl.flows_to is fls[-1]) # Test the glacier charac dfc = utils.glacier_characteristics(gdirs) self.assertTrue(np.all(dfc.terminus_type == 'Land-terminating')) cc = dfc[['flowline_mean_elev', 'tstar_avg_temp_mean_elev']].corr().values[0, 1] assert cc < -0.8 assert np.all(dfc.t_star > 1900) assert np.all(dfc.tstar_aar.mean() > 0.5)
def test_some_characs(self): gdirs = up_to_inversion() # Test the glacier charac dfc = utils.glacier_characteristics(gdirs) self.assertTrue(np.all(dfc.terminus_type == 'Land-terminating')) cc = dfc[['flowline_mean_elev', 'tstar_avg_temp_mean_elev']].corr().values[0, 1] assert cc < -0.8 assert np.all(dfc.t_star > 1900) assert np.all(dfc.tstar_aar.mean() > 0.5)
def test_glacier_characs(self): gdir = init_hef() df = utils.glacier_characteristics([gdir], path=False) assert len(df) == 1 assert np.all(~df.isnull()) df = df.iloc[0] np.testing.assert_allclose(df['dem_mean_elev'], df['flowline_mean_elev'], atol=5) np.testing.assert_allclose(df['tstar_avg_prcp'], 2853, atol=5) np.testing.assert_allclose(df['tstar_avg_prcpsol_max_elev'], 2811, atol=5)
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_regions(rgidf) # Preprocessing tasks task_list = [ 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) # Climate tasks -- only data IO and tstar interpolation! execute_entity_task(tasks.process_cru_data, gdirs) tasks.distribute_t_stars(gdirs) execute_entity_task(tasks.apparent_mb, gdirs) # Inversion tasks execute_entity_task(tasks.prepare_for_inversion, gdirs) # We use the default parameters for this run execute_entity_task(tasks.volume_inversion, gdirs, glen_a=cfg.A, fs=0) execute_entity_task(tasks.filter_inversion_output, gdirs) df = utils.glacier_characteristics(gdirs) assert df.inv_thickness_m[0] < 100 if do_plot: import matplotlib.pyplot as plt from oggm.graphics import plot_inversion plot_inversion(gdirs) plt.show()
def optimize_per_glacier(gdirs): gtd_df = _prepare_inv(gdirs) ref_gdirs = gtd_df['ref_gdirs'] ref_volume_km3 = gtd_df['ref_volume_km3'] ref_area_km2 = gtd_df['ref_area_km2'] ref_thickness_m = gtd_df['ref_thickness_m'] # Optimize without sliding log.info('Compute the inversion parameter.') fac = [] for gdir in ref_gdirs: def to_optimize(x): glen_a = cfg.A * x[0] v, a = invert_parabolic_bed(gdir, glen_a=glen_a, fs=0., write=False) return utils.rmsd(v / a, gtd_df['ref_thickness_m'].loc[gdir.rgi_id]) opti = optimization.minimize(to_optimize, [1.], bounds=((0.01, 10), ), tol=1.e-4) # Check results and save. fac.append(opti['x'][0]) # All results df = utils.glacier_characteristics(ref_gdirs) df['ref_area_km2'] = ref_area_km2 df['ref_volume_km3'] = ref_volume_km3 df['ref_thickness_m'] = ref_thickness_m df['vas_volume_km3'] = 0.034*(df['ref_area_km2']**1.375) df['vas_thickness_m'] = df['vas_volume_km3'] / ref_area_km2 * 1000 df['fac'] = fac fpath = os.path.join(cfg.PATHS['working_dir'], 'inversion_optim_pergla.csv') df.to_csv(fpath)
def optimize_thick(gdirs): """Optimizes fd based on GlaThiDa thicknesses. We use the glacier averaged thicknesses provided by GlaThiDa and correct them for differences in area with RGI, using a glacier specific volume-area scaling formula. Parameters ---------- gdirs: list of oggm.GlacierDirectory objects """ gtd_df = _prepare_inv(gdirs) ref_gdirs = gtd_df['ref_gdirs'] ref_volume_km3 = gtd_df['ref_volume_km3'] ref_area_km2 = gtd_df['ref_area_km2'] ref_thickness_m = gtd_df['ref_thickness_m'] # Optimize without sliding log.info('Compute the inversion parameter.') def to_optimize(x): tmp_ = np.zeros(len(ref_gdirs)) glen_a = cfg.A * x[0] for i, gdir in enumerate(ref_gdirs): v, a = mass_conservation_inversion(gdir, glen_a=glen_a, fs=0., write=False) tmp_[i] = v / a return utils.rmsd(tmp_, ref_thickness_m) opti = optimization.minimize(to_optimize, [1.], bounds=((0.01, 10), ), tol=1.e-4) # Check results and save. glen_a = cfg.A * opti['x'][0] fs = 0. # This is for the stats oggm_volume_m3 = np.zeros(len(ref_gdirs)) rgi_area_m2 = np.zeros(len(ref_gdirs)) for i, gdir in enumerate(ref_gdirs): v, a = mass_conservation_inversion(gdir, glen_a=glen_a, fs=fs, write=False) oggm_volume_m3[i] = v rgi_area_m2[i] = a assert np.allclose(rgi_area_m2 * 1e-6, ref_area_km2) # This is for each glacier out = dict() out['glen_a'] = glen_a out['fs'] = fs out['factor_glen_a'] = opti['x'][0] try: out['factor_fs'] = opti['x'][1] except IndexError: out['factor_fs'] = 0. for gdir in gdirs: gdir.write_pickle(out, 'inversion_params') # This is for the working dir # Simple stats out['vol_rmsd'] = utils.rmsd(oggm_volume_m3 * 1e-9, ref_volume_km3) out['thick_rmsd'] = utils.rmsd(oggm_volume_m3 / (ref_area_km2 * 1e6), ref_thickness_m) log.info('Optimized glen_a and fs with a factor {factor_glen_a:.2f} and ' '{factor_fs:.2f} for a thick RMSD of {thick_rmsd:.3f}'.format( **out)) df = pd.DataFrame(out, index=[0]) fpath = os.path.join(cfg.PATHS['working_dir'], 'inversion_optim_params.csv') df.to_csv(fpath) # All results df = utils.glacier_characteristics(ref_gdirs) df['ref_area_km2'] = ref_area_km2 df['ref_volume_km3'] = ref_volume_km3 df['ref_thickness_m'] = ref_thickness_m df['oggm_volume_km3'] = oggm_volume_m3 * 1e-9 df['oggm_thickness_m'] = oggm_volume_m3 / (ref_area_km2 * 1e6) df['vas_volume_km3'] = 0.034*(df['ref_area_km2']**1.375) df['vas_thickness_m'] = df['vas_volume_km3'] / ref_area_km2 * 1000 rgi_id = [gdir.rgi_id for gdir in ref_gdirs] df = pd.DataFrame(df, index=rgi_id) fpath = os.path.join(cfg.PATHS['working_dir'], 'inversion_optim_results.csv') df.to_csv(fpath) # return value for tests return out
tasks.compute_downstream_bedshape(gdir) tasks.catchment_area(gdir) tasks.catchment_intersections(gdir) tasks.catchment_width_geom(gdir) tasks.catchment_width_correction(gdir) tasks.process_cru_data(gdir) tasks.mu_candidates(gdir) tasks.compute_ref_t_stars([gdir]) tasks.distribute_t_stars([gdir]) tasks.apparent_mb(gdir) tasks.prepare_for_inversion(gdir) tasks.volume_inversion(gdir, glen_a=cfg.A, fs=0) tasks.filter_inversion_output(gdir) tasks.init_present_time_glacier(gdir) df = utils.glacier_characteristics([gdir], path=False) reset = True seed = 0 tasks.random_glacier_evolution(gdir, nyears=800, seed=0, y0=2000, filesuffix='_2000_def', reset=reset) tasks.random_glacier_evolution(gdir, nyears=800, seed=0, y0=1920,
tasks.catchment_width_correction, ] if RUN_GIS_PREPRO: for task in task_list: execute_entity_task(task, gdirs) if RUN_CLIMATE_PREPRO: for gdir in gdirs: gdir.inversion_calving_rate = 0 execute_entity_task(tasks.process_cru_data, gdirs) tasks.distribute_t_stars(gdirs) execute_entity_task(tasks.apparent_mb, gdirs) if RUN_INVERSION: # Inversion tasks execute_entity_task(tasks.prepare_for_inversion, gdirs, add_debug_var=True) execute_entity_task(tasks.volume_inversion, gdirs, glen_a=3.339e-24, fs=0.0) # Compile output utils.glacier_characteristics(gdirs, filesuffix='_Lake_land_no_calving_fs_zero_') # Log m, s = divmod(time.time() - start, 60) h, m = divmod(m, 60) log.info("OGGM is done! Time needed: %02d:%02d:%02d" % (h, m, s))
# Sort for more efficient parallel computing rgidf = rgidf.sort_values('Area', ascending=False) # rgidf = rgidf.loc[rgidf.RGIId.isin(['RGI50-01.10299'])] print('Number of glaciers: {}'.format(len(rgidf))) # Go - initialize working directories # ----------------------------------- # you can use the command below to reset your run -- use with caution! # gdirs = workflow.init_glacier_regions(rgidf, reset=True, force=True) gdirs = workflow.init_glacier_regions(rgidf) utils.glacier_characteristics(gdirs) utils.compile_run_output(gdirs, filesuffix='_fromzero') utils.compile_run_output(gdirs, filesuffix='_fromzero_newparams') utils.compile_run_output(gdirs, filesuffix='_fromtoday') utils.compile_run_output(gdirs, filesuffix='_fromtoday_newparams') exit() # Prepro tasks task_list = [ # tasks.glacier_masks, # tasks.compute_centerlines, # tasks.compute_downstream_lines, # tasks.initialize_flowlines, # tasks.compute_downstream_bedshape, # tasks.catchment_area,
all_calving_data = objt['calving_fluxes'] all_data_depth = objt['water_depth'] all_data_H_i = objt['H_ice'] all_data_width = objt['t_width'] # we see the final calculated calving flux last_calving = all_calving_data[-1] last_width = all_data_width print('For the glacier', gdir.rgi_id) print('last calving value is:', last_calving) gdir.inversion_calving_rate = last_calving # Calculating everything again with a calving flux assigned and filtering # and correcting for negative flux cfg.PARAMS['correct_for_neg_flux'] = False cfg.PARAMS['filter_for_neg_flux'] = False tasks.distribute_t_stars(gdirs) execute_entity_task(tasks.apparent_mb, gdirs) execute_entity_task(tasks.prepare_for_inversion, gdirs, add_debug_var=True) execute_entity_task(tasks.volume_inversion, gdirs, glen_a=cfg.A, fs=cfg.FS) # Write out glacier statistics utils.glacier_characteristics(gdirs, filesuffix='_with_calving_' + suf, inversion_only=True) m, s = divmod(time.time() - start, 60) h, m = divmod(m, 60) log.info("OGGM with calving is done! Time needed: %02d:%02d:%02d" % (h, m, s))
def setup_cache(self): setattr(full_workflow.setup_cache, "timeout", 360) utils.mkdir(self.testdir, reset=True) self.cfg_init() # Pre-download other files which will be needed later utils.get_cru_cl_file() utils.get_cru_file(var='tmp') utils.get_cru_file(var='pre') # Get the RGI glaciers for the run. rgi_list = ['RGI60-01.10299', 'RGI60-11.00897', 'RGI60-18.02342'] rgidf = utils.get_rgi_glacier_entities(rgi_list) # We use intersects db = utils.get_rgi_intersects_region_file(version='61', rgi_ids=rgi_list) cfg.set_intersects_db(db) # Sort for more efficient parallel computing rgidf = rgidf.sort_values('Area', ascending=False) # Go - initialize working directories gdirs = workflow.init_glacier_regions(rgidf) # Preprocessing tasks task_list = [ 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, ] for task in task_list: execute_entity_task(task, gdirs) # Climate tasks -- only data IO and tstar interpolation! execute_entity_task(tasks.process_cru_data, gdirs) execute_entity_task(tasks.local_mustar, gdirs) execute_entity_task(tasks.apparent_mb, 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) # Final preparation for the run execute_entity_task(tasks.init_present_time_glacier, gdirs) # Random climate representative for the tstar climate, without bias # In an ideal world this would imply that the glaciers remain stable, # but it doesn't have to be so execute_entity_task(tasks.run_constant_climate, gdirs, bias=0, nyears=100, output_filesuffix='_tstar') execute_entity_task(tasks.run_constant_climate, gdirs, y0=1990, nyears=100, output_filesuffix='_pd') # Compile output utils.glacier_characteristics(gdirs) utils.compile_run_output(gdirs, filesuffix='_tstar') utils.compile_run_output(gdirs, filesuffix='_pd') utils.compile_climate_input(gdirs) return gdirs
tasks.initialize_flowlines, tasks.catchment_area, tasks.catchment_intersections, tasks.catchment_width_geom, tasks.catchment_width_correction, ] if RUN_GIS_PREPRO: for task in task_list: execute_entity_task(task, gdirs) if RUN_CLIMATE_PREPRO: for gdir in gdirs: gdir.inversion_calving_rate = 0 execute_entity_task(tasks.process_cru_data, gdirs) tasks.distribute_t_stars(gdirs) execute_entity_task(tasks.apparent_mb, gdirs) if RUN_INVERSION: # Inversion tasks execute_entity_task(tasks.prepare_for_inversion, gdirs, add_debug_var=True) execute_entity_task(tasks.volume_inversion, gdirs, glen_a=cfg.A, fs=cfg.FS) # Compile output utils.glacier_characteristics(gdirs, filesuffix='_no_calving_cfgFS_') # Log m, s = divmod(time.time() - start, 60) h, m = divmod(m, 60) log.info("OGGM is done! Time needed: %02d:%02d:%02d" % (h, m, s))
task_list = [ 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) # Climate tasks -- we make sure that calving is = 0 for all tidewater for gdir in gdirs: gdir.inversion_calving_rate = 0 execute_entity_task(tasks.process_cru_data, gdirs) tasks.distribute_t_stars(gdirs) execute_entity_task(tasks.apparent_mb, gdirs) # Inversion tasks execute_entity_task(tasks.prepare_for_inversion, gdirs, add_debug_var=True) execute_entity_task(tasks.volume_inversion, gdirs, glen_a=cfg.A, fs=cfg.FS) # Compile output utils.glacier_characteristics(gdirs, filesuffix='_Columbia_no_calving_with_sliding_') # Log m, s = divmod(time.time() - start, 60) h, m = divmod(m, 60) log.info("OGGM is done! Time needed: %02d:%02d:%02d" % (h, m, s))
def optimize_thick(gdirs): """Optimizes fd based on GlaThiDa thicknesses. We use the glacier averaged thicknesses provided by GlaThiDa and correct them for differences in area with RGI, using a glacier specific volume-area scaling formula. Parameters ---------- gdirs: list of oggm.GlacierDirectory objects """ gtd_df = _prepare_inv(gdirs) ref_gdirs = gtd_df['ref_gdirs'] ref_volume_km3 = gtd_df['ref_volume_km3'] ref_area_km2 = gtd_df['ref_area_km2'] ref_thickness_m = gtd_df['ref_thickness_m'] # Optimize without sliding log.info('Compute the inversion parameter.') def to_optimize(x): tmp_ = np.zeros(len(ref_gdirs)) glen_a = cfg.A * x[0] for i, gdir in enumerate(ref_gdirs): v, a = invert_parabolic_bed(gdir, glen_a=glen_a, fs=0., write=False) tmp_[i] = v / a return utils.rmsd(tmp_, ref_thickness_m) opti = optimization.minimize(to_optimize, [1.], bounds=((0.01, 10), ), tol=1.e-4) # Check results and save. glen_a = cfg.A * opti['x'][0] fs = 0. # This is for the stats oggm_volume_m3 = np.zeros(len(ref_gdirs)) rgi_area_m2 = np.zeros(len(ref_gdirs)) for i, gdir in enumerate(ref_gdirs): v, a = invert_parabolic_bed(gdir, glen_a=glen_a, fs=fs, write=False) oggm_volume_m3[i] = v rgi_area_m2[i] = a assert np.allclose(rgi_area_m2 * 1e-6, ref_area_km2) # This is for each glacier out = dict() out['glen_a'] = glen_a out['fs'] = fs out['factor_glen_a'] = opti['x'][0] try: out['factor_fs'] = opti['x'][1] except IndexError: out['factor_fs'] = 0. for gdir in gdirs: gdir.write_pickle(out, 'inversion_params') # This is for the working dir # Simple stats out['vol_rmsd'] = utils.rmsd(oggm_volume_m3 * 1e-9, ref_volume_km3) out['thick_rmsd'] = utils.rmsd(oggm_volume_m3 / (ref_area_km2 * 1e6), ref_thickness_m) log.info( 'Optimized glen_a and fs with a factor {factor_glen_a:.2f} and ' '{factor_fs:.2f} for a thick RMSD of {thick_rmsd:.3f}'.format(**out)) df = pd.DataFrame(out, index=[0]) fpath = os.path.join(cfg.PATHS['working_dir'], 'inversion_optim_params.csv') df.to_csv(fpath) # All results df = utils.glacier_characteristics(ref_gdirs) df['ref_area_km2'] = ref_area_km2 df['ref_volume_km3'] = ref_volume_km3 df['ref_thickness_m'] = ref_thickness_m df['oggm_volume_km3'] = oggm_volume_m3 * 1e-9 df['oggm_thickness_m'] = oggm_volume_m3 / (ref_area_km2 * 1e6) df['vas_volume_km3'] = 0.034 * (df['ref_area_km2']**1.375) df['vas_thickness_m'] = df['vas_volume_km3'] / ref_area_km2 * 1000 rgi_id = [gdir.rgi_id for gdir in ref_gdirs] df = pd.DataFrame(df, index=rgi_id) fpath = os.path.join(cfg.PATHS['working_dir'], 'inversion_optim_results.csv') df.to_csv(fpath) # return value for tests return out
cfg.PARAMS['correct_for_neg_flux'] = False cfg.PARAMS['filter_for_neg_flux'] = False execute_entity_task(tasks.process_cru_data, gdirs) tasks.distribute_t_stars(gdirs) execute_entity_task(tasks.apparent_mb, gdirs) if RUN_INVERSION: # Inversion tasks execute_entity_task(tasks.prepare_for_inversion, gdirs) tasks.optimize_inversion_params(gdirs) execute_entity_task(tasks.volume_inversion, gdirs, ) # execute_entity_task(tasks.filter_inversion_output, gdirs) # Compile output if no calving if No_calving: utils.glacier_characteristics(gdirs, filesuffix='_no_calving') # Log m, s = divmod(time.time() - start, 60) h, m = divmod(m, 60) log.info("OGGM no_calving is done! Time needed: %02d:%02d:%02d" % (h, m, s)) # Calving loop # ----------------------------------- if With_calving: # Re-initializing climate tasks and inversion without calving to be sure for gdir in gdirs: gdir.inversion_calving_rate = 0 cfg.PARAMS['correct_for_neg_flux'] = False cfg.PARAMS['filter_for_neg_flux'] = False
# Inversion execute_entity_task(tasks.prepare_for_inversion, gdirs) execute_entity_task(tasks.volume_inversion, gdirs, glen_a=cfg.A, fs=0) execute_entity_task( tasks.filter_inversion_output, gdirs, ) # Run execute_entity_task(tasks.init_present_time_glacier, gdirs) # While the above should work always, this here is no piece of fun execute_entity_task(tasks.random_glacier_evolution, gdirs) # Write out glacier statistics df = utils.glacier_characteristics(gdirs) fpath = os.path.join(cfg.PATHS['working_dir'], 'glacier_char.csv') df.to_csv(fpath) # Plots (if you want) if PLOTS_DIR == '': exit() utils.mkdir(PLOTS_DIR) for gd in gdirs: bname = os.path.join(PLOTS_DIR, gd.name + '_' + gd.rgi_id + '_') graphics.plot_googlemap(gd) plt.savefig(bname + 'ggl.png') plt.close() graphics.plot_domain(gd) plt.savefig(bname + 'dom.png')
all_calving_data = objt['calving_fluxes'] all_data_depth = objt['water_depth'] all_data_H_i = objt['H_ice'] all_data_width = objt['t_width'] # we see the final calculated calving flux last_calving = all_calving_data[-1] last_width = all_data_width print('For the glacier', gdir.rgi_id) print('last calving value is:', last_calving) gdir.inversion_calving_rate = last_calving # Calculating everything again with a calving flux assigned and filtering # and correcting for negative flux cfg.PARAMS['correct_for_neg_flux'] = False cfg.PARAMS['filter_for_neg_flux'] = False tasks.distribute_t_stars(gdirs) execute_entity_task(tasks.apparent_mb, gdirs) execute_entity_task(tasks.prepare_for_inversion, gdirs, add_debug_var=True) execute_entity_task(tasks.volume_inversion, gdirs, glen_a=cfg.A, fs=cfg.FS) # Write out glacier statistics utils.glacier_characteristics(gdirs, filesuffix='_with_calving_corrected_' + suf) m, s = divmod(time.time() - start, 60) h, m = divmod(m, 60) log.info("OGGM with calving is done! Time needed: %02d:%02d:%02d" % (h, m, s))
tasks.compute_ref_t_stars([gdir]) tasks.distribute_t_stars([gdir]) tasks.apparent_mb(gdir) tasks.prepare_for_inversion(gdir) tasks.volume_inversion(gdir, glen_a=cfg.A, fs=0) tasks.filter_inversion_output(gdir) tasks.distribute_thickness(gdir, how='per_interpolation') tasks.init_present_time_glacier(gdir) # On single flowline run tasks.random_glacier_evolution(gdir, nyears=800, bias=0, seed=0, filesuffix='_fl_def', zero_initial_glacier=True) # For metadata utils.glacier_characteristics([gdir], path=base_dir+'/hef_fl_out.csv') # OK now the distributed stuffs with netCDF4.Dataset(gdir.get_filepath('gridded_data')) as nc: topo = nc.variables['topo'][:] ice_thick = nc.variables['thickness'][:] # Take a subset of the topo for easier regridding ds = gdir.grid.to_dataset() ds['topo'] = (('y', 'x'), topo) ds['ice_thick'] = (('y', 'x'), ice_thick) ds = ds.salem.subset(corners=((1, 3), (250, 202)), crs=gdir.grid) # Possible are factors 1 (50m) 2 (100m) or 5 (250m) factor = 2 topo = reduce(ds.topo.values, factor=factor)