Add CI and ability to control simulation dates

.github/workflows/tests.yaml

@@ -0,0 +1,59 @@
+name: CI
+
+on:
+  push:
+    branches:
+      - '*'
+  pull_request:
+    branches:
+      - main
+
+jobs:
+
+  test:
+    name: ${{ matrix.python-version }}-build
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.12",]
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Create conda environment
+        uses: mamba-org/setup-micromamba@v1
+        with:
+          cache-downloads: true
+          cache-environment: true
+          micromamba-version: 'latest'
+          environment-file: ci/environment.yml
+          create-args: |
+            python=${{ matrix.python-version }}
+
+      - name: Environment info
+        shell: bash
+        run: |
+          conda info
+          printenv
+
+      - name: Install C-Star
+        shell: micromamba-shell {0}
+        run: |
+           python - V
+           python -m pip install -e cstar_ocean --no-deps --force-reinstall
+
+      - name: Running Tests
+        shell: bash -l {0}
+        run: |
+           python -V
+           coverage run --rcfile=coverage.toml cstar_ocean/tests/test_roms_marbl_example.py
+
+      - name: Get coverage report
+        shell: bash -l {0}
+        run: |
+          coverage report -m ; coverage xml
+
+      - name: Upload coverage reports to Codecov
+        uses: codecov/codecov-action@v4.0.1
+        with:
+          token: ${{ secrets.CODECOV_TOKEN }}
+          files: ./coverage.xml

README.md

