ladim 1.3.4__py3-none-any.whl → 2.0.0__py3-none-any.whl

ladim/__init__.py

@@ -1,3 +1,3 @@
-__version__ = '1.3.4'
+__version__ = '2.0.0'
 
 from .main import main, run

ladim/config.py

@@ -0,0 +1,125 @@
+"""
+Functions for parsing configuration parameters.
+
+The module contains functions for parsing input configuration
+parameters, appending default values and converting between
+different versions of config file formats.
+"""
+import numpy as np
+
+
+def configure(module_conf):
+    import yaml
+
+    # Handle variations of input config type
+    if isinstance(module_conf, dict):
+        config_dict = module_conf
+    else:
+        config_dict = yaml.safe_load(module_conf)
+
+    if 'version' not in config_dict:
+        if 'particle_release' in config_dict:
+            config_dict['version'] = 1
+        else:
+            config_dict['version'] = 2
+
+    return _versioned_configure(config_dict)
+
+
+def _versioned_configure(config_dict):
+    if config_dict['version'] == 1:
+        config_dict = _convert_1_to_2(config_dict)
+
+    return config_dict
+
+
+def _convert_1_to_2(c):
+    # Read timedelta
+    dt_value, dt_unit = c['numerics']['dt']
+    dt_sec = np.timedelta64(dt_value, dt_unit).astype('timedelta64[s]').astype('int64')
+
+    # Read output variables
+    outvars = dict()
+    outvar_names = c['output_variables'].get('particle', []) + c['output_variables'].get('instance', [])
+    for v in outvar_names:
+        outvars[v] = c['output_variables'][v].copy()
+    for v in c['output_variables'].get('particle', []):
+        outvars[v]['kind'] = 'initial'
+    if 'release_time' in outvars and 'units' in outvars['release_time']:
+        outvars['release_time']['units'] = 'seconds since 1970-01-01'
+
+    # Read release config
+    relconf = dict(
+        file=c['files']['particle_release_file'],
+        frequency=c['particle_release'].get('release_frequency', [0, 's']),
+        colnames=c['particle_release']['variables'],
+        formats={
+            c['particle_release'][v]: v
+            for v in c['particle_release']['variables']
+            if v in c['particle_release'].keys()
+        },
+    )
+    if c['particle_release'].get('release_type', '') != 'continuous':
+        del relconf['frequency']
+    ibmvars = c.get('state', dict()).get('ibm_variables', [])
+    ibmvars += c.get('ibm', dict()).get('variables', [])
+    relconf['defaults'] = {
+        k: np.float64(0)
+        for k in ibmvars
+        if k not in relconf['colnames']
+    }
+
+    # Read ibm config
+    ibmconf_legacy = c.get('ibm', dict()).copy()
+    if 'module' in ibmconf_legacy:
+        ibmconf_legacy['ibm_module'] = ibmconf_legacy.pop('module')
+    ibmconf = dict()
+    if 'ibm_module' in ibmconf_legacy:
+        ibmconf['module'] = 'ladim.ibms.LegacyIBM'
+        ibmconf['legacy_module'] = ibmconf_legacy['ibm_module']
+        ibmconf['conf'] = dict(
+            dt=dt_sec,
+            output_instance=c.get('output_variables', {}).get('instance', []),
+            nc_attributes={k: v for k, v in outvars.items()}
+        )
+        ibmconf['conf']['ibm'] = {
+            k: v
+            for k, v in ibmconf_legacy.items()
+            if k != 'ibm_module'
+        }
+
+    config_dict = dict(
+        version=2,
+        solver=dict(
+            start=c['time_control']['start_time'],
+            stop=c['time_control']['stop_time'],
+            step=dt_sec,
+            seed=c['numerics'].get('seed', None),
+            order=['release', 'forcing', 'output', 'tracker', 'ibm', 'state'],
+        ),
+        grid=dict(
+            file=c['gridforce']['input_file'],
+            legacy_module=c['gridforce']['module'] + '.Grid',
+            start_time=np.datetime64(c['time_control']['start_time'], 's'),
+        ),
+        forcing=dict(
+            file=c['gridforce']['input_file'],
+            legacy_module=c['gridforce']['module'] + '.Forcing',
+            start_time=np.datetime64(c['time_control']['start_time'], 's'),
+            stop_time=np.datetime64(c['time_control']['stop_time'], 's'),
+            dt=dt_sec,
+            ibm_forcing=c['gridforce'].get('ibm_forcing', []),
+        ),
+        release=relconf,
+        output=dict(
+            file=c['files']['output_file'],
+            frequency=c['output_variables']['outper'],
+            variables=outvars,
+        ),
+        tracker=dict(
+            method=c['numerics']['advection'],
+            diffusion=c['numerics']['diffusion'],
+        ),
+        ibm=ibmconf,
+    )
+    return config_dict

