igm-model 2.2.2__tar.gz → 2.2.3__tar.gz

{igm_model-2.2.2 → igm_model-2.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: igm-model
-Version: 2.2.2
+Version: 2.2.3
 Summary: IGM - a glacier evolution model
 Home-page: https://github.com/jouvetg/igm
 Author: Guillaume Jouvet
@@ -21,6 +21,16 @@ Requires-Dist: oggm
 Requires-Dist: salem
 Requires-Dist: pyyaml
 Requires-Dist: importlib_resources
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 [![License badge](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)
 ### <h1 align="center" id="title">The Instructed Glacier Model (IGM) </h1>
@@ -44,7 +54,7 @@ The Instructed Glacier Model (IGM) is an **open-source Python package**, which p
   
 # Documentation
 
-Start with the 10-min [video tutorial](https://vimeo.com/884003820). Then, all the documentation can be found on the dedicated [wiki](https://github.com/jouvetg/igm/wiki) and the the in-progress and open-to-contributions [technical paper](https://github.com/jouvetg/igm-paper/paper.pdf).
+Start with the 10-min [video tutorial](https://vimeo.com/884003820). Then, all the documentation can be found on the dedicated [wiki](https://github.com/jouvetg/igm/wiki) and the the in-progress and open-to-contributions [technical paper](https://github.com/jouvetg/igm-paper/blob/main/paper.pdf).
 
 # Discord channel
 

{igm_model-2.2.2 → igm_model-2.2.3}/README.md

@@ -20,7 +20,7 @@ The Instructed Glacier Model (IGM) is an **open-source Python package**, which p
   
 # Documentation
 
-Start with the 10-min [video tutorial](https://vimeo.com/884003820). Then, all the documentation can be found on the dedicated [wiki](https://github.com/jouvetg/igm/wiki) and the the in-progress and open-to-contributions [technical paper](https://github.com/jouvetg/igm-paper/paper.pdf).
+Start with the 10-min [video tutorial](https://vimeo.com/884003820). Then, all the documentation can be found on the dedicated [wiki](https://github.com/jouvetg/igm/wiki) and the the in-progress and open-to-contributions [technical paper](https://github.com/jouvetg/igm-paper/blob/main/paper.pdf).
 
 # Discord channel
 

{igm_model-2.2.2 → igm_model-2.2.3}/igm/modules/postproc/anim_plotly/anim_plotly.py

@@ -1,10 +1,7 @@
 #!/usr/bin/env python3
 import copy
-
 import numpy as np
-import os
 import json
-from types import SimpleNamespace
 import xarray as xr
 
 
@@ -45,45 +42,11 @@ def finalize(params, state):
                         ],
                         style={"margin-bottom": "10px"},
                     ),
-                    # slider for camera-position in x-y-plane
-                    html.Div(
-                        dcc.Slider(
-                            id="camera_angle",
-                            step=9,
-                            value=45,
-                            min=0,
-                            max=180,
-                            marks=None,
-                            drag_value=45,
-                            included=False,
-                        )
-                    ),
+
                     # 3D surface plot
                     dcc.Graph(id="mnt_surface", figure=fig),
                 ],
-                style={"width": "95%", "height": "800px", "display": "inline-block"},
-            ),
-            # slider for camera-position on z-axis
-            html.Div(
-                children=[
-                    dcc.Slider(
-                        id="camera_height",
-                        step=0.2,
-                        value=1.5,
-                        min=0,
-                        max=2,
-                        vertical=True,
-                        drag_value=1.5,
-                        marks=None,
-                        verticalHeight=600,
-                        included=False,
-                    )
-                ],
-                style={
-                    "width": "5%",
-                    "display": "inline-block",
-                    "text_align": "center",
-                },
+                style={"width": "100%", "height": "800px", "display": "inline-block"},
             ),
         ],
         style={
@@ -96,18 +59,11 @@ def finalize(params, state):
     @app.callback(
         Output("mnt_surface", "figure"),
         Input("property", "value"),
-        Input("camera_angle", "drag_value"),
-        Input("camera_height", "drag_value"),
     )
-    def updata_graph(property, camera_angle, camera_height):
-        # load params
-        path_to_json_saved = "params_saved.json"
-        with open(path_to_json_saved, "r") as json_file:
-            json_text = json_file.read()
-        params = json.loads(json_text, object_hook=lambda d: SimpleNamespace(**d))
-
+    def updata_graph(property):
         # read output.nc
-        ds = xr.open_dataset("output.nc", engine="netcdf4")
+        output_file = params.wncd_output_file
+        ds = xr.open_dataset(output_file, engine="netcdf4")
 
         # get attributes from ds
         bedrock = np.array(ds.topg[0])
@@ -204,7 +160,7 @@ def finalize(params, state):
                 z=bedrock_border,
                 x=lat_range,
                 y=lon_range,
-                colorscale='speed_r',
+                colorscale='gray',
                 opacity=1,
                 showlegend=True,
                 name="bedrock",
@@ -261,40 +217,35 @@ def finalize(params, state):
         ratio_z = (max_bedrock - min_bedrock) / (bedrock.shape[0] * resolution)
         ratio_z *= 2  # emphasize z-axis to make mountians look twice as steep
 
-        # transform angle[0-180] into values between [0, 1] for camera postion
-        radians = math.radians(camera_angle - 180)
-        camera_x = math.sin(-radians)
-        camera_y = math.cos(-radians)
-
         fig_dict = dict(
             data=frames[0]["data"],
             frames=frames,
             layout=dict(  # width=1800,
-                height=800,
+                height=900,
                 margin=dict(l=0, r=0, t=30, b=0),
                 sliders=[sliders_dict],
                 title=title,
                 font=dict(family="monospace"),
                 legend={"orientation": "h", "yanchor": "bottom", "xanchor": "left"},
                 scene=dict(
-                    zaxis=dict(showbackground=True, showticklabels=False, title=""),
+                    zaxis=dict(showbackground=False, showticklabels=False, title=""),
                     xaxis=dict(
                         showbackground=False,
-                        showticklabels=True,
+                        showticklabels=False,
                         visible=True,
                         range=[lat_range[0], lat_range[-1]],
-                        title="Longitude",
+                        title=""#"Longitude",
                     ),
                     yaxis=dict(
                         showbackground=False,
-                        showticklabels=True,
+                        showticklabels=False,
                         visible=True,
                         range=[lon_range[0], lon_range[-1]],
-                        title="Latitude",
+                        title=""#"Latitude",
+
                     ),
                 ),
                 scene_aspectratio=dict(x=1, y=ratio_y, z=ratio_z),
-                scene_camera_eye=dict(x=camera_x, y=camera_y, z=camera_height),
                 updatemenus=[
                     dict(
                         buttons=[
@@ -347,4 +298,23 @@ def finalize(params, state):
 
 
 if __name__ == "__main__":
-    finalize_anim_plotly(None, None)
+    import argparse
+    # Set up argument parser
+    parser = argparse.ArgumentParser(description="Load a JSON file and pass its content to finalize.")
+    parser.add_argument('--param_file',
+                        type=str,
+                        default='params_saved.json',
+                        help='Path to the JSON parameter file')
+
+    # Parse the command-line arguments
+    args = parser.parse_args()
+
+    # Load the JSON file
+    with open(args.param_file, 'r') as f:
+        param_dict = json.load(f)
+
+    # Convert the loaded JSON dictionary into a Namespace
+    param_data = argparse.Namespace(**param_dict)
+
+    # Call finalize with the loaded JSON data as the first argument
+    finalize(param_data, None)

igm_model-2.2.3/igm/modules/postproc/print_info/print_info.py

@@ -0,0 +1,65 @@
+#!/usr/bin/env python3
+
+# Copyright (C) 2021-2023 Guillaume Jouvet <guillaume.jouvet@unil.ch>
+# Published under the GNU GPL (Version 3), check at the LICENSE file
+
+import numpy as np
+import os
+import datetime
+import matplotlib.pyplot as plt
+import tensorflow as tf
+
+from igm.modules.utils import *
+
+def params(parser):
+    parser.add_argument(
+        "--print_mem_info",
+        type=str2bool,
+        default=False,
+        help="Additional info on memory usage",
+    )
+
+def initialize(params, state):
+    if params.print_mem_info:
+        print(
+            "IGM %s :         Iterations   |         Time (y)     |     Time Step (y)   |   Ice Volume (km^3)   |   GPU memory (MB) "
+        )
+    else:
+        print(
+            "IGM %s :         Iterations   |         Time (y)     |     Time Step (y)   |   Ice Volume (km^3) "
+        )
+
+
+def update(params, state):
+    """
+    This serves to print key info on the fly during computation
+    """
+    if state.saveresult:
+
+        if params.print_mem_info:
+            gpu_info = tf.config.experimental.get_memory_info("GPU:0")
+            print(
+                "IGM %s :      %6.0f    |      %8.0f        |     %7.2f        |     %10.2f         |     %10.2f "
+                % (
+                    datetime.datetime.now().strftime("%H:%M:%S"),
+                    state.it,
+                    state.t,
+                    state.dt_target,
+                    np.sum(state.thk) * (state.dx**2) / 10**9,
+                    gpu_info['current'] / 1024**2
+                )
+            )
+        else:    
+            print(
+                "IGM %s :      %6.0f    |      %8.0f        |     %7.2f        |     %10.2f "
+                % (
+                    datetime.datetime.now().strftime("%H:%M:%S"),
+                    state.it,
+                    state.t,
+                    state.dt_target,
+                    np.sum(state.thk) * (state.dx**2) / 10**9
+                )
+            )
+
+def finalize(params, state):
+    pass

{igm_model-2.2.2 → igm_model-2.2.3}/igm/modules/postproc/write_ncdf/write_ncdf.py

@@ -131,6 +131,9 @@ def update(params, state):
             E.axis = "X"
             E[:] = state.x.numpy()
 
+            if hasattr(state, 'pyproj_srs'):
+                nc.pyproj_srs = state.pyproj_srs
+
             if hasattr(params, "iflo_Nz"):
                 nc.createDimension("z", params.iflo_Nz)
                 E = nc.createVariable("z", np.dtype("float32").char, ("z",))

{igm_model-2.2.2 → igm_model-2.2.3}/igm/modules/preproc/load_ncdf/load_ncdf.py

@@ -139,7 +139,7 @@ def initialize(params, state):
             if var in ["x", "y"]:
                 vars(state)[var] = tf.constant(vars()[var].astype("float32"))
             else:
-                vars(state)[var] = tf.Variable(vars()[var].astype("float32"))
+                vars(state)[var] = tf.Variable(vars()[var].astype("float32"), trainable=False)
 
     nc.close()
 

{igm_model-2.2.2 → igm_model-2.2.3}/igm/modules/preproc/load_tif/load_tif.py

@@ -109,7 +109,7 @@ def initialize(params, state):
     # transform from numpy to tensorflow
     for file in files:
         var = os.path.split(file)[-1].split(".")[0]
-        vars(state)[var] = tf.Variable(vars()[var].astype("float32"))
+        vars(state)[var] = tf.Variable(vars()[var].astype("float32"), trainable=False)
 
     state.x = tf.constant(x.astype("float32"))
     state.y = tf.constant(y.astype("float32"))

{igm_model-2.2.2 → igm_model-2.2.3}/igm/modules/preproc/oggm_shop/oggm_shop.py

@@ -82,13 +82,20 @@ def params(parser):
         "--oggm_sub_entity_mask",
         type=str2bool,
         default=False,
-        help="Ice mask shows individual RGI 7.0G entities within each larger RGI 7.0C complex",
+        help=("Ice mask shows individual RGI 7.0G entities within each larger RGI 7.0C complex "
+              "(this is now unnecessary for igm_v4, but needs confirming since some tidwater stuff is computed as well)"),
     )
     parser.add_argument(
         "--oggm_RGI_product",
         type=str,
         default="G",
-        help="Glacier complexes (C) or individual basins (G) (default is G, individual basins)",
+        help="RGI7 Glacier complexes (C) or individual basins (G) (default is G, individual basins)",
+    )
+    parser.add_argument(
+        "--oggm_highres",
+        type=str2bool,
+        default=False,
+        help="OGGM offers high resolution data glacier directories, this will use it if available",
     )
     parser.add_argument(
         "--oggm_run_batch",
@@ -96,24 +103,44 @@ def params(parser):
         default=False,
         help="Run all the glaciers in the world",
     )
+    parser.add_argument(
+        "--smooth_obs_vel",
+        type=str2bool,
+        default=True,
+        help="Smooth the observed velocities",
+    )
 
 def initialize(params, state):
+
     import json
+    import rasterio
 
-    try:
+    # Fetch the data from OGGM
+    if not os.path.exists(params.oggm_RGI_ID):
         _oggm_util([params.oggm_RGI_ID], params)
-    except:
-        print('Server data issue?: '+params.oggm_RGI_ID)
+
+    ncpath = os.path.join(params.oggm_RGI_ID, "gridded_data.nc")
+    if not os.path.exists(ncpath):
+        msg = f'OGGM data issue with glacier {params.oggm_RGI_ID}'
+        if hasattr(state, "logger"):
+            state.logger.info(msg)
+        else:
+            print(msg)
         return
 
     if hasattr(state, "logger"):
         state.logger.info("Prepare data using oggm and glathida")
 
-    nc = Dataset(os.path.join(params.oggm_RGI_ID, "gridded_data.nc"), "r+")
+    nc = Dataset(ncpath, "r+")
 
     x = np.squeeze(nc.variables["x"]).astype("float32")
     y = np.flip(np.squeeze(nc.variables["y"]).astype("float32"))
-    
+
+    if hasattr(nc, 'pyproj_srs'):
+        pyproj_srs = nc.pyproj_srs
+    else:
+        pyproj_srs = None
+
     #If you know that grids above a certain size are going to make your GPU memory explode,
     #activating this commented block and setting the number in the if statement to your
     #maximum threshold will cause IGM to skip execution and move on to the next one
@@ -161,15 +188,12 @@ def initialize(params, state):
             uvelsurfobs = np.flipud(
                 np.squeeze(nc.variables["millan_vx"]).astype("float32")
             )
-            uvelsurfobs = np.where(np.isnan(uvelsurfobs), 0, uvelsurfobs)
-            
             uvelsurfobs = np.where(icemaskobs, uvelsurfobs, 0)
             vars_to_save += ["uvelsurfobs"]
         if "millan_vy" in nc.variables:
             vvelsurfobs = np.flipud(
                 np.squeeze(nc.variables["millan_vy"]).astype("float32")
             )
-            vvelsurfobs = np.where(np.isnan(vvelsurfobs), 0, vvelsurfobs)            
             vvelsurfobs = np.where(icemaskobs, vvelsurfobs, 0)
             vars_to_save += ["vvelsurfobs"]
         else:
@@ -182,28 +206,27 @@ def initialize(params, state):
             uvelsurfobs = np.flipud(
                 np.squeeze(nc.variables["itslive_vx"]).astype("float32")
             )
-            uvelsurfobs = np.where(np.isnan(uvelsurfobs), 0, uvelsurfobs)
             uvelsurfobs = np.where(icemaskobs, uvelsurfobs, 0)
             vars_to_save += ["uvelsurfobs"]
         if "itslive_vy" in nc.variables:
             vvelsurfobs = np.flipud(
                 np.squeeze(nc.variables["itslive_vy"]).astype("float32")
             )
-            vvelsurfobs = np.where(np.isnan(vvelsurfobs), 0, vvelsurfobs)
             vvelsurfobs = np.where(icemaskobs, vvelsurfobs, 0)
             vars_to_save += ["vvelsurfobs"]
 
-    uvelsurfobs = scipy.signal.medfilt2d(uvelsurfobs, kernel_size=3) # remove outliers
-    vvelsurfobs = scipy.signal.medfilt2d(vvelsurfobs, kernel_size=3) # remove outliers
+    if params.smooth_obs_vel:
+       uvelsurfobs = scipy.signal.medfilt2d(uvelsurfobs, kernel_size=3) # remove outliers
+       vvelsurfobs = scipy.signal.medfilt2d(vvelsurfobs, kernel_size=3) # remove outliers
 
-    if "millan_ice_thickness" in nc.variables:
+    if params.oggm_thk_source in nc.variables: # either "millan_ice_thickness" or "consensus_ice_thickness"
         thkinit = np.flipud(
-            np.squeeze(nc.variables["millan_ice_thickness"]).astype("float32")
+            np.squeeze(nc.variables[params.oggm_thk_source]).astype("float32")
         )
         thkinit = np.where(np.isnan(thkinit), 0, thkinit)
         thkinit = np.where(icemaskobs, thkinit, 0)
         vars_to_save += ["thkinit"]
-        
+
     if "hugonnet_dhdt" in nc.variables:
         dhdt = np.flipud(
             np.squeeze(nc.variables["hugonnet_dhdt"]).astype("float32")
@@ -219,7 +242,7 @@ def initialize(params, state):
             with open(os.path.join(params.oggm_RGI_ID, "glacier_grid.json"), "r") as f:
                 data = json.load(f)
             proj = data["proj"]
-    
+
             try:
                 thkobs = _read_glathida(
                     x, y, usurfobs, proj, params.oggm_path_glathida, state
@@ -229,7 +252,7 @@ def initialize(params, state):
                 thkobs = np.zeros_like(thk) * np.nan
         elif params.oggm_RGI_version==7:
             path_glathida = os.path.join(params.oggm_RGI_ID, "glathida_data.csv")
-    
+
             try:
                 thkobs = _read_glathida_v7(
                     x, y, path_glathida
@@ -247,8 +270,11 @@ def initialize(params, state):
     for var in ["x", "y"]:
         vars(state)[var] = tf.constant(vars()[var].astype("float32"))
 
+    if pyproj_srs is not None:
+        vars(state)["pyproj_srs"] = pyproj_srs
+
     for var in vars_to_save:
-        vars(state)[var] = tf.Variable(vars()[var].astype("float32"))
+        vars(state)[var] = tf.Variable(vars()[var].astype("float32"), trainable=False)
 
     complete_data(state)
 
@@ -270,6 +296,16 @@ def initialize(params, state):
             var_info["tidewatermask"] = ["Tidewater glacier mask", "no unit"]
             var_info["slopes"] = ["Average glacier surface slope", "deg"]
 
+        # Extract standardized OGGM projection information
+        with open(os.path.join(params.oggm_RGI_ID, "glacier_grid.json"), "r") as f:
+                proj = json.load(f)
+
+        # Access central dem.tif to extract actual EPSG number
+        # (failsafe to always check dem.tif)
+        # (can optionally also be inferred from 'proj' assuming always northern hemisphere UTM coordinates; not sure)
+        with rasterio.open(os.path.join(params.oggm_RGI_ID,'dem.tif')) as dem_ds:
+            dst_crs = dem_ds.crs
+
         nc = Dataset(
             os.path.join("input_saved.nc"), "w", format="NETCDF4"
         )
@@ -290,6 +326,18 @@ def initialize(params, state):
         xn.axis = "X"
         xn[:] = x
 
+        if pyproj_srs is not None:
+            # Write globale attribute in netCDF output file
+            nc.pyproj_srs = pyproj_srs
+            nc.setncattr('pyproj_crs',str(proj))
+            nc.setncattr('epsg',str(dst_crs))
+            nc.pyproj_crs = str(proj)
+            nc.epsg = str(dst_crs)
+        else:
+            # Write globale attribute in netCDF output file
+            nc.pyproj_crs = str(proj)
+            nc.epsg = str(dst_crs)
+
         for v in vars_to_save:
             E = nc.createVariable(v, np.dtype("float32").char, ("y", "x"))
             E.long_name = var_info[v][0]
@@ -312,7 +360,7 @@ def finalize(params, state):
 
     if params.oggm_remove_RGI_folder:
         try:
-            shutil.rmtree(params.oggm_RGI_ID) 
+            shutil.rmtree(params.oggm_RGI_ID)
         except Exception as error:
             print("Error: ", error)
 
@@ -345,7 +393,7 @@ def _oggm_util(RGIs, params):
         # Initialize OGGM and set up the default run parameters
         cfg.initialize_minimal()
 
-        cfg.PARAMS["continue_on_error"] = False
+        cfg.PARAMS["continue_on_error"] = True
         cfg.PARAMS["use_multiprocessing"] = False
 
         WD = "OGGM-prepro"
@@ -366,7 +414,11 @@ def _oggm_util(RGIs, params):
             )
         else:
             rgi_ids = RGIs
-            base_url = ( "https://cluster.klima.uni-bremen.de/~oggm/gdirs/oggm_v1.6/exps/igm_v3" )
+            if params.oggm_highres:
+                base_url = ( "https://cluster.klima.uni-bremen.de/~oggm/gdirs/oggm_v1.6/exps/igm_v4_hr" )
+            else:
+                base_url = ( "https://cluster.klima.uni-bremen.de/~oggm/gdirs/oggm_v1.6/exps/igm_v4" )
+
             gdirs = workflow.init_glacier_directories(
                 # Start from level 3 if you want some climate data in them
                 rgi_ids,
@@ -447,15 +499,15 @@ def _oggm_util(RGIs, params):
         from oggm.shop import bedtopo
 
         workflow.execute_entity_task(bedtopo.add_consensus_thickness, gdirs)
-        
+
         from oggm.shop import glathida
 
         workflow.execute_entity_task(glathida.glathida_to_gdir, gdirs)
-        
+
         from oggm.shop.w5e5 import process_w5e5_data
 
         workflow.execute_entity_task(process_w5e5_data, gdirs)
-        
+
         workflow.execute_entity_task(tasks.elevation_band_flowline, gdirs)
         workflow.execute_entity_task(tasks.fixed_dx_elevation_band_flowline, gdirs)
         workflow.execute_entity_task(tasks.mb_calibration_from_geodetic_mb,
@@ -491,7 +543,7 @@ def _read_glathida(x, y, usurf, proj, path_glathida, state):
 
     files = glob.glob(os.path.join(path_glathida, "glathida", "data", "*", "point.csv"))
     files += glob.glob(os.path.join(path_glathida, "glathida", "data", "point.csv"))
-   
+
     os.path.expanduser
 
     transformer = Transformer.from_crs(proj, "epsg:4326", always_xy=True)
@@ -508,8 +560,8 @@ def _read_glathida(x, y, usurf, proj, path_glathida, state):
     df = pd.concat(
         [pd.read_csv(file, low_memory=False) for file in files], ignore_index=True
     )
-    
-    
+
+
     mask = (
         (lonmin <= df["longitude"])
         & (df["longitude"] <= lonmax)
@@ -546,12 +598,15 @@ def _read_glathida(x, y, usurf, proj, path_glathida, state):
         elevation_normalized = fsurf(xx, yy, grid=False)
         thickness_normalized = np.maximum(elevation_normalized - bedrock, 0)
 
+        dx = x[1]-x[0]
+        dy = y[1]-y[0]
+        
         # Rasterize thickness
         thickness_gridded = (
             pd.DataFrame(
                 {
-                    "col": np.floor((xx - np.min(x)) / (x[1] - x[0])).astype(int),
-                    "row": np.floor((yy - np.min(y)) / (y[1] - y[0])).astype(int),
+                    "col": np.floor((xx - np.min(x) + dx/2) / dx).astype(int),
+                    "row": np.floor((yy - np.min(y) + dy/2) / dy).astype(int),
                     "thickness": thickness_normalized,
                 }
             )
@@ -566,33 +621,33 @@ def _read_glathida(x, y, usurf, proj, path_glathida, state):
 
 def _read_glathida_v7(x, y, path_glathida):
     #Function written by Samuel Cook
-    
+
     #Read GlaThiDa file
     gdf = pd.read_csv(path_glathida)
-    
+
     gdf_sel = gdf.loc[gdf.thickness > 0]  # you may not want to do that, but be aware of: https://gitlab.com/wgms/glathida/-/issues/25
     gdf_per_grid = gdf_sel.groupby(by='ij_grid')[['i_grid', 'j_grid', 'elevation', 'thickness', 'thickness_uncertainty']].mean()  # just average per grid point
     # Average does not preserve ints
     gdf_per_grid['i_grid'] = gdf_per_grid['i_grid'].astype(int)
     gdf_per_grid['j_grid'] = gdf_per_grid['j_grid'].astype(int)
-    
-    #Get GlaThiDa data onto model grid  
+
+    #Get GlaThiDa data onto model grid
     thkobs = np.full((y.shape[0], x.shape[0]), np.nan)
     thkobs[gdf_per_grid['j_grid'],gdf_per_grid['i_grid']] = gdf_per_grid['thickness']
     thkobs = np.flipud(thkobs)
-    
+
     return thkobs
 
 def _get_tidewater_termini_and_slopes(tidewatermask, slopes, RGIs, params):
     #Function written by Samuel Cook
     #Identify which glaciers in a complex are tidewater and also return average slope (both needed for infer_params in optimize)
-    
+
     from oggm import utils, workflow, tasks, graphics
     import xarray as xr
     import matplotlib.pyplot as plt
-    
+
     rgi_ids = RGIs
-    base_url = ( "https://cluster.klima.uni-bremen.de/~oggm/gdirs/oggm_v1.6/exps/igm_v3" )
+    base_url = ( "https://cluster.klima.uni-bremen.de/~oggm/gdirs/oggm_v1.6/exps/igm_v4" )
     gdirs = workflow.init_glacier_directories(
         # Start from level 3 if you want some climate data in them
         rgi_ids,
@@ -619,4 +674,4 @@ def _get_tidewater_termini_and_slopes(tidewatermask, slopes, RGIs, params):
         if gdf.loc[0].term_type == '1':
             tidewatermask[tidewatermask==1] = 1
         else:
-            tidewatermask[tidewatermask==1] = 0
+            tidewatermask[tidewatermask==1] = 0