@@ -1,3 +1,4 @@
+[![codecov](https://codecov.io/github/dafyddstephenson/C-Star/branch/automated_testing/graph/badge.svg?token=Z0L4U76WSG)](https://codecov.io/github/dafyddstephenson/C-Star)
 # C-Star
 Computational Systems for Tracking Ocean Carbon
 

ci/environment.yml

@@ -0,0 +1,15 @@
+name: cstar_env
+channels:
+  - conda-forge
+dependencies:
+  - python>=3.10
+  - pooch
+  - pyyaml
+  - python-dateutil
+  - coverage
+  - numpy
+  - compilers
+  - netcdf-fortran
+  - mpich
+  - nco
+  - ncview

coverage.toml

@@ -0,0 +1,7 @@
+[tool.coverage.run]
+source = ["cstar_ocean"]
+omit = [
+    "tests/*",
+    "**/__init__.py",
+    "setup.py",
+]

cstar_ocean/cstar_ocean/component.py

@@ -1,12 +1,20 @@
 import os
 import glob
+import warnings
 import subprocess
 from abc import ABC, abstractmethod
 from typing import List, Optional, Any
 
 from cstar_ocean.utils import _calculate_node_distribution, _replace_text_in_file
 from cstar_ocean.base_model import ROMSBaseModel, BaseModel
-from cstar_ocean.input_dataset import InputDataset
+from cstar_ocean.input_dataset import (
+    InputDataset,
+    InitialConditions,
+    ModelGrid,
+    SurfaceForcing,
+    BoundaryForcing,
+    TidalForcing,
+)
 from cstar_ocean.additional_code import AdditionalCode
 
 from cstar_ocean.environment import (
@@ -69,7 +77,7 @@ def __init__(self, **kwargs: Any):
             An intialized Component object
         """
 
-        # FIXME: do Type checking here
+        # TODO: do Type checking here
         if "base_model" not in kwargs or not isinstance(
             kwargs["base_model"], BaseModel
         ):
@@ -107,26 +115,27 @@ def __str__(self):
         )
 
         base_str += "\n\nDiscretization info:"
-        if hasattr(self,'n_procs_x') and self.n_procs_x is not None:
+        if hasattr(self, "time_step") and self.time_step is not None:
+            base_str += "\ntime_step: " + str(self.time_step)
+        if hasattr(self, "n_procs_x") and self.n_procs_x is not None:
             base_str += (
-                "\nn_procs_x:"
+                "\nn_procs_x: "
                 + str(self.n_procs_x)
                 + " (Number of x-direction processors)"
             )
-        if hasattr(self,'n_procs_y') and self.n_procs_y is not None:
+        if hasattr(self, "n_procs_y") and self.n_procs_y is not None:
             base_str += (
                 "\nn_procs_y:"
                 + str(self.n_procs_y)
                 + " (Number of y-direction processors)"
             )
-        if hasattr(self,'n_levels') and self.n_levels is not None:
+        if hasattr(self, "n_levels") and self.n_levels is not None:
             base_str += "\nn_levels:" + str(self.n_levels)
-        if hasattr(self,'nx') and self.nx is not None:
+        if hasattr(self, "nx") and self.nx is not None:
             base_str += "\nnx:" + str(self.nx)
-        if hasattr(self,'ny') and self.ny is not None:
+        if hasattr(self, "ny") and self.ny is not None:
             base_str += "\nny:" + str(self.ny)
-
-        if hasattr(self,'exe_path') and self.exe_path is not None:
+        if hasattr(self, "exe_path") and self.exe_path is not None:
             base_str += "\n\nIs compiled: True"
             base_str += "\n exe_path: " + self.exe_path
         return base_str
@@ -186,6 +195,8 @@ class ROMSComponent(Component):
     input_datasets: InputDataset or list of InputDatasets
         Any spatiotemporal data needed to run this instance of ROMS
         e.g. initial conditions, surface forcing, etc.
+    time_step: int, Optional, default=1
+        The time step with which to run ROMS in this configuration
     nx,ny,n_levels: int
         The number of x and y points and vertical levels in the domain associated with this object
     n_procs_x,n_procs_y: int
@@ -213,6 +224,7 @@ def __init__(
         base_model: ROMSBaseModel,
         additional_code: Optional[AdditionalCode] = None,
         input_datasets: Optional[InputDataset | List[InputDataset]] = None,
+        time_step: int = 1,
         nx: Optional[int] = None,
         ny: Optional[int] = None,
         n_levels: Optional[int] = None,
@@ -252,6 +264,7 @@ def __init__(
             input_datasets=input_datasets,
         )
         # QUESTION: should all these attrs be passed in as a single "discretization" arg of type dict?
+        self.time_step: int = time_step
         self.nx: Optional[int] = nx
         self.ny: Optional[int] = ny
         self.n_levels: Optional[int] = n_levels
@@ -308,29 +321,61 @@ def pre_run(self):
 
         # Partition input datasets
         if self.input_datasets is not None:
-            datasets_to_partition = (
-                self.input_datasets
-                if isinstance(self.input_datasets, list)
-                else [
+            if isinstance(self.input_datasets, InputDataset):
+                dataset_list = [
                     self.input_datasets,
                 ]
-            )
+            elif isinstance(self.input_datasets, list):
+                dataset_list = self.input_datasets
+            else:
+                dataset_list = []
+
+            datasets_to_partition = [d for d in dataset_list if d.exists_locally]
 
             for f in datasets_to_partition:
                 dspath = f.local_path
                 fname = os.path.basename(f.source)
 
-                os.makedirs(dspath + "/PARTITIONED", exist_ok=True)
+                os.makedirs(os.path.dirname(dspath) + "/PARTITIONED", exist_ok=True)
                 subprocess.run(
                     "partit "
                     + str(self.n_procs_x)
                     + " "
                     + str(self.n_procs_y)
                     + " ../"
                     + fname,
-                    cwd=dspath + "PARTITIONED",
+                    cwd=os.path.dirname(dspath) + "/PARTITIONED",
                     shell=True,
                 )
+            # Edit namelist file to contain dataset paths
+            forstr = ""
+            namelist_path = (
+                self.additional_code.local_path
+                + "/"
+                + self.additional_code.namelists[0]
+            )
+            for f in datasets_to_partition:
+                partitioned_path = (
+                    os.path.dirname(f.local_path)
+                    + "/PARTITIONED/"
+                    + os.path.basename(f.local_path)
+                )
+                if isinstance(f, ModelGrid):
+                    gridstr = "     " + partitioned_path + "\n"
+                    _replace_text_in_file(
+                        namelist_path, "__GRID_FILE_PLACEHOLDER__", gridstr
+                    )
+                elif isinstance(f, InitialConditions):
+                    icstr = "     " + partitioned_path + "\n"
+                    _replace_text_in_file(
+                        namelist_path, "__INITIAL_CONDITION_FILE_PLACEHOLDER__", icstr
+                    )
+                elif type(f) in [SurfaceForcing, TidalForcing, BoundaryForcing]:
+                    forstr += "     " + partitioned_path + "\n"
+
+            _replace_text_in_file(
+                namelist_path, "__FORCING_FILES_PLACEHOLDER__", forstr
+            )
 
         ################################################################################
         ## NOTE: we assume that roms.in is the ONLY entry in additional_code.namelists, hence [0]
@@ -346,10 +391,12 @@ def pre_run(self):
             "MARBL_NAMELIST_DIR",
             self.additional_code.local_path + "/namelists/MARBL",
         )
+
         ################################################################################
 
     def run(
         self,
+        n_time_steps: Optional[int] = None,
         account_key: Optional[str] = None,
         walltime: Optional[str] = _CSTAR_SYSTEM_MAX_WALLTIME,
         job_name: str = "my_roms_run",
@@ -383,9 +430,34 @@ def run(
                 + "\nIf you have already run Component.get(), either run it again or "
                 + " add the local path manually using Component.additional_code.local_path='YOUR/PATH'."
             )
+            return
         else:
             run_path = self.additional_code.local_path + "/output/PARTITIONED/"
 
+        # Add number of timesteps to namelist
+        # Check if n_time_steps is None, indicating it was not explicitly set
+        if n_time_steps is None:
+            n_time_steps = 1
+            warnings.warn(
+                "n_time_steps not explicitly set, using default value of 1. "
+                "Please call ROMSComponent.run() with the n_time_steps argument "
+                "to specify the length of the run.",
+                UserWarning,
+            )
+            assert isinstance(n_time_steps, int)
+
+        if self.additional_code.namelists is None:
+            raise ValueError(
+                "A namelist file (typically roms.in) is needed to run ROMS."
+                " ROMSComponent.additional_code.namelists should be a non-empty list of filenames."
+            )
+
+        _replace_text_in_file(
+            self.additional_code.local_path + "/" + self.additional_code.namelists[0],
+            "__NTIMES_PLACEHOLDER__",
+            str(n_time_steps),
+        )
+
         os.makedirs(run_path, exist_ok=True)
         if self.exe_path is None:
             # FIXME this only works if build() is called in the same session
@@ -410,9 +482,9 @@ def run(
                     exec_pfx = "mpirun"
                 case "osx_arm64":
                     exec_pfx = "mpirun"
+                case "linux_x86_64":
+                    exec_pfx = "mpirun"
 
-                # FIXME (probably throughout): self.additional_code /could/ be a list
-                # need to figure out which element to use
             roms_exec_cmd = (
                 f"{exec_pfx} -n {self.n_procs_tot} {self.exe_path} "
                 + f"{self.additional_code.local_path}/{self.additional_code.namelists[0]}"