ladim/forcing.py

@@ -0,0 +1,95 @@
+from .model import Model, Module
+
+
+class Forcing(Module):
+    def __init__(self, model: Model):
+        super().__init__(model)
+
+    def velocity(self, X, Y, Z, tstep=0.0):
+        raise NotImplementedError
+
+
+class RomsForcing(Forcing):
+    def __init__(self, model: Model, file, variables=None, **conf):
+        """
+        Forcing module which uses output data from the ROMS ocean model
+
+        :param model: Parent model
+        :param file: Glob pattern for the input files
+        :param variables: A mapping of variable names to interpolation
+        specifications. Each interpolaction specification consists of 0-4
+        of the letters "xyzt". Coordinates that are listed in the string are
+        interpolated linearly, while the remaining ones use nearest-neighbor
+        interpolation. Some default configurations are defined:
+
+        .. code-block:: json
+            {
+                "temp": "xyzt",
+                "salt": "xyzt",
+                "u": "xt",
+                "v": "yt",
+                "w": "zt",
+            }
+
+
+        :param conf: Legacy config dict
+        """
+        super().__init__(model)
+
+        # Apply default interpolation configs
+        variables = variables or dict()
+        default_vars = dict(u="xt", v="yt", w="zt", temp="xyzt", salt="xyzt")
+        self.variables = {**default_vars, **variables}
+
+        grid_ref = GridReference(model)
+        legacy_conf = dict(
+            gridforce=dict(
+                input_file=file,
+            ),
+            ibm_forcing=conf.get('ibm_forcing', []),
+            start_time=conf.get('start_time', None),
+            stop_time=conf.get('stop_time', None),
+            dt=conf.get('dt', None),
+        )
+
+        from .model import load_class
+        LegacyForcing = load_class(conf.get('legacy_module', 'ladim.gridforce.ROMS.Forcing'))
+
+        # Allow gridforce module in current directory
+        import sys
+        import os
+        sys.path.insert(0, os.getcwd())
+        # Import correct gridforce_module
+        self.forcing = LegacyForcing(legacy_conf, grid_ref)
+        # self.steps = self.forcing.steps
+        # self.U = self.forcing.U
+        # self.V = self.forcing.V
+
+    def update(self):
+        elapsed = self.model.solver.time - self.model.solver.start
+        t = elapsed // self.model.solver.step
+
+        self.forcing.update(t)
+
+        # Update state variables by sampling the field
+        x, y, z = self.model.state['X'], self.model.state['Y'], self.model.state['Z']
+        for v in self.variables:
+            if v in self.model.state:
+                self.model.state[v] = self.field(x, y, z, v)
+
+    def velocity(self, X, Y, Z, tstep=0.0):
+        return self.forcing.velocity(X, Y, Z, tstep=tstep)
+
+    def field(self, X, Y, Z, name):
+        return self.forcing.field(X, Y, Z, name)
+
+    def close(self):
+        return self.forcing.close()
+
+
+class GridReference:
+    def __init__(self, modules: Model):
+        self.modules = modules
+
+    def __getattr__(self, item):
+        return getattr(self.modules.grid.grid, item)

