[JTH] initial struc for delft3d and more docus

Author: tausiaj

bluemath_tk/wrappers/_base_wrappers.py

@@ -348,6 +348,25 @@ def build_cases(self, mode: str = "one_by_one") -> None:
             f"{len(self.cases_dirs)} cases created in {mode} mode and saved in {self.output_dir}"
         )
 
+    def run_case(self, case_dir: str, launcher: str) -> None:
+        """
+        Run the case based on the launcher specified.
+
+        Parameters
+        ----------
+        case_dir : str
+            The case directory.
+        launcher : str
+            The launcher to run the case.
+        """
+
+        # Get launcher command from the available launchers
+        launcher = self.list_available_launchers().get(launcher, launcher)
+
+        self.logger.info(f"Running case in {case_dir} with launcher={launcher}.")
+        os.chdir(case_dir)
+        self._exec_bash_commands(str_cmd=launcher)
+
     def run_cases(
         self,
         launcher: str,
@@ -379,9 +398,6 @@ def run_cases(
             cases_dir_to_run = [self.cases_dirs[case] for case in cases_to_run]
         else:
             cases_dir_to_run = copy.deepcopy(self.cases_dirs)
-        cases_exec_commands = [
-            launcher.replace("$case_dir", case_dir) for case_dir in cases_dir_to_run
-        ]
 
         if parallel:
             num_threads = self.get_num_processors_available()
@@ -390,29 +406,28 @@ def run_cases(
             )
             with ThreadPoolExecutor(max_workers=num_threads) as executor:
                 future_to_case = {
-                    executor.submit(
-                        self._exec_bash_commands, case_exec_command
-                    ): case_exec_command
-                    for case_exec_command in cases_exec_commands
+                    executor.submit(self.run_case, case_dir, launcher): case_dir
+                    for case_dir in cases_dir_to_run
                 }
                 for future in as_completed(future_to_case):
-                    case_exec_command = future_to_case[future]
+                    case_dir = future_to_case[future]
                     try:
                         future.result()
                     except Exception as exc:
                         self.logger.error(
-                            f"Job {case_exec_command} generated an exception: {exc}."
+                            f"Job for {case_dir} generated an exception: {exc}."
                         )
         else:
             self.logger.info(f"Running cases sequentially with launcher={launcher}.")
-            for case_exec_command in cases_exec_commands:
+            for case_dir in cases_dir_to_run:
                 try:
-                    self._exec_bash_commands(
-                        str_cmd=case_exec_command,
+                    self.run_case(
+                        case_dir=case_dir,
+                        launcher=launcher,
                     )
                 except Exception as exc:
                     self.logger.error(
-                        f"Job {case_exec_command} generated an exception: {exc}."
+                        f"Job for {case_dir} generated an exception: {exc}."
                     )
 
         if launcher == "docker" or "docker" in launcher:
@@ -427,23 +442,14 @@ def run_cases_bulk(
         launcher: str,
     ) -> None:
         """
-        Run the cases based on the scheduler, script, and parameters.
+        Run the cases based on the launcher specified.
 
         Parameters
         ----------
         launcher : str
             The launcher to run the cases.
-
-        Raises
-        ------
-        ValueError
-            If the launcher is not recognized or the script does not exist.
         """
 
-        if launcher not in self.list_available_launchers():
-            raise ValueError(
-                f"Invalid launcher: {launcher}, not in {self.list_available_launchers()}."
-            )
         self.logger.info(f"Running cases with launcher={launcher}.")
         self._exec_bash_commands(str_cmd=launcher)
 

bluemath_tk/wrappers/delft3d/delft3d_wrapper.py

@@ -0,0 +1,41 @@
+from .._base_wrappers import BaseModelWrapper
+
+
+class Delft3dModelWrapper(BaseModelWrapper):
+    """
+    Wrapper for the Delft3d model.
+
+    Attributes
+    ----------
+    default_parameters : dict
+        The default parameters type for the wrapper.
+    available_launchers : dict
+        The available launchers for the wrapper.
+    """
+
+    default_parameters = {}
+
+    available_launchers = {"geoocean-cluster": "launchDelft3d.sh"}
+
+    def __init__(
+        self,
+        templates_dir: str,
+        model_parameters: dict,
+        output_dir: str,
+        templates_name: dict = "all",
+        debug: bool = True,
+    ) -> None:
+        """
+        Initialize the Delft3d model wrapper.
+        """
+
+        super().__init__(
+            templates_dir=templates_dir,
+            model_parameters=model_parameters,
+            output_dir=output_dir,
+            templates_name=templates_name,
+            default_parameters=self.default_parameters,
+        )
+        self.set_logger_name(
+            name=self.__class__.__name__, level="DEBUG" if debug else "INFO"
+        )

bluemath_tk/wrappers/swash/swash_wrapper.py

@@ -59,8 +59,9 @@ class SwashModelWrapper(BaseModelWrapper):
     }
 
     available_launchers = {
-        "bash": "cd $case_dir && swashrun -input input.sws",
-        "docker": "docker run --rm -v $case_dir:/case_dir -w /case_dir tausiaj/swash-geoocean:11.01 swashrun -input input.sws",
+        "bash": "swashrun -input input.sws",
+        "docker": "docker run --rm -v .:/case_dir -w /case_dir tausiaj/swash-geoocean:11.01 swashrun -input input.sws",
+        "geoocean-cluster": "launchSwash.sh",
     }
 
     postprocess_functions = {

docs/contribute.md

@@ -70,3 +70,46 @@ By contributing to the BlueMath package, you agree that your contributions will
 If you have any questions or need further assistance, feel free to reach out to the maintainers.
 
 Thank you for your contributions and support!
+
+## Documentation
+
+When creating new `python` code, it is essential to properly document all new classes and functions. Below, we show how the **docstrings** of classes should look, so the community can properly learn how to use **BlueMath**.
+
+Code example:
+```python
+import numpy as np
+
+class HyWavesExample:
+    """
+    This class implements a HyWaves Metamodel Example for nearshore wave propagations.
+
+    Attributes
+    ----------
+    waves_model : str
+        The waves numerical model to use.
+    statistical_model : str, optional
+        The statistical model to use. Default is "MDA".
+
+    Methods
+    -------
+    run_model -> np.ndarray
+        Runs the waves numerical model and returns the output.
+    """
+
+    def __init__(self, waves_model: str, statistical_model: str = "MDA") -> None:
+        self.waves_model = waves_model
+        self.statistical_model = statistical_model
+
+    def run_model(self, launcher: str) -> np.ndarray:
+        """
+        Runs the numerical waves model.
+
+        Parameters
+        ----------
+        launcher : str
+            The launcher to use.
+        """
+
+        self.run_model(launcher=launcher, model=self.waves_model)
+        return self.get_model_ouput()
+```

docs/installation.md

@@ -23,4 +23,4 @@ conda activate bluemath
 5. Finally, install package in development mode:
 ```sh
 pip install -e .
-```
+```