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

{igm-model-2.2.1 → 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.1
+Version: 2.2.3
 Summary: IGM - a glacier evolution model
 Home-page: https://github.com/jouvetg/igm
 Author: Guillaume Jouvet
@@ -9,17 +9,28 @@ License: gpl-3.0
 Requires-Python: <3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: tensorflow[and-cuda]==2.14.0
+Requires-Dist: tensorflow[and-cuda]==2.15.1
 Requires-Dist: matplotlib
 Requires-Dist: scipy
-Requires-Dist: netCDF4
+Requires-Dist: netCDF4==1.6.0
 Requires-Dist: xarray
 Requires-Dist: rasterio
 Requires-Dist: pyproj
 Requires-Dist: geopandas
 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>
@@ -43,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.1 → 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.1 → igm_model-2.2.3}/igm/__init__.py

@@ -15,7 +15,7 @@ from .common import (
     load_modules,
     add_logger,
     print_params,
-    load_dependent_modules,
+#    load_dependent_modules,
     get_modules_list,
     load_user_defined_params,
     run_intializers,
@@ -24,5 +24,6 @@ from .common import (
     setup_igm_modules,
     setup_igm_params,
     add_logger,
-    print_gpu_info
+    print_gpu_info,
+    download_unzip_and_store    
 )

{igm-model-2.2.1 → igm_model-2.2.3}/igm/common.py

@@ -23,9 +23,8 @@ import igm
 
 IGM_DESCRIPTION = r"""
   ┌──────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
-  │ Welcome to IGM! The Iceflow Glacier Model (IGM) is a modular, open-source, and user-friendly glacier model.      │
-  │ It is designed to be used in a variety of applications, including glacier evolution, ice flow, and ice           │
-  │ dynamics.                                                                                                        │
+  │             Welcome to IGM, a modular, open-source, fast, and user-friendly glacier evolution model!             │
+  │                                                                                                                  │
   │                                                                                                                  │
   │                         __/\\\\\\\\\\\_____/\\\\\\\\\\\\__/\\\\____________/\\\\_                                │
   │                          _\/////\\\///____/\\\//////////__\/\\\\\\________/\\\\\\_                               │
@@ -118,6 +117,18 @@ def params_core() -> argparse.ArgumentParser:
         default="params_saved",
         help="Name of the file to store the parameters used in the run (default: %(default)s)",
     )
+    parser.add_argument(
+        "--url_data",
+        type=str,
+        default="",
+        help="The URL of the ZIP file to download and unzip (default: %(default)s)",
+    )
+    parser.add_argument(
+        "--folder_data",
+        type=str,
+        default="data",
+        help="The name of the folder where are stored the data (default: %(default)s)",
+    )
 
     return parser
 
@@ -126,7 +137,7 @@ def setup_igm_modules(params: Namespace) -> List[ModuleType]:
 
     modules_dict = get_modules_list(params.param_file)
     imported_modules = load_modules(modules_dict)
-    imported_modules = load_dependent_modules(imported_modules)
+#    imported_modules = load_dependent_modules(imported_modules) this is no more in used
 
     return imported_modules
 
@@ -207,14 +218,29 @@ def load_json_file(
     dic_params = json.loads(json_text)
     return dic_params
 
+import yaml
+def load_yaml_file(
+    param_file: str
+) -> Dict[str, Any]:
+    with open(param_file, "r") as file:
+        dic_params = yaml.safe_load(file)
+
+    return dic_params
+
 
 def get_modules_list(params_path: str) -> dict[str, List[str]]:
     try:
-        with open(params_path) as f:
-            # params_dict = json.load(f) #re-instate if you want to enforce no comments in the json file(remove all the lines that load the clean json in this case...)
-            json_text = f.read()
-            json_cleaned = remove_comments(json_text)
-            params_dict = json.loads(json_cleaned)
+        with open(params_path, "r") as file:
+            if params_path.endswith(".json"):
+                json_text = file.read()
+                json_cleaned = remove_comments(json_text)
+                params_dict = json.loads(json_cleaned)
+            elif params_path.endswith(".yaml") or params_path.endswith(".yml"):
+                params_dict = yaml.safe_load(file)
+            else:
+                raise ValueError(
+                    f"File type not supported. Please use a .json or .yaml file."
+                )
             module_dict = {
                 "modules_preproc": params_dict["modules_preproc"],
                 "modules_process": params_dict["modules_process"],
@@ -228,11 +254,21 @@ def get_modules_list(params_path: str) -> dict[str, List[str]]:
             doc=e.doc,
             pos=e.pos,
         )
+    # Create a custom error message for the YAML file (using yaml.YAMLError base exception)
 
 
 def load_user_defined_params(param_file: str, params_dict: dict[str, Any]):
+    if param_file.endswith(".json"):
+        loading_function = load_json_file
+    elif param_file.endswith(".yaml") or param_file.endswith(".yml"):
+        loading_function = load_yaml_file
+    else:
+        raise ValueError(
+            f"File type not supported. Please use a .json or .yaml file."
+        )
     try:
-        json_defined_params = load_json_file(param_file=param_file)
+        json_defined_params = loading_function(param_file=param_file)
+
     except JSONDecodeError as e:
         raise JSONDecodeError(
             msg=f"Error decoding JSON: Please make sure your file path is correct or your json is properly formatted.",
@@ -273,7 +309,7 @@ def load_modules(modules_dict: Dict) -> List[ModuleType]:
     return (
         imported_preproc_modules
         + imported_process_modules
-        + imported_postproc_modules  # + imported_custom_modules
+        + imported_postproc_modules  # + imported_custom_modules ? (see above)
     )
 
 
@@ -304,7 +340,10 @@ def load_modules_from_directory(
                 logging.info(
                     f"Trying to import custom module from current working directory (folder or .py): {module_name}"
                 )
-                module = importlib.import_module(module_name)
+                try:
+                    module = importlib.import_module(module_name)
+                except ModuleNotFoundError:
+                    module = importlib.import_module("modules_custom." + module_name)
             except ModuleNotFoundError:
                 raise ModuleNotFoundError(
                     f"Can not find module {module_name}. Make sure it is either in the 1) {Path(igm.__file__).parent}/modules/{module_folder} directory or 2) in your current working directory."
@@ -316,41 +355,41 @@ def load_modules_from_directory(
     return imported_modules
 
 
-def has_dependencies(module: Any) -> bool:
-    if hasattr(module, "dependencies"):
-        return True
-    return False
-
-
-def load_dependent_modules(imported_modules: List) -> List[ModuleType]:
-    imported_dependencies = set()
-    for module in imported_modules:
-        if has_dependencies(module):
-            module_dependencies = module.dependencies
-            directories_to_search = [
-                "preproc",
-                "process",
-                "postproc",
-            ]  # will also check current working directory if any of them fail
-            load_modules_partial = partial(
-                load_modules_from_directory, module_dependencies
-            )
-            for directory in directories_to_search:
-                try:
-                    dependent_module = load_modules_partial(module_folder=directory)
-                    imported_dependencies.add(
-                        dependent_module[0]
-                    )  # [0] because it returns a singleton list
-                    logging.info(
-                        f"Found dependencies in directory {directory} or current working directory. Checking next module for dependencies."
-                    )
-                    break
-                except ModuleNotFoundError:
-                    logging.info(
-                        f"Could not find dependencies in directory {directory} or current working directory. Checking next IGM directory."
-                    )
-
-    return imported_modules + list(imported_dependencies)
+# def has_dependencies(module: Any) -> bool:
+#     if hasattr(module, "dependencies"):
+#         return True
+#     return False
+
+
+# def load_dependent_modules(imported_modules: List) -> List[ModuleType]:
+#     imported_dependencies = set()
+#     for module in imported_modules:
+#         if has_dependencies(module):
+#             module_dependencies = module.dependencies
+#             directories_to_search = [
+#                 "preproc",
+#                 "process",
+#                 "postproc",
+#             ]  # will also check current working directory if any of them fail
+#             load_modules_partial = partial(
+#                 load_modules_from_directory, module_dependencies
+#             )
+#             for directory in directories_to_search:
+#                 try:
+#                     dependent_module = load_modules_partial(module_folder=directory)
+#                     imported_dependencies.add(
+#                         dependent_module[0]
+#                     )  # [0] because it returns a singleton list
+#                     logging.info(
+#                         f"Found dependencies in directory {directory} or current working directory. Checking next module for dependencies."
+#                     )
+#                     break
+#                 except ModuleNotFoundError:
+#                     logging.info(
+#                         f"Could not find dependencies in directory {directory} or current working directory. Checking next IGM directory."
+#                     )
+
+#     return imported_modules + list(imported_dependencies)
 
 
 def print_gpu_info() -> None:
@@ -378,3 +417,37 @@ def print_params(params: Namespace) -> None:
         json.dump(params.__dict__, json_file, indent=2)
 
     os.system("echo rm " + param_file + " >> clean.sh")
+
+
+def download_unzip_and_store(url, folder_name='data') -> None:
+    """
+    Use wget to download a ZIP file and unzip its contents to a specified folder.
+    
+    Args:
+    - url (str): The URL of the ZIP file to download.
+    - folder_name (str): The name of the folder where the ZIP file's contents will be extracted.
+    """
+
+    import subprocess
+    import os
+    import zipfile
+
+    # Ensure the destination folder exists
+    if not os.path.exists(folder_name):
+        os.makedirs(folder_name)
+        
+        # Download the file with wget
+        print("Downloading the ZIP file with wget...")
+        subprocess.run(['wget', '-O', 'downloaded_file.zip', url])
+        
+        # Unzipping the file
+        print("Unzipping the file...")
+        with zipfile.ZipFile('downloaded_file.zip', 'r') as zip_ref:
+            zip_ref.extractall(folder_name)
+        
+        # Clean up (delete) the zip file after extraction
+        os.remove('downloaded_file.zip')
+        print(f"File successfully downloaded and extracted to '{folder_name}'")
+
+    else:
+        print(f"The data already existing at '{folder_name}'")

igm_model-2.2.3/igm/emulators/pinnbp_10_4_cnn_8_32_2_1/fieldin.dat

@@ -0,0 +1,5 @@
+thk
+usurf
+arrhenius
+slidingco
+dX

igm_model-2.2.3/igm/emulators/pinnbp_10_4_cnn_8_32_2_1/fieldout.dat

@@ -0,0 +1,2 @@
+U
+V 

igm_model-2.2.3/igm/emulators/pinnbp_10_4_unet_16_32_2_1/fieldin.dat

@@ -0,0 +1,5 @@
+thk
+usurf
+arrhenius
+slidingco
+dX

igm_model-2.2.3/igm/emulators/pinnbp_10_4_unet_16_32_2_1/fieldout.dat

@@ -0,0 +1,2 @@
+U
+V 

igm_model-2.2.3/igm/emulators/pinnbp_30_4_cnn_12_32_3_1/fieldin.dat

@@ -0,0 +1,5 @@
+thk
+usurf
+arrhenius
+slidingco
+dX

igm_model-2.2.3/igm/emulators/pinnbp_30_4_cnn_12_32_3_1/fieldout.dat

@@ -0,0 +1,2 @@
+U
+V 

igm_model-2.2.3/igm/igm_help.py

@@ -0,0 +1,30 @@
+#!/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 tensorflow as tf
+import sys
+from igm import (
+    State,
+    params_core,
+    setup_igm_modules,
+    setup_igm_params
+)
+
+
+def main() -> None: 
+    
+    parser = params_core()
+    params = State()
+    params.param_file = parser.get_default('param_file')
+    imported_modules = setup_igm_modules(params)
+    params = setup_igm_params(parser, imported_modules)
+        
+    # Check if no arguments were provided
+    if len(sys.argv) == 1:
+        parser.print_help()
+        sys.exit(1)  # Exit after displaying the help
+
+if __name__ == "__main__":
+    main()

{igm-model-2.2.1 → igm_model-2.2.3}/igm/igm_run.py

@@ -3,6 +3,7 @@
 # Copyright (C) 2021-2023 Guillaume Jouvet <guillaume.jouvet@unil.ch>
 # Published under the GNU GPL (Version 3), check at the LICENSE file
 
+import os
 import tensorflow as tf
 from igm import (
     State,
@@ -14,7 +15,8 @@ from igm import (
     setup_igm_modules,
     setup_igm_params,
     print_gpu_info,
-    add_logger
+    add_logger,
+    download_unzip_and_store
 )
 
 
@@ -35,6 +37,11 @@ def main() -> None:
 
     if params.print_params:
         print_params(params=params)
+        
+    if not params.url_data=="":
+        download_unzip_and_store(params.url_data,params.folder_data)
+        
+    os.environ["CUDA_VISIBLE_DEVICES"] = str(params.gpu_id)        
 
     # Place the computation on your device GPU ('/GPU:0') or CPU ('/CPU:0')
     with tf.device(f"/GPU:{params.gpu_id}"):  # type: ignore for linting checks

{igm-model-2.2.1 → igm_model-2.2.3}/igm/instructed_oggm.py

@@ -80,8 +80,10 @@ class IGM_Model2D(Model2D):
         parser = igm.params_core()
         
         params, __ = parser.parse_known_args()  # args=[] add this for jupyter notebook
+        
+        modules_dict = { "modules_preproc": [ ], "modules_process": ["iceflow"], "modules_postproc": [ ] }
              
-        imported_modules = igm.load_modules(params)
+        imported_modules = igm.load_modules(modules_dict)
 
         for module in imported_modules:
             module.params(parser)
@@ -109,7 +111,7 @@ class IGM_Model2D(Model2D):
         self.state.arrhenius = (
             tf.ones_like(self.state.thk) * cfg.PARAMS["glen_a"] * SEC_IN_YEAR * 1e18
         )
-        self.state.slidingco = tf.ones_like(self.state.thk) * 10000
+        self.state.slidingco = tf.ones_like(self.state.thk) * 0.045
         self.state.dX = tf.ones_like(self.state.thk) * self.dx
 
         self.state.x = tf.constant(self.x)

{igm-model-2.2.1 → igm_model-2.2.3}/igm/modules/postproc/__init__.py

@@ -2,3 +2,4 @@
 
 # Copyright (C) 2021-2023 Guillaume Jouvet <guillaume.jouvet@unil.ch>
 # Published under the GNU GPL (Version 3), check at the LICENSE file
+

{igm-model-2.2.1 → 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.1 → igm_model-2.2.3}/igm/modules/postproc/plot2d/plot2d.py

@@ -41,7 +41,7 @@ def params(parser):
     parser.add_argument(
         "--plt2d_var_max",
         type=float,
-        default=250,
+        default=1000,
         help="Maximum value of the varplot variable used to adjust the scaling of the colorbar",
     )
 
@@ -72,28 +72,37 @@ def update(params, state):
         im0 = state.ax.imshow(
             state.topg,
             origin="lower",
-            cmap=matplotlib.cm.terrain,
-            extent=state.extent,
-            alpha=0.65,
-        )
-
-        im = state.ax.imshow(
-            np.where(state.thk > 0, vars(state)[params.plt2d_var], np.nan),
-            origin="lower",
-            cmap=matplotlib.cm.viridis,
-            vmin=0,
-            vmax=params.plt2d_var_max,
-            extent=state.extent,
+            cmap='binary', # matplotlib.cm.terrain,
+            extent=state.extent
+#            alpha=0.65,
         )
+ 
+        if params.plt2d_var=="velbar_mag":
+            im = state.ax.imshow(
+                np.where(state.thk > 0, vars(state)[params.plt2d_var], np.nan),
+                origin="lower",
+                cmap="turbo",
+                extent=state.extent, 
+                norm=matplotlib.colors.LogNorm(vmin=1, vmax=params.plt2d_var_max)
+            )
+        else:
+            im = state.ax.imshow(
+                np.where(state.thk > 0, vars(state)[params.plt2d_var], np.nan),
+                origin="lower",
+                cmap='jet',
+                vmin=0,
+                vmax=params.plt2d_var_max,
+                extent=state.extent,
+            )
         if params.plt2d_particles:
-            if hasattr(state, "xpos"):
+            if hasattr(state, "particle_x"):
                 if hasattr(state, "ip"):
                     state.ip.set_visible(False)
                 r = 1
                 state.ip = state.ax.scatter(
-                    x=state.xpos[::r],
-                    y=state.ypos[::r],
-                    c=1 - state.rhpos[::r].numpy(),
+                    x = state.particle_x[::r] + state.x[0],
+                    y = state.particle_y[::r] + state.y[0],
+                    c = 1 - state.particle_r[::r].numpy(), #or r ?
                     vmin=0,
                     vmax=1,
                     s=0.5,