ladim/grid.py

@@ -0,0 +1,79 @@
+from .model import Model, Module
+
+
+class Grid(Module):
+    def __init__(self, model: Model):
+        super().__init__(model)
+
+    def ingrid(self, X, Y):
+        raise NotImplementedError
+
+    def sample_metric(self, X, Y):
+        raise NotImplementedError
+
+    def atsea(self, X, Y):
+        raise NotImplementedError
+
+    def ll2xy(self, lon, lat):
+        raise NotImplementedError
+
+    def xy2ll(self, x, y):
+        raise NotImplementedError
+
+
+class RomsGrid(Grid):
+    def __init__(self, model: Model, **conf):
+        super().__init__(model)
+
+        legacy_conf = dict(
+            gridforce=dict(
+                input_file=conf['file'],
+            ),
+            start_time=conf.get('start_time', None),
+        )
+
+        from .model import load_class
+        LegacyGrid = load_class(conf.get('legacy_module', 'ladim.gridforce.ROMS.Grid'))
+
+        # Allow gridforce module in current directory
+        import sys
+        import os
+        sys.path.insert(0, os.getcwd())
+        # Import correct gridforce_module
+        # gridforce_module = importlib.import_module(config["gridforce_module"])
+        self.grid = LegacyGrid(legacy_conf)
+        self.xmin = self.grid.xmin
+        self.xmax = self.grid.xmax
+        self.ymin = self.grid.ymin
+        self.ymax = self.grid.ymax
+
+    def sample_metric(self, X, Y):
+        """Sample the metric coefficients"""
+        return self.grid.sample_metric(X, Y)
+
+    def sample_depth(self, X, Y):
+        """Return the depth of grid cells"""
+        return self.grid.sample_depth(X, Y)
+
+    def lonlat(self, X, Y, method=None):
+        """Return the longitude and latitude from grid coordinates"""
+        return self.grid.lonlat(X, Y, method=method)
+
+    def ingrid(self, X, Y):
+        """Returns True for points inside the subgrid"""
+        return self.grid.ingrid(X, Y)
+
+    def onland(self, X, Y):
+        """Returns True for points on land"""
+        return self.grid.onland(X, Y)
+
+    # Error if point outside
+    def atsea(self, X, Y):
+        """Returns True for points at sea"""
+        return self.grid.atsea(X, Y)
+
+    def ll2xy(self, lon, lat):
+        return self.grid.ll2xy(lon, lat)
+
+    def xy2ll(self, X, Y):
+        return self.grid.xy2ll(X, Y)

ladim/gridforce/ROMS.py

@@ -168,6 +168,10 @@ class Grid:
         I = X.round().astype(int) - self.i0
         J = Y.round().astype(int) - self.j0
 
+        # Constrain to valid indices
+        I = np.minimum(np.maximum(I, 0), self.dx.shape[-1] - 2)
+        J = np.minimum(np.maximum(J, 0), self.dx.shape[-2] - 2)
+
         # Metric is conform for PolarStereographic
         A = self.dx[J, I]
         return A, A
@@ -207,6 +211,11 @@ class Grid:
         """Returns True for points at sea"""
         I = X.round().astype(int) - self.i0
         J = Y.round().astype(int) - self.j0
+
+        # Constrain to valid indices
+        I = np.minimum(np.maximum(I, 0), self.M.shape[-1] - 1)
+        J = np.minimum(np.maximum(J, 0), self.M.shape[-2] - 1)
+
         return self.M[J, I] > 0
 
     def xy2ll(self, X, Y):
@@ -239,6 +248,10 @@ class Forcing:
         # self.config = config["gridforce"]
         self.ibm_forcing = config["ibm_forcing"]
 
