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

{igm-model-2.2.0 → igm_model-2.2.2}/PKG-INFO

@@ -1,24 +1,25 @@
 Metadata-Version: 2.1
 Name: igm-model
-Version: 2.2.0
+Version: 2.2.2
 Summary: IGM - a glacier evolution model
 Home-page: https://github.com/jouvetg/igm
 Author: Guillaume Jouvet
 Author-email: guillaume.jouvet@unil.ch
 License: gpl-3.0
-Requires-Python: <3.12
+Requires-Python: <3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: tensorflow[and-cuda]==2.12.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
 
 [![License badge](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)

{igm-model-2.2.0 → igm_model-2.2.2}/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.0 → igm_model-2.2.2}/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.2/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.2/igm/emulators/pinnbp_10_4_cnn_8_32_2_1/fieldout.dat

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

igm_model-2.2.2/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.2/igm/emulators/pinnbp_10_4_unet_16_32_2_1/fieldout.dat

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

igm_model-2.2.2/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.2/igm/emulators/pinnbp_30_4_cnn_12_32_3_1/fieldout.dat

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

igm_model-2.2.2/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.0 → igm_model-2.2.2}/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.0 → igm_model-2.2.2}/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.0 → igm_model-2.2.2}/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.0 → igm_model-2.2.2}/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,

igm_model-2.2.2/igm/modules/postproc/texture/__init__.py

@@ -0,0 +1 @@
+from .texture import params, initialize, update, finalize

igm_model-2.2.2/igm/modules/postproc/texture/constants.py

@@ -0,0 +1,20 @@
+from typing import Tuple
+from dataclasses import dataclass
+
+@dataclass(frozen=True)
+class FeatureConstants:
+    topg: Tuple[float, float] = (4151.99267578125, 0.0)
+    water: Tuple[float, float] = (1.0, 0.0)
+    vx: Tuple[float, float] = (3.5998013782501204, -4.1134811401367175)
+    thk: Tuple[float, float] = (125.9672691345204, 0.0)
+    prec: Tuple[float, float] = (463.0692443847656, 2.575910019874573)
+    ndvi: Tuple[float, float] = (221.4811553955078, -0.6113666892051697)
+    vy: Tuple[float, float] = (6.441854915618933, -1.314163446426393)
+    temp: Tuple[float, float] = (22.149993896484375, -8.147315979003906)
+
+
+@dataclass(frozen=True)
+class ImageConstants:
+    red: Tuple[float, float] = (255.0, 0.0)
+    blue: Tuple[float, float] = (255.0, 0.0)
+    green: Tuple[float, float] = (255.0, 0.0)

igm_model-2.2.2/igm/modules/postproc/texture/emulator.py

@@ -0,0 +1,19 @@
+import tensorflow as tf
+from abc import ABC, abstractmethod
+
+
+class Emulator(ABC):
+    @abstractmethod
+    def apply(self, array):
+        pass
+
+
+class LinearRegressor(Emulator):
+    def __init__(self, coefficients, b) -> None:
+        self.coefficients = coefficients
+        self.b = b
+
+    def apply(self, array: tf.Tensor) -> tf.Tensor:
+        y = tf.matmul(self.coefficients, array) + self.b
+
+        return y

igm_model-2.2.2/igm/modules/postproc/texture/exporter.py

@@ -0,0 +1,95 @@
+import tensorflow as tf
+import matplotlib.pyplot as plt
+from abc import ABC, abstractmethod
+from typing import Any
+from .normalizer import Normalizer
+
+class Exporter(ABC):
+    @abstractmethod
+    def export(self, image: tf.Tensor, filename: str) -> None:
+        pass
+
+
+class PngExporter(Exporter):
+
+    def convert_8bit(self, image: tf.Tensor, image_normalizer: Normalizer) -> tf.Tensor:
+        out = image_normalizer.unnormalize(image)
+        out = tf.cast(out, tf.uint8)
+        out = tf.squeeze(out).numpy()
+
+        return out
+
+    def unpad(self, image: tf.Tensor, padding_parameters) -> tf.Tensor:
+        import numpy as np
+        n_dimensions = len(padding_parameters)
+        padded_image = image
+        for i, dimension in enumerate(padding_parameters):
+            if not np.all(np.equal(dimension,0)):
+                begin = [0] * n_dimensions
+                size = [-1] * n_dimensions
+                begin[i] = dimension[0]
+                size[i] = image.shape[i] - dimension[0] - dimension[1]
+                padded_image = tf.slice(padded_image, begin=begin, size=size)
+        unpadded_image = padded_image
+        
+        return unpadded_image
+
+    def export(self, image: tf.Tensor, filename: str) -> None:
+        plt.imsave(fname=filename, arr=image, format='png', dpi=300, origin='lower')
+
+
+class TiffExporter(Exporter):
+    
+    def __init__(self, state: Any):
+        self.state = state
+        
+    # this is a copy of the PngExporter, but it should be changed to export tiff files
+    def convert_8bit(self, image: tf.Tensor, image_normalizer: Normalizer) -> tf.Tensor:
+        out = image_normalizer.unnormalize(image)
+        out = tf.cast(out, tf.uint8)
+        out = tf.squeeze(out).numpy()
+
+        return out
+
+    # this is a copy of the PngExporter, but it should be changed to export tiff files
+    def unpad(self, image: tf.Tensor, padding_parameters) -> tf.Tensor:
+        import numpy as np
+        n_dimensions = len(padding_parameters)
+        padded_image = image
+        for i, dimension in enumerate(padding_parameters):
+            if not np.all(np.equal(dimension,0)):
+                begin = [0] * n_dimensions
+                size = [-1] * n_dimensions
+                begin[i] = dimension[0]
+                size[i] = image.shape[i] - dimension[0] - dimension[1]
+                padded_image = tf.slice(padded_image, begin=begin, size=size)
+        unpadded_image = padded_image
+        
+        return unpadded_image    
+    
+    def export(self, image: tf.Tensor, filename: str) -> None:
+
+        import rasterio
+        from rasterio.enums import ColorInterp
+        import numpy as np
+ 
+        code = 32632 # UTM 32N (oviously this should be a parameter in the future)
+               
+        ny=image.shape[0]
+        nx=image.shape[1]
+        ch=image.shape[2]    
+        
+        xmin = min(self.state.x)
+        xmax = max(self.state.x)
+        ymin = min(self.state.y)
+        ymax = max(self.state.y)
+        
+        xres = (xmax - xmin) / float(nx)
+        yres = (ymax - ymin) / float(ny)
+        
+        transform = rasterio.Affine.translation(xmin - xres / 2, ymin - yres / 2)  * rasterio.Affine.scale(xres, yres)
+
+        with rasterio.open(filename, mode="w", driver="GTiff", height=ny, width=nx, 
+                           count=3, dtype=np.uint8, transform=transform,) as src:
+            src.write(np.rollaxis(image, -1, 0))
+            src.colorinterp = [ColorInterp.red, ColorInterp.green, ColorInterp.blue]