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

igm_model-3.0.1/MANIFEST.in

@@ -0,0 +1,3 @@
+recursive-include igm *.yaml
+recursive-include igm *.dat
+recursive-include igm *.h5

igm_model-3.0.1/PKG-INFO

@@ -0,0 +1,47 @@
+Metadata-Version: 2.4
+Name: igm-model
+Version: 3.0.1
+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
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: tensorflow[and-cuda]==2.15.1
+Requires-Dist: matplotlib
+Requires-Dist: scipy
+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
+Requires-Dist: tqdm
+Requires-Dist: hydra-core
+Requires-Dist: omegaconf
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+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>
+ 
+ <div align="center">
+    <img src="logo/logo_igm.svg" width="40%" alt="Alt text">
+</div>
+
+Source code of the Instructed Glacier Model (IGM).
+
+Documentation (from version 3) : https://igm-model.org/
+
+Documentation (up to version 2) : https://github.com/jouvetg/igm/wiki

igm_model-3.0.1/README.md

@@ -0,0 +1,12 @@
+[![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>
+ 
+ <div align="center">
+    <img src="logo/logo_igm.svg" width="40%" alt="Alt text">
+</div>
+
+Source code of the Instructed Glacier Model (IGM).
+
+Documentation (from version 3) : https://igm-model.org/
+
+Documentation (up to version 2) : https://github.com/jouvetg/igm/wiki

igm_model-3.0.1/igm/__init__.py

@@ -0,0 +1,9 @@
+#!/usr/bin/env python3
+
+# Copyright (C) 2021-2025 IGM authors 
+# Published under the GNU GPL (Version 3), check at the LICENSE file
+    
+from . import processes
+from . import inputs, outputs
+from . import common
+

igm_model-3.0.1/igm/common/__init__.py

@@ -0,0 +1,18 @@
+from .core import State
+
+from .runner import (
+    initialize_modules,
+    update_modules,
+    finalize_modules,
+    setup_igm_modules,
+    check_incompatilities_in_parameters_file,
+    load_yaml_as_cfg,
+    EmptyClass
+)
+
+from .utilities import (
+    add_logger,
+    download_unzip_and_store,
+    print_comp,
+    print_gpu_info,
+)

igm_model-3.0.1/igm/common/core/__init__.py

@@ -0,0 +1 @@
+from .src import State, IGM_DESCRIPTION

igm_model-3.0.1/igm/common/core/src.py

@@ -0,0 +1,20 @@
+IGM_DESCRIPTION = r"""
+  ┌──────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
+  │             Welcome to IGM, a modular, open-source, fast, and user-friendly glacier evolution model!             │
+  │                                                                                                                  │
+  │                                                                                                                  │
+  │                         __/\\\\\\\\\\\_____/\\\\\\\\\\\\__/\\\\____________/\\\\_                                │
+  │                          _\/////\\\///____/\\\//////////__\/\\\\\\________/\\\\\\_                               │
+  │                           _____\/\\\______/\\\_____________\/\\\//\\\____/\\\//\\\_                              │
+  │                            _____\/\\\_____\/\\\____/\\\\\\\_\/\\\\///\\\/\\\/_\/\\\_                             │
+  │                             _____\/\\\_____\/\\\___\/////\\\_\/\\\__\///\\\/___\/\\\_                            │
+  │                              _____\/\\\_____\/\\\_______\/\\\_\/\\\____\///_____\/\\\_                           │
+  │                               _____\/\\\_____\/\\\_______\/\\\_\/\\\_____________\/\\\_                          │
+  │                                __/\\\\\\\\\\\_\//\\\\\\\\\\\\/__\/\\\_____________\/\\\_                         │
+  │                                 _\///////////___\////////////____\///______________\///__                        │
+  └──────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
+"""
+
+
+class State:
+    pass

igm_model-3.0.1/igm/common/runner/__init__.py

@@ -0,0 +1,8 @@
+from .configuration import check_incompatilities_in_parameters_file, EmptyClass, load_yaml_as_cfg
+
+from .modules import (
+    initialize_modules,
+    update_modules,
+    finalize_modules,
+    setup_igm_modules,
+)

igm_model-3.0.1/igm/common/runner/configuration/__init__.py

@@ -0,0 +1,2 @@
+from .utils import check_incompatilities_in_parameters_file, EmptyClass
+from .loader import load_yaml_as_cfg

igm_model-3.0.1/igm/common/runner/configuration/loader.py

@@ -0,0 +1,44 @@
+import os, yaml
+from omegaconf import OmegaConf
+
+
+def load_yaml_as_cfg(yaml_filename):
+    from .utils import DictToObj
+
+    script_dir = os.path.dirname(
+        os.path.abspath(__file__)
+    )  # Get the script's directory
+    yaml_path = os.path.join(script_dir, yaml_filename)  # Build the full path
+
+    with open(yaml_path, "r") as file:
+        yaml_dict = yaml.safe_load(file)  # Load as dict
+
+    return DictToObj(yaml_dict)  # Convert to object
+
+
+def load_yaml_recursive(base_dir):
+    config = {}
+    for root, _, files in os.walk(base_dir):
+        for file in files:
+            if file.endswith(".yaml") or file.endswith(".yml"):
+                full_path = os.path.join(root, file)
+                relative_path = os.path.relpath(full_path, base_dir)
+                keys = (
+                    relative_path.replace(".yaml", "").replace(".yml", "").split(os.sep)
+                )
+
+                # Load the YAML file
+                yaml_conf = OmegaConf.load(full_path)
+
+                # Nest it in the config dictionary
+                sub_conf = config
+                for key in keys[:-1]:
+                    sub_conf = sub_conf.setdefault(key, {})
+                if keys[-1] in yaml_conf:
+                    sub_conf[keys[-1]] = OmegaConf.merge(
+                        sub_conf.get(keys[-1], {}), yaml_conf[keys[-1]]
+                    )
+                else:
+                    sub_conf[keys[-1]] = yaml_conf
+
+    return OmegaConf.create(config)

igm_model-3.0.1/igm/common/runner/configuration/utils.py

@@ -0,0 +1,86 @@
+import os
+import igm
+from omegaconf import OmegaConf
+
+
+from .loader import load_yaml_recursive
+
+
+class EmptyClass:
+    pass
+
+
+class DictToObj:
+    """Recursively convert a dictionary to an object with attribute-style access."""
+
+    def __init__(self, dictionary):
+        for key, value in dictionary.items():
+            if isinstance(value, dict):
+                setattr(self, key, DictToObj(value))
+            else:
+                setattr(self, key, value)
+
+    def __getitem__(self, key):
+        return getattr(self, key)  # Allow dictionary-like access
+
+    def __repr__(self):
+        return str(self.__dict__)
+
+    def to_dict(self):
+        """Convert back to a dictionary."""
+        return {
+            key: value.to_dict() if isinstance(value, DictToObj) else value
+            for key, value in self.__dict__.items()
+        }
+
+
+def check_incompatilities_in_parameters_file(cfg, path):
+
+    from difflib import get_close_matches
+
+    def flatten_dict(d, parent_key="", sep="."):
+        def recurse(obj, prefix):
+            if isinstance(obj, dict):
+                for k, v in obj.items():
+                    yield from recurse(v, f"{prefix}{sep}{k}" if prefix else k)
+            elif isinstance(obj, list):
+                for i, item in enumerate(obj):
+                    yield from recurse(item, f"{prefix}[{i}]")
+            else:
+                yield (prefix, obj)
+
+        return dict(recurse(d, parent_key))
+
+    def compare_configs(cfg, cfgo, path="", excluded_keys=["cwd", "config"]):
+        for key in cfg:
+            full_path = f"{path}.{key}" if path else key
+            if key not in excluded_keys:
+                if key not in cfgo:
+                    # Get possible matches for the missing key
+                    posskeys = flatten_dict(
+                        OmegaConf.to_container(cfgo, resolve=False)
+                    ).keys()
+                    suggestions = get_close_matches(key, posskeys, n=5, cutoff=0.2)
+                    suggestions = [path + "." + s for s in suggestions]
+                    suggestion_msg = (
+                        f" Did you mean '{suggestions}'?" if suggestions else ""
+                    )
+                    raise ValueError(
+                        f"Parameter '{full_path}' does not exist.\n {suggestion_msg}"
+                    )
+                if OmegaConf.is_dict(cfg[key]):
+                    if not OmegaConf.is_dict(cfgo[key]):
+                        raise ValueError(
+                            f"Configuration mismatch at '{full_path}': expected a dictionary-like config."
+                        )
+                    compare_configs(cfg[key], cfgo[key], full_path)
+
+    ############################
+
+    cfgo = load_yaml_recursive(os.path.join(igm.__path__[0], "conf"))
+
+    addo = load_yaml_recursive(os.path.join(path, "user/conf"))
+
+    cfgo = OmegaConf.merge(cfgo, addo)
+
+    compare_configs(cfg, cfgo)

igm_model-3.0.1/igm/common/runner/modules/__init__.py

@@ -0,0 +1 @@
+from .src import initialize_modules, update_modules, finalize_modules, setup_igm_modules

igm_model-3.0.1/igm/common/runner/modules/loader.py

@@ -0,0 +1,182 @@
+#!/usr/bin/env python3
+
+"""
+# Copyright (C) 2021-2025 IGM authors 
+Published under the GNU GPL (Version 3), check at the LICENSE file
+"""
+
+import sys
+import importlib
+from typing import List, Tuple
+from types import ModuleType
+from hydra.core.hydra_config import HydraConfig
+
+from .utils import get_module_name, get_orders
+from .validator import validate_module
+
+
+def load_modules(
+    cfg, state
+) -> Tuple[List[ModuleType], List[ModuleType], List[ModuleType]]:
+    """Returns a list of actionable modules to then apply the update, initialize, finalize functions on for IGM."""
+    imported_input_modules = []
+    imported_modules = []
+    imported_output_modules = []
+
+    root_foldername = (
+        f"{HydraConfig.get().runtime.cwd}/{cfg.core.structure.root_foldername}"
+    )
+
+    # Add custom modules folder to sys.path
+    user_input_modules_folder = f"{root_foldername}/{cfg.core.structure.code_foldername}/{cfg.core.structure.input_modules_foldername}"
+    user_process_modules_folder = f"{root_foldername}/{cfg.core.structure.code_foldername}/{cfg.core.structure.process_modules_foldername}"
+    user_output_modules_folder = f"{root_foldername}/{cfg.core.structure.code_foldername}/{cfg.core.structure.output_modules_foldername}"
+
+    custom_modules_folders = [
+        user_input_modules_folder,
+        user_process_modules_folder,
+        user_output_modules_folder,
+    ]
+
+    for folder in custom_modules_folders:
+        if folder not in sys.path:
+            sys.path.append(folder)
+
+    if "inputs" in cfg:
+        load_user_modules(
+            cfg=cfg,
+            state=state,
+            modules_list=cfg.inputs,
+            imported_modules_list=imported_input_modules,
+            module_folder=user_input_modules_folder,
+        )
+        load_modules_igm(
+            cfg=cfg,
+            state=state,
+            modules_list=cfg.inputs,
+            imported_modules_list=imported_input_modules,
+            module_type="inputs",
+        )
+
+    if "processes" in cfg:
+        load_user_modules(
+            cfg=cfg,
+            state=state,
+            modules_list=cfg.processes,
+            imported_modules_list=imported_modules,
+            module_folder=user_process_modules_folder,
+        )
+        load_modules_igm(
+            cfg=cfg,
+            state=state,
+            modules_list=cfg.processes,
+            imported_modules_list=imported_modules,
+            module_type="processes",
+        )
+
+    if "outputs" in cfg:
+        load_user_modules(
+            cfg=cfg,
+            state=state,
+            modules_list=cfg.outputs,
+            imported_modules_list=imported_output_modules,
+            module_folder=user_output_modules_folder,
+        )
+        load_modules_igm(
+            cfg=cfg,
+            state=state,
+            modules_list=cfg.outputs,
+            imported_modules_list=imported_output_modules,
+            module_type="outputs",
+        )
+
+    # Reorder modules
+    input_order, module_order, output_order = get_orders()
+
+    input_order_dict = {name: index for index, name in enumerate(input_order)}
+    imported_input_modules = sorted(
+        imported_input_modules,
+        key=lambda module: input_order_dict[get_module_name(module)],
+    )
+
+    modules_order_dict = {name: index for index, name in enumerate(module_order)}
+    imported_modules = sorted(
+        imported_modules, key=lambda module: modules_order_dict[get_module_name(module)]
+    )
+
+    output_order_dict = {name: index for index, name in enumerate(output_order)}
+    imported_output_modules = sorted(
+        imported_output_modules,
+        key=lambda module: output_order_dict[get_module_name(module)],
+    )
+
+    if cfg.core.print_imported_modules:
+        print(f"{'':-^100}")
+        print(f"{'INPUTS Modules':-^100}")
+        for i, input_module in enumerate(imported_input_modules):
+            print(f" {i}: {input_module}")
+        print(f"{'PROCESSES Modules':-^100}")
+        for i, module in enumerate(imported_modules):
+            print(f" {i}: {module}")
+        print(f"{'OUTPUTS Modules':-^100}")
+        for i, output_module in enumerate(imported_output_modules):
+            print(f" {i}: {output_module}")
+        print(f"{'':-^100}")
+
+    return imported_input_modules, imported_modules, imported_output_modules
+
+
+def load_user_modules(
+    cfg, state, modules_list, imported_modules_list, module_folder
+) -> List[ModuleType]:
+
+    from importlib.machinery import SourceFileLoader
+
+    for module_name in modules_list:
+        # Local Directory
+        try:
+            module = SourceFileLoader(
+                f"{module_name}", f".{module_name}.py"
+            ).load_module()
+        except FileNotFoundError:
+
+            # User Modules Folder
+            try:
+                module = SourceFileLoader(
+                    f"{module_name}", f"{module_folder}/{module_name}.py"
+                ).load_module()
+            except FileNotFoundError:
+                # User Modules Folder Folder
+                try:
+                    module = SourceFileLoader(
+                        f"{module_name}",
+                        f"{module_folder}/{module_name}/{module_name}.py",
+                    ).load_module()
+                except FileNotFoundError:
+                    pass
+                else:
+                    imported_modules_list.append(module)
+            else:
+                imported_modules_list.append(module)
+        else:
+            imported_modules_list.append(module)
+
+    return imported_modules_list
+
+
+def load_modules_igm(
+    cfg, state, modules_list, imported_modules_list, module_type
+) -> List[ModuleType]:
+
+    from importlib.machinery import SourceFileLoader
+
+    imported_modules_names = [module.__name__ for module in imported_modules_list]
+    for module_name in modules_list:
+        if module_name in imported_modules_names:
+            continue
+
+        module_path = f"igm.{module_type}.{module_name}"
+        module = importlib.import_module(module_path)
+        if module_type == "processes":
+            validate_module(module)
+        imported_modules_list.append(module)

igm_model-3.0.1/igm/common/runner/modules/src.py

@@ -0,0 +1,61 @@
+from typing import List, Any
+from types import ModuleType
+
+import time
+
+from ...core import State
+from ...utilities import print_info
+from ..modules.loader import load_modules
+
+
+def initialize_modules(processes: List, cfg: Any, state: State) -> None:
+    for module in processes:
+        if cfg.core.logging:
+            state.logger.info(f"Initializing module: {module.__name__.split('.')[-1]}")
+        module.initialize(cfg, state)
+
+
+def update_modules(processes: List, outputs: List, cfg: Any, state: State) -> None:
+
+    state.it = 0
+    state.continue_run = True
+    if cfg.core.print_comp:
+        state.tcomp = {
+            module.__name__.split(".")[-1]: [] for module in processes + outputs
+        }
+    while state.continue_run:
+        for module in processes:
+            m = module.__name__.split(".")[-1]
+            if cfg.core.print_comp:
+                state.tcomp[m].append(time.time())
+            module.update(cfg, state)
+            if cfg.core.print_comp:
+                state.tcomp[m][-1] -= time.time()
+                state.tcomp[m][-1] *= -1
+        run_outputs(outputs, cfg, state)
+        if cfg.core.print_info:
+            print_info(state)
+        state.it += 1
+
+        if not hasattr(state, "t"):
+            state.continue_run = False
+
+
+def finalize_modules(processes: List, cfg: Any, state: State) -> None:
+    for module in processes:
+        module.finalize(cfg, state)
+
+
+def run_outputs(output_modules: List, cfg: Any, state: State) -> None:
+    for module in output_modules:
+        m = module.__name__.split(".")[-1]
+        if cfg.core.print_comp:
+            state.tcomp[m].append(time.time())
+        module.run(cfg, state)
+        if cfg.core.print_comp:
+            state.tcomp[m][-1] -= time.time()
+            state.tcomp[m][-1] *= -1
+
+
+def setup_igm_modules(cfg, state) -> List[ModuleType]:
+    return load_modules(cfg, state)

igm_model-3.0.1/igm/common/runner/modules/utils.py

@@ -0,0 +1,34 @@
+from hydra.core.hydra_config import HydraConfig
+import yaml
+
+
+def get_orders():
+    config_path = [
+        path["path"]
+        for path in HydraConfig.get().runtime.config_sources
+        if path["schema"] == "file"
+    ][0]
+
+    with open(
+        f"{config_path}/experiment/{HydraConfig.get().runtime.choices.experiment}.yaml",
+        "r",
+    ) as file:
+        original_experiment_config = yaml.safe_load(file)
+
+    defaults = original_experiment_config["defaults"]
+    input_order = modules_order = output_order = []
+    for default in defaults:
+
+        key = list(default.keys())[0]  # ? Cleaner / more robust way to do this?
+        if key == "override /inputs":
+            input_order = default[key]
+        elif key == "override /processes":
+            modules_order = default[key]
+        elif key == "override /outputs":
+            output_order = default[key]
+
+    return input_order, modules_order, output_order
+
+
+def get_module_name(module):
+    return module.__name__.split(".")[-1]

igm_model-3.0.1/igm/common/runner/modules/validator.py

@@ -0,0 +1,9 @@
+def validate_module(module) -> None:
+    """Validates that a module has the required functions to be used in IGM."""
+    required_functions = ["initialize", "finalize", "update"]
+    for function in required_functions:
+        if not hasattr(module, function):
+            raise AttributeError(
+                f"Module {module} is missing the required function ({function}). If it is a custom python package, make sure to include the 3 required functions: ['initialize', 'finalize', 'update'].",
+                f"Please see https://github.com/jouvetg/igm/wiki/5.-Custom-modules-(coding) for more information on how to construct custom modules.",
+            )

igm_model-3.0.1/igm/common/utilities/__init__.py

@@ -0,0 +1,6 @@
+from .misc import add_logger, download_unzip_and_store
+from .printers import print_comp, print_gpu_info, print_info
+from .visualizers import (
+    _plot_computational_pie,
+    _plot_memory_pie,
+)  # undo "private" convention if not used privately...

igm_model-3.0.1/igm/common/utilities/misc.py

@@ -0,0 +1,56 @@
+import logging
+
+
+def download_unzip_and_store(url, folder_path) -> 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_path (str): The path of the folder where the ZIP file's contents will be extracted.
+    # - 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_path):  # directory exists?
+        os.makedirs(folder_path)
+
+        # Download the file with wget
+        logging.info("Downloading the ZIP file with wget...")
+        subprocess.run(["wget", "-O", "downloaded_file.zip", url])
+
+        # Unzipping the file
+        logging.info("Unzipping the file...")
+        with zipfile.ZipFile("downloaded_file.zip", "r") as zip_ref:
+            zip_ref.extractall(folder_path)
+
+        # Clean up (delete) the zip file after extraction
+        os.remove("downloaded_file.zip")
+        logging.info(f"File successfully downloaded and extracted to '{folder_path}'")
+
+    else:
+        logging.info(f"The data already exists at '{folder_path}'")
+
+
+def add_logger(cfg, state) -> None:
+
+    # ! Ignore logging file for now...
+    # if cfg.logging_file == "":
+    #     pathf = ""
+    # else:
+    #     pathf = cfg.logging_file
+
+    logging.basicConfig(
+        # filename=pathf,
+        encoding="utf-8",
+        filemode="w",
+        level=cfg.core.logging_level,
+        format="%(asctime)s - %(levelname)s - %(message)s",
+    )
+    logging.root.setLevel(cfg.core.logging_level)
+
+    state.logger = logging.getLogger("igm")