+        config = config.copy()
+        config["start_time"] = np.datetime64(config["start_time"])
+        config["stop_time"] = np.datetime64(config["stop_time"])
+
         files = self.find_files(config["gridforce"])
         numfiles = len(files)
         if numfiles == 0:
@@ -319,12 +332,17 @@ class Forcing:
     @staticmethod
     def find_files(force_config):
         """Find (and sort) the forcing file(s)"""
-        files = glob.glob(force_config["input_file"])
+
+        # Use unix-style filenames to provide consistency between windows and linux
+        first_file = force_config.get("first_file", "").replace("\\", "/")
+        last_file = force_config.get("last_file", "").replace("\\", "/")
+        files = [f.replace("\\", "/") for f in glob.glob(force_config["input_file"])]
+
         files.sort()
-        if force_config.get("first_file", None):
-            files = [f for f in files if f >= force_config["first_file"]]
-        if force_config.get("last_file", None):
-            files = [f for f in files if f <= force_config["last_file"]]
+        if first_file:
+            files = [f for f in files if f >= first_file]
+        if last_file:
+            files = [f for f in files if f <= last_file]
         return files
 
     @staticmethod
@@ -713,6 +731,10 @@ def z2s(z_rho, X, Y, Z):
     I = np.around(X).astype("int")
     J = np.around(Y).astype("int")
 
+    # Constrain to valid indices
+    I = np.minimum(np.maximum(I, 0), z_rho.shape[-1] - 1)
+    J = np.minimum(np.maximum(J, 0), z_rho.shape[-2] - 1)
+
     # Vectorized searchsorted
     K = np.sum(z_rho[:, J, I] < -Z, axis=0)
     K = K.clip(1, kmax - 1)
@@ -747,6 +769,11 @@ def sample3D(F, X, Y, K, A, method="bilinear"):
         # Find rho-point as lower left corner
         I = X.astype("int")
         J = Y.astype("int")
+
+        # Constrain to valid indices
+        I = np.minimum(np.maximum(I, 0), F.shape[-1] - 2)
+        J = np.minimum(np.maximum(J, 0), F.shape[-2] - 2)
+
         P = X - I
         Q = Y - J
         W000 = (1 - P) * (1 - Q) * (1 - A)

ladim/gridforce/__init__.py

@@ -1 +0,0 @@
-from .legacy import Grid, Forcing

ladim/ibms/__init__.py

@@ -1,6 +1,21 @@
-class IBM:
-    def __init__(self, *_, **__):
-        pass
+from ..model import Model, Module
+
+
+class IBM(Module):
+    def __init__(self, model: Model):
+        super().__init__(model)
+
+
+class LegacyIBM(IBM):
+    def __init__(self, model: Model, legacy_module, conf):
+        super().__init__(model)
+
+        from ..model import load_class
+        LegacyIbmClass = load_class(legacy_module + '.IBM')
+        self._ibm = LegacyIbmClass(conf)
 
     def update(self):
-        pass
+        grid = self.model['grid']
+        state = self.model['state']
+        forcing = self.model['forcing']
+        self._ibm.update_ibm(grid, state, forcing)

ladim/main.py

@@ -15,7 +15,7 @@ import logging
 
 import ladim
 
-from .configuration import configure
+from .config import configure
 from .model import Model
 
 

ladim/model.py

@@ -1,22 +1,25 @@
 import importlib
 
