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

{igm-model-2.1.0/igm_model.egg-info → igm-model-2.2.1}/PKG-INFO

@@ -1,44 +1,49 @@
 Metadata-Version: 2.1
 Name: igm-model
-Version: 2.1.0
+Version: 2.2.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
-Requires-Python: <3.12
+Requires-Python: <3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: tensorflow[and-cuda]==2.14.0
 Requires-Dist: matplotlib
-Requires-Dist: numpy
 Requires-Dist: scipy
-Requires-Dist: tensorflow==2.12.0
 Requires-Dist: netCDF4
 Requires-Dist: xarray
 Requires-Dist: rasterio
 Requires-Dist: pyproj
 Requires-Dist: geopandas
 Requires-Dist: oggm
+Requires-Dist: salem
 Requires-Dist: importlib_resources
 
 [![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>
+
 
 # Overview    
 
 The Instructed Glacier Model (IGM) is an **open-source Python package**, which permits to simulate **3D glacier evolution** accounting for the coupling between ice thermo-dynamics, surface mass balance, and mass conservation. IGM features:
 
-- **Simplicity and modularity:** IGM is implemented in the most popular programming language -- Python -- at a low level of abstractivity. IGM is organized **module-wise** for clarity and to facilitate coupling, customization and commmunity development. For simplicity, IGM assumes a horizontal regular grid for numerical discretization and therefore deals with **2D gridded input and output data**.
+- **Accessibility and modularity:** IGM is implemented in the most popular programming language -- Python -- and takes large benefit of existing tools such as [OGGM](https://oggm.org/). It is organized **module-wise** to facilitate coupling, customization and commmunity development. For simplicity, IGM uses a horizontal regular grid for numerical discretization and therefore deals with **2D gridded input and output data**.
 
 - **State-of-the-art physics:** IGM implements mass conservation, **high-order** 3D ice flow mechanics, an **Enthalpy** model for the thermic regime of ice, **melt/accumulation surface mass balance** model, and other glaciological processes.
 
-- **Computational high efficiency:** Thanks to the **TensorFlow library**, mathematical operations are **fully-vectorized**. This permits tremendous **speed-ups on GPU**. **Physics-informed deep learning** is used as an alternative to numerical solvers for modelling ice flow physics in a vectorized way. While GPU are highly-recommended for modelling large domain / high resolution, IGM runs fairly well on CPU for individual glaciers.
+- **Computational efficiency:** Thanks to the **TensorFlow library**, mathematical operations are **fully-vectorized**. This permits tremendous **speed-ups on GPU**. **Physics-informed deep learning** is used as an alternative to numerical solvers for modelling ice flow physics in a vectorized way. While GPU are highly-recommended for modelling large domain / high resolution, IGM runs fairly well on CPU for individual glaciers.
 
 - **Automatic differentiation:** TensorFlow operations are differentiable. Therefore, automatic differentiation strongly facilitates and speeds-up inverse modelling / data assimilation.
   
 # 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 [concept paper](https://github.com/jouvetg/igm/blob/main/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/paper.pdf).
 
 # Discord channel
 
@@ -47,4 +52,3 @@ IGM has a [discord channel](https://discord.com/) for quick support, getting lat
 # Contact
 
 Feel free to drop me an email for any questions, bug reports, or ideas of model extension: guillaume.jouvet at unil.ch
-

{igm-model-2.1.0 → igm-model-2.2.1}/README.md

@@ -1,21 +1,26 @@
 [![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>
+
 
 # Overview    
 
 The Instructed Glacier Model (IGM) is an **open-source Python package**, which permits to simulate **3D glacier evolution** accounting for the coupling between ice thermo-dynamics, surface mass balance, and mass conservation. IGM features:
 
-- **Simplicity and modularity:** IGM is implemented in the most popular programming language -- Python -- at a low level of abstractivity. IGM is organized **module-wise** for clarity and to facilitate coupling, customization and commmunity development. For simplicity, IGM assumes a horizontal regular grid for numerical discretization and therefore deals with **2D gridded input and output data**.
+- **Accessibility and modularity:** IGM is implemented in the most popular programming language -- Python -- and takes large benefit of existing tools such as [OGGM](https://oggm.org/). It is organized **module-wise** to facilitate coupling, customization and commmunity development. For simplicity, IGM uses a horizontal regular grid for numerical discretization and therefore deals with **2D gridded input and output data**.
 
 - **State-of-the-art physics:** IGM implements mass conservation, **high-order** 3D ice flow mechanics, an **Enthalpy** model for the thermic regime of ice, **melt/accumulation surface mass balance** model, and other glaciological processes.
 
-- **Computational high efficiency:** Thanks to the **TensorFlow library**, mathematical operations are **fully-vectorized**. This permits tremendous **speed-ups on GPU**. **Physics-informed deep learning** is used as an alternative to numerical solvers for modelling ice flow physics in a vectorized way. While GPU are highly-recommended for modelling large domain / high resolution, IGM runs fairly well on CPU for individual glaciers.
+- **Computational efficiency:** Thanks to the **TensorFlow library**, mathematical operations are **fully-vectorized**. This permits tremendous **speed-ups on GPU**. **Physics-informed deep learning** is used as an alternative to numerical solvers for modelling ice flow physics in a vectorized way. While GPU are highly-recommended for modelling large domain / high resolution, IGM runs fairly well on CPU for individual glaciers.
 
 - **Automatic differentiation:** TensorFlow operations are differentiable. Therefore, automatic differentiation strongly facilitates and speeds-up inverse modelling / data assimilation.
   
 # 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 [concept paper](https://github.com/jouvetg/igm/blob/main/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/paper.pdf).
 
 # Discord channel
 
@@ -24,4 +29,3 @@ IGM has a [discord channel](https://discord.com/) for quick support, getting lat
 # Contact
 
 Feel free to drop me an email for any questions, bug reports, or ideas of model extension: guillaume.jouvet at unil.ch
-

igm-model-2.2.1/igm/__init__.py

@@ -0,0 +1,28 @@
+#!/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 sys
+import os
+sys.path.append(os.getcwd()) # I guess by default sys.path does not have cwd. not sure if this is the convention though...
+    
+from . import modules, emulators
+
+from .common import (
+    State,
+    params_core,
+    load_modules,
+    add_logger,
+    print_params,
+    load_dependent_modules,
+    get_modules_list,
+    load_user_defined_params,
+    run_intializers,
+    run_processes,
+    run_finalizers,
+    setup_igm_modules,
+    setup_igm_params,
+    add_logger,
+    print_gpu_info
+)

igm-model-2.2.1/igm/common.py

@@ -0,0 +1,380 @@
+#!/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 os, json
+from json import JSONDecodeError
+import importlib
+import argparse
+from argparse import ArgumentParser, Namespace
+from pathlib import Path
+from functools import partial
+from typing import List, Any, Dict, Tuple
+from types import ModuleType
+import logging
+import warnings
+
+import tensorflow as tf
+
+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.                                                                                                        │
+  │                                                                                                                  │
+  │                         __/\\\\\\\\\\\_____/\\\\\\\\\\\\__/\\\\____________/\\\\_                                │
+  │                          _\/////\\\///____/\\\//////////__\/\\\\\\________/\\\\\\_                               │
+  │                           _____\/\\\______/\\\_____________\/\\\//\\\____/\\\//\\\_                              │
+  │                            _____\/\\\_____\/\\\____/\\\\\\\_\/\\\\///\\\/\\\/_\/\\\_                             │
+  │                             _____\/\\\_____\/\\\___\/////\\\_\/\\\__\///\\\/___\/\\\_                            │
+  │                              _____\/\\\_____\/\\\_______\/\\\_\/\\\____\///_____\/\\\_                           │
+  │                               _____\/\\\_____\/\\\_______\/\\\_\/\\\_____________\/\\\_                          │
+  │                                __/\\\\\\\\\\\_\//\\\\\\\\\\\\/__\/\\\_____________\/\\\_                         │
+  │                                 _\///////////___\////////////____\///______________\///__                        │
+  └──────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
+"""
+
+
+class State:
+    pass
+
+
+# this create core parameters for any IGM run
+def params_core() -> argparse.ArgumentParser:
+    parser = ArgumentParser(
+        description=IGM_DESCRIPTION,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        conflict_handler="resolve",
+    )  # automatically overrides repeated/older parameters! Valid solution?
+
+    parser.add_argument(
+        "--param_file",
+        type=str,
+        default="params.json",
+        help="Path for the JSON parameter file. (default: %(default)s)",
+    )
+    parser.add_argument(
+        "--modules_preproc",
+        type=list,
+        default=["oggm_shop"],
+        help="List of pre-processing modules (default: %(default)s)",
+    )
+    parser.add_argument(
+        "--modules_process",
+        type=list,
+        default=["iceflow", "time", "thk"],
+        help="List of processing modules (default: %(default)s)",
+    )
+    parser.add_argument(
+        "--modules_postproc",
+        type=list,
+        default=["write_ncdf", "plot2d", "print_info"],
+        help="List of post-processing modules (default: %(default)s)",
+    )
+    parser.add_argument(
+        "--logging",
+        action="store_true",
+        default=False,
+        help="Activates the logging (default: %(default)s)",
+    )
+    parser.add_argument(
+        "--logging_level",
+        default=30,
+        type=int,
+        help="Determine logging level used for logger (default: %(default)s)",
+    )
+    parser.add_argument(
+        "--logging_file",
+        type=str,
+        default="",
+        help="Logging file name, if empty it prints in the screen (default: %(default)s)",
+    )
+    parser.add_argument(
+        "--print_params",
+        action="store_false",
+        default=True,
+        help="Print definitive parameters in a file for record (default: %(default)s)",
+    )
+    parser.add_argument(
+        "--gpu_info",
+        action="store_true",
+        default=False,
+        help="Print CUDA and GPU information to the screen (default: %(default)s)",
+    )
+    parser.add_argument(
+        "--gpu_id",
+        type=int,
+        default=0,
+        help="Id of the GPU to use (default: %(default)s)",
+    )
+    parser.add_argument(
+        "--saved_params_filename",
+        type=str,
+        default="params_saved",
+        help="Name of the file to store the parameters used in the run (default: %(default)s)",
+    )
+
+    return parser
+
+
+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)
+
+    return imported_modules
+
+
+def setup_igm_params(
+    parser: ArgumentParser, imported_modules: List[ModuleType]
+) -> Namespace:
+    for module in imported_modules:
+        module.params(parser)
+
+    core_and_module_params = parser.parse_args()
+    params = load_user_defined_params(
+        param_file=core_and_module_params.param_file,
+        params_dict=vars(core_and_module_params),
+    )
+
+    parser.set_defaults(**params)
+    params = parser.parse_args()
+
+    return params
+
+
+def run_intializers(modules: List, params: Any, state: State) -> None:
+    for module in modules:
+        module.initialize(params, state)
+
+
+def run_processes(modules: List, params: Any, state: State) -> None:
+    if hasattr(state, "t"):
+        while state.t < params.time_end:
+            for module in modules:
+                module.update(params, state)
+
+
+def run_finalizers(modules: List, params: Any, state: State) -> None:
+    for module in modules:
+        module.finalize(params, state)
+
+
+def add_logger(params, state) -> None:
+    if params.logging_file == "":
+        pathf = ""
+    else:
+        pathf = params.logging_file
+
+    logging.basicConfig(
+        filename=pathf,
+        encoding="utf-8",
+        filemode="w",
+        level=params.logging_level,
+        format="%(asctime)s - %(levelname)s - %(message)s",
+    )
+    logging.root.setLevel(params.logging_level)
+
+    state.logger = logging.getLogger("igm_logger")
+    if not pathf == "":
+        os.system("echo rm " + pathf + " >> clean.sh")
+
+
+def remove_comments(json_str) -> str:
+    lines = json_str.split("\n")
+    cleaned_lines = [
+        line for line in lines if not line.strip().startswith(("//", "#"))
+    ]  # ! TODO: Add blocks comments...
+    cleaned_text = "\n".join(cleaned_lines)
+    return cleaned_text
+
+
+def load_json_file(
+    param_file: str, remove_param_comments: bool = True
+) -> Dict[str, Any]:
+    with open(param_file, "r") as json_file:
+        json_text = json_file.read()
+
+    if remove_param_comments:
+        json_text = remove_comments(json_text)
+
+    dic_params = json.loads(json_text)
+    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)
+            module_dict = {
+                "modules_preproc": params_dict["modules_preproc"],
+                "modules_process": params_dict["modules_process"],
+                "modules_postproc": params_dict["modules_postproc"],
+            }
+
+            return module_dict
+    except JSONDecodeError as e:
+        raise JSONDecodeError(
+            msg="For the following line, please check the 1) JSON file structure and/or 2) make sure there are no comments (//, #, etc.)",
+            doc=e.doc,
+            pos=e.pos,
+        )
+
+
+def load_user_defined_params(param_file: str, params_dict: dict[str, Any]):
+    try:
+        json_defined_params = load_json_file(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.",
+            doc=e.doc,
+            pos=e.pos,
+        )
+
+    unrecognized_json_arguments = {
+        k: v for k, v in json_defined_params.items() if k not in params_dict
+    }
+    params_dict.update(json_defined_params)
+
+    for key in unrecognized_json_arguments.keys():
+        raise ValueError(
+            f"The following argument specified in the JSON file does not exist among the core arguments nor the modules you have chosen: {key}"
+        )
+
+    return params_dict
+
+
+def load_modules(modules_dict: Dict) -> List[ModuleType]:
+    """Returns a list of actionable modules to then apply the update, initialize, finalize functions on for IGM."""
+
+    imported_preproc_modules = load_modules_from_directory(
+        modules_list=modules_dict["modules_preproc"], module_folder="preproc"
+    )
+    imported_process_modules = load_modules_from_directory(
+        modules_list=modules_dict["modules_process"], module_folder="process"
+    )
+    imported_postproc_modules = load_modules_from_directory(
+        modules_list=modules_dict["modules_postproc"], module_folder="postproc"
+    )
+    # ? Should we have custom modules in a seperate folder?
+    # imported_custom_modules = load_modules_from_directory(
+    #     modules_list=modules_dict.modules_custom, module_folder=params.modules_custom_folder
+    # )
+
+    return (
+        imported_preproc_modules
+        + imported_process_modules
+        + imported_postproc_modules  # + imported_custom_modules
+    )
+
+
+def validate_module(module) -> None:
+    """Validates that a module has the required functions to be used in IGM."""
+    required_functions = ["params", "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 4 required functions: ['params', '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.",
+            )
+
+
+def load_modules_from_directory(
+    modules_list: List[str], module_folder: str
+) -> List[ModuleType]:
+    imported_modules = []
+    for module_name in modules_list:
+        module_path = f"igm.modules.{module_folder}.{module_name}"
+        try:
+            module = importlib.import_module(module_path)
+        except ModuleNotFoundError:
+            logging.info(
+                f"Error importing module: {module_path}, checking for custom package in current working directory."
+            )
+            try:
+                logging.info(
+                    f"Trying to import custom module from current working directory (folder or .py): {module_name}"
+                )
+                module = importlib.import_module(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."
+                )
+
+        validate_module(module)
+        imported_modules.append(module)
+
+    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 print_gpu_info() -> None:
+    gpus = tf.config.experimental.list_physical_devices("GPU")
+    print(f"{'CUDA Enviroment':-^150}")
+    tf.sysconfig.get_build_info().pop("cuda_compute_capabilities", None)
+    print(f"{json.dumps(tf.sysconfig.get_build_info(), indent=2, default=str)}")
+    print(f"{'Available GPU Devices':-^150}")
+    for gpu in gpus:
+        gpu_info = {"gpu_id": gpu.name, "device_type": gpu.device_type}
+        device_details = tf.config.experimental.get_device_details(gpu)
+        gpu_info.update(device_details)
+
+        print(f"{json.dumps(gpu_info, indent=2, default=str)}")
+    print(f"{'':-^150}")
+
+
+# Print parameters in screen and a dedicated file
+def print_params(params: Namespace) -> None:
+    param_file = params.saved_params_filename
+    param_file = param_file + ".json"
+
+    # load the given parameters
+    with open(param_file, "w") as json_file:
+        json.dump(params.__dict__, json_file, indent=2)
+
+    os.system("echo rm " + param_file + " >> clean.sh")

igm-model-2.2.1/igm/igm_run.py

@@ -0,0 +1,47 @@
+#!/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
+from igm import (
+    State,
+    params_core,
+    print_params,
+    run_intializers,
+    run_processes,
+    run_finalizers,
+    setup_igm_modules,
+    setup_igm_params,
+    print_gpu_info,
+    add_logger
+)
+
+
+def main() -> None:
+    state = State()  # class acting as a dictionary
+    parser = params_core()
+    params, _ = parser.parse_known_args()
+
+    if params.gpu_info:
+        print_gpu_info()
+
+    if params.logging:
+        add_logger(params=params, state=state)
+        tf.get_logger().setLevel(params.logging_level)
+        
+    imported_modules = setup_igm_modules(params)
+    params = setup_igm_params(parser, imported_modules)
+
+    if params.print_params:
+        print_params(params=params)
+
+    # 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
+        run_intializers(imported_modules, params, state)
+        run_processes(imported_modules, params, state)
+        run_finalizers(imported_modules, params, state)
+
+
+if __name__ == "__main__":
+    main()

{igm-model-2.1.0 → igm-model-2.2.1}/igm/instructed_oggm.py

@@ -76,8 +76,16 @@ class IGM_Model2D(Model2D):
         
         """
 
-        parser = argparse.ArgumentParser(description="IGM")
-        igm.params_iceflow(parser)
+        # parser = argparse.ArgumentParser(description="IGM")
+        parser = igm.params_core()
+        
+        params, __ = parser.parse_known_args()  # args=[] add this for jupyter notebook
+             
+        imported_modules = igm.load_modules(params)
+
+        for module in imported_modules:
+            module.params(parser)
+        
         self.params = parser.parse_args(args=[])
 
         self.state = igm.State()
@@ -111,7 +119,7 @@ class IGM_Model2D(Model2D):
 
         self.icemask = mb_filter
 
-        igm.initialize_iceflow(self.params, self.state)
+        igm.modules.process.iceflow.initialize(self.params, self.state)
 
     def step(self, dt):
         # recast glacier variables into igm-like variables
@@ -120,7 +128,7 @@ class IGM_Model2D(Model2D):
         self.state.usurf.assign(self.surface_h)
 
         # compute ubar and vbar
-        igm.update_iceflow(self.params, self.state)
+        igm.modules.process.iceflow.update(self.params, self.state)
 
         # retrurn the divergence of the flux using upwind fluxes
         divflux = (

{igm-model-2.1.0/igm/modules/preproc → igm-model-2.2.1/igm/modules}/__init__.py

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

igm-model-2.2.1/igm/modules/postproc/anim_mayavi/__init__.py

@@ -0,0 +1,6 @@
+from .anim_mayavi import (
+	params,
+	initialize,
+	finalize,
+	update
+)

{igm-model-2.1.0/igm/modules/postproc → igm-model-2.2.1/igm/modules/postproc/anim_mayavi}/anim_mayavi.py

@@ -3,26 +3,23 @@
 # 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, sys, shutil
-import time
 import tensorflow as tf
 import matplotlib.pyplot as plt
 
 
-def params_anim_mayavi(parser):
+def params(parser):
     pass
 
 
-def initialize_anim_mayavi(params, state):
+def initialize(params, state):
     pass
 
 
-def update_anim_mayavi(params, state):
+def update(params, state):
     pass
 
 
-def finalize_anim_mayavi(params, state):
+def finalize(params, state):
     from mayavi import mlab
     import xarray as xr
     import numpy as np
@@ -30,9 +27,7 @@ def finalize_anim_mayavi(params, state):
 
     plt.close("all")
 
-    ds = xr.open_dataset(
-        os.path.join(params.working_dir, "output.nc"), engine="netcdf4"
-    )
+    ds = xr.open_dataset("output.nc", engine="netcdf4")
 
     X, Y = np.meshgrid(ds.x, ds.y)
 
@@ -57,7 +52,7 @@ def finalize_anim_mayavi(params, state):
 
     VEC = hasattr(ds, "uvelsurf") & hasattr(ds, "vvelsurf") & hasattr(ds, "wvelsurf")
 
-    PAR = os.path.isdir(os.path.join(params.working_dir, "trajectories"))
+    PAR = os.path.isdir("trajectories")
 
     if VEC:
         quiv = mlab.quiver3d(
@@ -70,7 +65,7 @@ def finalize_anim_mayavi(params, state):
         )
 
     # if PAR:
-    #     f = os.path.join(params.working_dir, "trajectories",'traj-'+"{:06.0f}".format(TIME[0])+".csv")
+    #     f = os.path.join("trajectories",'traj-'+"{:06.0f}".format(TIME[0])+".csv")
     #     XYZ = np.loadtxt(f,skiprows=1,delimiter=',')
     #     pt3d = mlab.points3d(XYZ[:,1], XYZ[:,2], XYZ[:,3], colormap="RdBu",mode='point')
     #     pt3d.actor.property.point_size = 5
@@ -87,7 +82,7 @@ def finalize_anim_mayavi(params, state):
                 quiv.mlab_source.v = np.array(tf.expand_dims(ds.vvelsurf[i], axis=0))
                 quiv.mlab_source.w = np.array(tf.expand_dims(ds.wvelsurf[i], axis=0))
             # if PAR:
-            #     f = os.path.join(params.working_dir, "trajectories",'traj-'+"{:06.0f}".format(TIME[i])+".csv")
+            #     f = os.path.join("trajectories",'traj-'+"{:06.0f}".format(TIME[i])+".csv")
             #     XYZ = np.loadtxt(f,skiprows=1,delimiter=',')
             #     pt3d.mlab_source.x = XYZ[:,1]
             #     pt3d.mlab_source.y = XYZ[:,2]