-import ladim.gridforce
-import ladim.ibms
-import ladim.output
-import ladim.release
-import ladim.state
-import ladim.tracker
-import ladim.timestepper
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from ladim.grid import Grid
+    from ladim.forcing import Forcing
+    from ladim.ibms import IBM
+    from ladim.output import Output
+    from ladim.release import Releaser
+    from ladim.state import State
+    from ladim.tracker import Tracker
+    from ladim.solver import Solver
 
 DEFAULT_MODULES = dict(
-    grid='ladim.gridforce.Grid',
-    forcing='ladim.gridforce.Forcing',
-    release='ladim.release.Releaser',
-    state='ladim.state.State',
-    output='ladim.output.Output',
+    grid='ladim.grid.RomsGrid',
+    forcing='ladim.forcing.RomsForcing',
+    release='ladim.release.TextFileReleaser',
+    state='ladim.state.DynamicState',
+    output='ladim.output.RaggedOutput',
     ibm='ladim.ibms.IBM',
-    tracker='ladim.tracker.Tracker',
-    timestepper='ladim.timestepper.TimeStepper',
+    tracker='ladim.tracker.HorizontalTracker',
+    solver='ladim.solver.Solver',
 )
 
 
@@ -24,49 +27,62 @@ class Model:
     def __init__(self, config):
         module_names = (
             'grid', 'forcing', 'release', 'state', 'output', 'ibm', 'tracker',
-            'timestepper',
+            'solver',
         )
 
         self.modules = dict()
         for name in module_names:
-            self.add_module(name, config[name])
+            self.add_module(name, config.get(name, dict()))
 
     def add_module(self, name, conf):
         module_name = conf.get('module', DEFAULT_MODULES[name])
-        Module = load_module(module_name)
-        self.modules[name] = Module(self, **conf)
+        conf_without_module = {
+            k: v for k, v in conf.items()
+            if k != 'module'
+        }
+
+        cls = load_class(module_name)
+        self.modules[name] = cls(self, **conf_without_module)
 
     @property
-    def grid(self) -> ladim.gridforce.Grid:
+    def grid(self) -> "Grid":
+        # noinspection PyTypeChecker
         return self.modules.get('grid', None)
 
     @property
-    def forcing(self) -> ladim.gridforce.Forcing:
+    def forcing(self) -> "Forcing":
+        # noinspection PyTypeChecker
         return self.modules.get('forcing', None)
 
     @property
-    def release(self) -> ladim.release.Releaser:
+    def release(self) -> "Releaser":
+        # noinspection PyTypeChecker
         return self.modules.get('release', None)
 
     @property
-    def state(self) -> ladim.state.State:
+    def state(self) -> "State":
+        # noinspection PyTypeChecker
         return self.modules.get('state', None)
 
     @property
-    def output(self) -> ladim.output.Output:
+    def output(self) -> "Output":
+        # noinspection PyTypeChecker
         return self.modules.get('output', None)
 
     @property
-    def ibm(self) -> ladim.ibms.IBM:
+    def ibm(self) -> "IBM":
+        # noinspection PyTypeChecker
         return self.modules.get('ibm', None)
 
     @property
-    def tracker(self) -> ladim.tracker.Tracker:
+    def tracker(self) -> "Tracker":
+        # noinspection PyTypeChecker
         return self.modules.get('tracker', None)
 
     @property
-    def timestepper(self) -> ladim.timestepper.TimeStepper:
-        return self.modules.get('timestepper', None)
+    def solver(self) -> "Solver":
+        # noinspection PyTypeChecker
+        return self.modules.get('solver', None)
 
     def __getitem__(self, item):
         return self.modules[item]
@@ -75,7 +91,7 @@ class Model:
         return item in self.modules
 
     def run(self):
-        self.timestepper.run()
+        self.solver.run()
 
     def close(self):
         for m in self.modules.values():
@@ -83,6 +99,25 @@ class Model:
                 m.close()
 
 
-def load_module(name):
+def load_class(name):
     pkg, cls = name.rsplit(sep='.', maxsplit=1)
     return getattr(importlib.import_module(pkg), cls)
+
+
+class Module:
+    def __init__(self, model: Model):
+        self._model = model
+
+    @property
+    def model(self) -> Model:
+        return self._model
+
+    @model.setter
+    def model(self, value: Model):
+        self._model = value
+
+    def update(self):
+        pass
+
+    def close(self):
+        pass