ladim 2.0.2__py3-none-any.whl → 2.0.4__py3-none-any.whl

ladim/__init__.py

@@ -1,3 +1,3 @@
-__version__ = '2.0.2'
+__version__ = '2.0.4'
 
 from .main import main, run

ladim/config.py

@@ -28,98 +28,126 @@ def configure(module_conf):
 
 def _versioned_configure(config_dict):
     if config_dict['version'] == 1:
-        config_dict = _convert_1_to_2(config_dict)
+        config_dict = convert_1_to_2(config_dict)
 
     return config_dict
 
 
-def _convert_1_to_2(c):
+def dict_get(d, items, default=None):
+    if isinstance(items, str):
+        items = [items]
+
+    for item in items:
+        try:
+            return dict_get_single(d, item)
+        except KeyError:
+            pass
+
+    return default
+
+
+def dict_get_single(d, item):
+    tokens = str(item).split(sep='.')
+    sub_dict = d
+    for t in tokens:
+        if t in sub_dict:
+            sub_dict = sub_dict[t]
+        else:
+            raise KeyError
+
+    return sub_dict
+
+
+def convert_1_to_2(c):
+    out = {}
+
+    # If any of the top-level attribute values in `c` are None, they should be
+    # converted to empty dicts
+    top_level_nones = [k for k in c if c[k] is None]
+    c = c.copy()
+    for k in top_level_nones:
+        c[k] = dict()
+
     # Read timedelta
-    dt_value, dt_unit = c['numerics']['dt']
-    dt_sec = np.timedelta64(dt_value, dt_unit).astype('timedelta64[s]').astype('int64')
+    dt_sec = None
+    if 'numerics' in c:
+        if 'dt' in c['numerics']:
+            dt_value, dt_unit = c['numerics']['dt']
+            dt_sec = np.timedelta64(dt_value, dt_unit).astype('timedelta64[s]').astype('int64')
+
+    out['version'] = 2
+
+    out['solver'] = {}
+    out['solver']['start'] = dict_get(c, 'time_control.start_time')
+    out['solver']['stop'] = dict_get(c, 'time_control.stop_time')
+    out['solver']['step'] = dt_sec
+    out['solver']['seed'] = dict_get(c, 'numerics.seed')
+    out['solver']['order'] = ['release', 'forcing', 'output', 'tracker', 'ibm', 'state']
+
+    out['grid'] = {}
+    out['grid']['file'] = dict_get(c, [
+        'files.grid_file', 'gridforce.grid_file',
+        'files.input_file', 'gridforce.input_file'])
+    out['grid']['legacy_module'] = dict_get(c, 'gridforce.module', '') + '.Grid'
+    out['grid']['start_time'] = np.datetime64(dict_get(c, 'time_control.start_time', '1970'), 's')
+
+    out['forcing'] = {}
+    out['forcing']['file'] = dict_get(c, ['gridforce.input_file', 'files.input_file'])
+    out['forcing']['legacy_module'] = dict_get(c, 'gridforce.module', '') + '.Forcing'
+    out['forcing']['start_time'] = np.datetime64(dict_get(c, 'time_control.start_time', '1970'), 's')
+    out['forcing']['stop_time'] = np.datetime64(dict_get(c, 'time_control.stop_time', '1970'), 's')
+    out['forcing']['dt'] = dt_sec
+    out['forcing']['ibm_forcing'] = dict_get(c, 'gridforce.ibm_forcing', [])
 
-    # Read output variables
-    outvars = dict()
-    outvar_names = c['output_variables'].get('particle', []) + c['output_variables'].get('instance', [])
+    out['output'] = {}
+    out['output']['file'] = dict_get(c, 'files.output_file')
+    out['output']['frequency'] = dict_get(c, 'output_variables.outper')
+    out['output']['variables'] = {}
+
+    # Convert output variable format spec
+    outvar_names = dict_get(c, 'output_variables.particle', []).copy()
+    outvar_names += dict_get(c, 'output_variables.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'
+        out['output']['variables'][v] = c['output_variables'][v].copy()
+        if v == 'release_time' and 'units' in c['output_variables'][v]:
+            out['output']['variables'][v]['units'] = 'seconds since 1970-01-01'
+    for v in dict_get(c, 'output_variables.particle', []):
+        out['output']['variables'][v]['kind'] = 'initial'
+
+    out['tracker'] = {}
+    out['tracker']['method'] = dict_get(c, 'numerics.advection')
+    out['tracker']['diffusion'] = dict_get(c, 'numerics.diffusion')
 
     # 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'] = {
+    out['release'] = {}
+    out['release']['file'] = dict_get(c, 'files.particle_release_file')
+    out['release']['colnames'] = dict_get(c, 'particle_release.variables', [])
+    if dict_get(c, 'particle_release.release_type', '') == 'continuous':
+        out['release']['frequency'] = dict_get(c, 'particle_release.release_frequency', [0, 's'])
+    out['release']['formats'] = {
+        c.get('particle_release', {})[v]: v
+        for v in dict_get(c, 'particle_release.variables', [])
+        if v in c.get('particle_release', {}).keys()
+    }
+    out['release']['defaults'] = {
         k: np.float64(0)
-        for k in ibmvars
-        if k not in relconf['colnames']
+        for k in dict_get(c, 'state.ibm_variables', []) + dict_get(c, 'ibm.variables', [])
+        if k not in out['release']['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'] = {
+    out['ibm'] = {}
+    if 'ibm' in c:
+        out['ibm']['module'] = 'ladim.ibms.LegacyIBM'
+        out['ibm']['legacy_module'] = dict_get(c, ['ibm.ibm_module', 'ibm.module'])
+        if out['ibm']['legacy_module'] == 'ladim.ibms.ibm_salmon_lice':
+            out['ibm']['legacy_module'] = 'ladim_plugins.salmon_lice'
+        out['ibm']['conf'] = {}
+        out['ibm']['conf']['dt'] = dt_sec
+        out['ibm']['conf']['output_instance'] = dict_get(c, 'output_variables.instance', [])
+        out['ibm']['conf']['nc_attributes'] = {
             k: v
-            for k, v in ibmconf_legacy.items()
-            if k != 'ibm_module'
+            for k, v in out['output']['variables'].items()
         }
+        out['ibm']['conf']['ibm'] = {k: v for k, v in c['ibm'].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
+    return out

ladim/gridforce/ROMS.py

@@ -182,6 +182,8 @@ class Grid:
         """Return the depth of grid cells"""
         I = X.round().astype(int) - self.i0
         J = Y.round().astype(int) - self.j0
+        I = np.minimum(np.maximum(I, 0), self.H.shape[1] - 1)
+        J = np.minimum(np.maximum(J, 0), self.H.shape[0] - 1)
         return self.H[J, I]
 
     def lonlat(self, X, Y, method="bilinear"):
@@ -191,6 +193,8 @@ class Grid:
         # else: containing grid cell, less accurate
         I = X.round().astype("int") - self.i0
         J = Y.round().astype("int") - self.j0
+        I = np.minimum(np.maximum(I, 0), self.lon.shape[1] - 1)
+        J = np.minimum(np.maximum(J, 0), self.lon.shape[0] - 1)
         return self.lon[J, I], self.lat[J, I]
 
     def ingrid(self, X: np.ndarray, Y: np.ndarray) -> np.ndarray:
@@ -206,6 +210,11 @@ class Grid:
         """Returns True for points on land"""
         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] < 1
 
     # Error if point outside
@@ -802,6 +811,11 @@ def sample3D(F, X, Y, K, A, method="bilinear"):
     # else:  method == 'nearest'
     I = X.round().astype("int")
     J = Y.round().astype("int")
+
+    # Constrain to valid indices
+    I = np.minimum(np.maximum(I, 0), F.shape[-1] - 1)
+    J = np.minimum(np.maximum(J, 0), F.shape[-2] - 1)
+
     return F[K, J, I]
 
 

ladim/gridforce/zROMS.py

@@ -15,7 +15,7 @@ import glob
 import logging
 import numpy as np
 from netCDF4 import Dataset, num2date
-from ladim.sample import sample2D
+from ladim.sample import sample2D, bilin_inv
 
 
 logger = logging.getLogger(__name__)
@@ -37,12 +37,23 @@ class Grid:
     def __init__(self, config):
 
         logger.info("Initializing zROMS grid object")
+
+        # Grid file
+        if "grid_file" in config["gridforce"]:
+            grid_file = config["gridforce"]["grid_file"]
+        elif "input_file" in config["gridforce"]:
+            files = glob.glob(config["gridforce"]["input_file"])
+            files.sort()
+            grid_file = files[0]
+        else:
+            logger.error("No grid file specified")
+            raise SystemExit(1)
+
         try:
-            ncid = Dataset(config["gridforce"]["grid_file"])
+            ncid = Dataset(grid_file)
+            ncid.set_auto_mask(False)
         except OSError:
-            logger.error(
-                "Grid file {} not found".format(config["gridforce"]["grid_file"])
-            )
+            logger.error("Could not open grid file " + grid_file)
             raise SystemExit(1)
 
         # Subgrid, only considers internal grid cells
@@ -96,11 +107,6 @@ class Grid:
         self.lon = ncid.variables["lon_rho"][self.J, self.I]
         self.lat = ncid.variables["lat_rho"][self.J, self.I]
 
-        # self.z_r = sdepth(self.H, self.hc, self.Cs_r,
-        #                  stagger='rho', Vtransform=self.Vtransform)
-        # self.z_w = sdepth(self.H, self.hc, self.Cs_w,
-        #                  stagger='w', Vtransform=self.Vtransform)
-
         # Land masks at u- and v-points
         M = self.M
         Mu = np.zeros((self.jmax, self.imax + 1), dtype=int)
@@ -126,6 +132,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
@@ -134,30 +144,39 @@ class Grid:
         """Return the depth of grid cells"""
         I = X.round().astype(int) - self.i0
         J = Y.round().astype(int) - self.j0
+        I = np.minimum(np.maximum(I, 0), self.H.shape[1] - 1)
+        J = np.minimum(np.maximum(J, 0), self.H.shape[0] - 1)
         return self.H[J, I]
 
     def lonlat(self, X, Y, method="bilinear"):
         """Return the longitude and latitude from grid coordinates"""
         if method == "bilinear":  # More accurate
             return self.xy2ll(X, Y)
-        else:  # containing grid cell, less accurate
-            I = X.round().astype("int") - self.i0
-            J = Y.round().astype("int") - self.j0
-            return self.lon[J, I], self.lat[J, I]
-
+        # else: containing grid cell, less accurate
+        I = X.round().astype("int") - self.i0
+        J = Y.round().astype("int") - self.j0
+        I = np.minimum(np.maximum(I, 0), self.lon.shape[1] - 1)
+        J = np.minimum(np.maximum(J, 0), self.lon.shape[0] - 1)
+        return self.lon[J, I], self.lat[J, I]
+
+    def ingrid(self, X: np.ndarray, Y: np.ndarray) -> np.ndarray:
+        """Returns True for points inside the subgrid"""
         return (
-            sample2D(self.lon, X - self.i0, Y - self.j0),
-            sample2D(self.lat, X - self.i0, Y - self.j0),
+            (self.xmin + 0.5 < X)
+            & (X < self.xmax - 0.5)
+            & (self.ymin + 0.5 < Y)
+            & (Y < self.ymax - 0.5)
         )
 
-    def ingrid(self, X, Y):
-        """Returns True for points inside the subgrid"""
-        return (self.xmin < X) & (X < self.xmax) & (self.ymin < Y) & (Y < self.ymax)
-
     def onland(self, X, Y):
         """Returns True for points on land"""
         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] < 1
 
     # Error if point outside
@@ -165,6 +184,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):
@@ -194,7 +218,7 @@ class Forcing:
         logger.info("Initiating forcing")
 
         self._grid = grid  # Get the grid object, make private?
-
+        # self.config = config["gridforce"]
         self.ibm_forcing = config["ibm_forcing"]
 
         # Test for glob, use MFDataset if needed
@@ -247,7 +271,7 @@ class Forcing:
         num_frames = []  # Available time frames in each file
         # change_times = []     # Times for change of file
         for fname in files:
-            print(fname)
+            logging.info(f'Load {fname}')
             with Dataset(fname) as nc:
                 # new_times = nc.variables['ocean_time'][:]
                 new_times = nc.variables["time"][:]
@@ -313,6 +337,7 @@ class Forcing:
         # --------------
         # prestep = last forcing step < 0
         #
+
         V = [step for step in steps if step < 0]
         if V:  # Forcing available before start time
             prestep = max(V)
@@ -334,11 +359,12 @@ class Forcing:
 
         elif steps[0] == 0:
             # Simulation start at first forcing time
+            # Runge-Kutta needs dU and dV in this case as well
             self.U, self.V = self._read_velocity(0)
             self.Unew, self.Vnew = self._read_velocity(steps[1])
             self.dU = (self.Unew - self.U) / steps[1]
             self.dV = (self.Vnew - self.V) / steps[1]
-            # Syncronize
+            # Synchronize with start time
             self.Unew = self.U
             self.Vnew = self.V
             # Extrapolate to time step = -1
@@ -361,7 +387,7 @@ class Forcing:
     def update(self, t):
         """Update the fields to time step t"""
 
-        # Read from config
+        # Read from config?
         interpolate_velocity_in_time = True
         interpolate_ibm_forcing_in_time = False
 
@@ -402,7 +428,7 @@ class Forcing:
 
         # Handle file opening/closing
         # Always read velocity before other fields
-        logger.debug("Reading velocity for time step = {}".format(n))
+        logger.info("Reading velocity for time step = {}".format(n))
         first = True
         if first:  # Open file initiallt
             self._nc = Dataset(self._files[self.file_idx[n]])
@@ -419,6 +445,7 @@ class Forcing:
         # Read the velocity
         U = self._nc.variables["u"][frame, :, self._grid.Ju, self._grid.Iu]
         V = self._nc.variables["v"][frame, :, self._grid.Jv, self._grid.Iv]
+
         # Scale if needed
         # Assume offset = 0 for velocity
         if self.scaled["U"]:
@@ -435,7 +462,6 @@ class Forcing:
 
     def _read_field(self, name, n):
         """Read a 3D field"""
-        # print("IBM-forcing:", name)
         frame = self.frame_idx[n]
         F = self._nc.variables[name][frame, :, self._grid.J, self._grid.I]
         if self.scaled[name]:
@@ -568,7 +594,7 @@ def sdepth(H, Hc, C, stagger="rho", Vtransform=1):
     """
     H = np.asarray(H)
     Hshape = H.shape  # Save the shape of H
-    H = H.ravel()  # and make H 1D for easy shape manipulation
+    H = H.ravel()  # and make H 1D for easy shape maniplation
     C = np.asarray(C)
     N = len(C)
     outshape = (N,) + Hshape  # Shape of output
@@ -584,13 +610,13 @@ def sdepth(H, Hc, C, stagger="rho", Vtransform=1):
         B = np.outer(C, H)
         return (A + B).reshape(outshape)
 
-    elif Vtransform == 2:  # New transform by Shchepetkin
+    if Vtransform == 2:  # New transform by Shchepetkin
         N = Hc * S[:, None] + np.outer(C, H)
         D = 1.0 + Hc / H
         return (N / D).reshape(outshape)
 
-    else:
-        raise ValueError("Unknown Vtransform")
+    # else:
+    raise ValueError("Unknown Vtransform")
 
 
 # ------------------------
@@ -649,13 +675,15 @@ def sample3D(F, X, Y, K, A, method="bilinear"):
 
     """
 
-    # print('sample3D: method =', method)
-
-    # sjekk om 1-A eller A
     if 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) * A
@@ -678,10 +706,15 @@ def sample3D(F, X, Y, K, A, method="bilinear"):
             + W111 * F[K - 1, J + 1, I + 1]
         )
 
-    else:  # method == 'nearest'
-        I = X.round().astype("int")
-        J = Y.round().astype("int")
-        return F[K, J, I]
+    # else:  method == 'nearest'
+    I = X.round().astype("int")
+    J = Y.round().astype("int")
+
+    # Constrain to valid indices
+    I = np.minimum(np.maximum(I, 0), F.shape[-1] - 1)
+    J = np.minimum(np.maximum(J, 0), F.shape[-2] - 1)
+
+    return F[K, J, I]
 
 
 def sample3DUV(U, V, X, Y, K, A, method="bilinear"):

ladim/main.py

@@ -47,7 +47,9 @@ def run():
 
     logging.basicConfig(
         level=logging.INFO,
-        format='%(levelname)s:%(module)s - %(message)s')
+        format='%(asctime)s  %(levelname)s:%(module)s - %(message)s',
+        datefmt='%Y-%m-%d %H:%M:%S',
+    )
 
     # ====================
     # Parse command line

ladim/model.py

@@ -1,4 +1,7 @@
 import importlib
+import importlib.util
+import sys
+from pathlib import Path
 
 from typing import TYPE_CHECKING
 if TYPE_CHECKING:
@@ -101,7 +104,26 @@ class Model:
 
 def load_class(name):
     pkg, cls = name.rsplit(sep='.', maxsplit=1)
-    return getattr(importlib.import_module(pkg), cls)
+
+    # Check if "pkg" is an existing file
+    spec = None
+    module_name = None
+    file_name = pkg + '.py'
+    if Path(file_name).exists():
+        # This can return None if there were import errors
+        module_name = pkg
+        spec = importlib.util.spec_from_file_location(module_name, file_name)
+
+    # If pkg can not be interpreted as a file, use regular import
+    if spec is None:
+        return getattr(importlib.import_module(pkg), cls)
+
+    # File import
+    else:
+        module = importlib.util.module_from_spec(spec)
+        sys.modules[module_name] = module
+        spec.loader.exec_module(module)
+        return getattr(module, cls)
 
 
 class Module:

{ladim-2.0.2.dist-info → ladim-2.0.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ladim
-Version: 2.0.2
+Version: 2.0.4
 Summary: Lagrangian Advection and Diffusion Model
 Home-page: https://github.com/pnsaevik/ladim
 Author: Bjørn Ådlandsvik

{ladim-2.0.2.dist-info → ladim-2.0.4.dist-info}/RECORD

@@ -1,10 +1,10 @@
-ladim/__init__.py,sha256=0i7KXjW3S0HuMuJqk69XKrsqQE9QUVTrXRDo6jNiFEM,51
+ladim/__init__.py,sha256=1pOaNTt2-oJQ33nsnZyDsOulYErImxLErxjlfOb8Oyg,51
 ladim/__main__.py,sha256=8f07EMfxQllDZSgpak5ECyYHnfQFy8LaHl2xdC-aO9c,23
-ladim/config.py,sha256=6b0ikBrBnq_sSElgO2YcVtJHjQU0nyZsVyPV3q9fy5I,4233
+ladim/config.py,sha256=tnTyKDeaDG1M9T5fiUGXG8Ezc_n7Xwm8l6--UpBJhaE,5449
 ladim/forcing.py,sha256=f4PpSwyilSScXeNyorTWLMgVTiat9htSLkCwAkRlJVM,3048
 ladim/grid.py,sha256=m6bQrGJ3cux7rqC8pbRXD86cOI-VQKF-XjP9m1jCIcY,2221
-ladim/main.py,sha256=EwBkmWwQG7I0_i-xjthSTeGsoALHH-MdQ1Vvf64lv_A,2838
-ladim/model.py,sha256=jpjq_ZSh7ULpwi3_RqDb-p5SG8WcdgCPaBkSpnNWblU,3137
+ladim/main.py,sha256=6_blu3PYnDXaYdPxfZoukWsjN0o9vh7O8_-W2-aguAI,2894
+ladim/model.py,sha256=iXClvieChhipCSZ-dDrmnjqwS4cuM53VpJv7oaJyQ88,3794
 ladim/output.py,sha256=Rz7iujvS7Z3LoABiJduQqyb3zPswNqhhFsywr3MLsBY,8373
 ladim/release.py,sha256=1j__9Gj0BD0CqVCM2KLZhio1Ia-hz1gbUIhTsa0J3Rg,8451
 ladim/sample.py,sha256=n8wRGd_VsW_qyQe1ZoTpmfZcdcwB929vsM8PoKG6JTs,8292
@@ -12,10 +12,10 @@ ladim/solver.py,sha256=sZvYgOxzJ-EItI-IB2y8_z8Tf-SJAQSrmydlhDRa7ZQ,755
 ladim/state.py,sha256=4XNIIx5sGjlqkZ6bg-dGbqzp8ujFNkHHFL2D9qCQA2w,4119
 ladim/tracker.py,sha256=VVX6T5CqiU6nGSCgLlSCC8w0UYhW273OGFE7ApPjdyI,5091
 ladim/utilities.py,sha256=r7-zShqJhh0cBctDUmtfw-GBOk1eTTYR4S72b0ouiSQ,994
-ladim/gridforce/ROMS.py,sha256=6y8ZIkAQgVPgK-zG53SKxFms4lJdkTCaP1doz7zuSyo,26965
+ladim/gridforce/ROMS.py,sha256=DF5CSR2iJsPWAmTOrqYavARVtqokQbtAWLSCDWb_9f0,27525
 ladim/gridforce/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ladim/gridforce/analytical.py,sha256=qI-1LJdjmnwwanzOdrsDZqwGgo73bT75CB7pMaxbHKM,1094
-ladim/gridforce/zROMS.py,sha256=t88mow91orUP-kMQiqmQ0_SnJKKG9xfycM5MMmdVljI,22853
+ladim/gridforce/zROMS.py,sha256=4bnrmcXiWpCAUch9uqd_0XmyKRh-Ll6sFvIHiTbTOOg,23996
 ladim/ibms/__init__.py,sha256=GOG75jZDmNEiLr8brxrKqIlqVj-pNR7pnPP8FUKE6hU,565
 ladim/ibms/light.py,sha256=POltHmKkX8-q3t9wXyfcseCKEq9Bq-kX1WEJYsr1lNQ,2737
 ladim/plugins/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -24,9 +24,9 @@ postladim/cellcount.py,sha256=nCFu9iJmprubn4YmPB4W0VO02GfEb90Iif7D49w1Kss,2054
 postladim/kde_plot.py,sha256=GvMWzT6VxIeXKh1cnqaGzR-4jGG_WIHGMLPpRMXIpo4,1628
 postladim/particlefile.py,sha256=0aif9wYUJ-VrpQKeCef8wB5VCiBB-gWY6sxNCUYviTA,4889
 postladim/variable.py,sha256=-2aihoppYMMmpSpCqaF31XvpinTMaH3Y01-USDIkbBc,6587
-ladim-2.0.2.dist-info/LICENSE,sha256=BgtXyjNr6Ly9nQ7ZLXKpV3r5kWRLnh5MiN0dxp0Bvfc,1085
-ladim-2.0.2.dist-info/METADATA,sha256=sjw274vLpD7oaf1g96Ik4VEI0c2grbLVml7nVXTVfoU,1841
-ladim-2.0.2.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-ladim-2.0.2.dist-info/entry_points.txt,sha256=JDlNJo87GJaOkH0-BpAzTPLCrZcuPSdSlHNQ4XmnoRg,41
-ladim-2.0.2.dist-info/top_level.txt,sha256=TK8Gl7d6MsrAQvqKG4b6YJCbB4UL46Se3SzsI-sJAuc,16
-ladim-2.0.2.dist-info/RECORD,,
+ladim-2.0.4.dist-info/LICENSE,sha256=BgtXyjNr6Ly9nQ7ZLXKpV3r5kWRLnh5MiN0dxp0Bvfc,1085
+ladim-2.0.4.dist-info/METADATA,sha256=9zVlHY1N0c5JKYGu9_ayPTmBVcPnzHaj9i8kJgLRgOU,1841
+ladim-2.0.4.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+ladim-2.0.4.dist-info/entry_points.txt,sha256=JDlNJo87GJaOkH0-BpAzTPLCrZcuPSdSlHNQ4XmnoRg,41
+ladim-2.0.4.dist-info/top_level.txt,sha256=TK8Gl7d6MsrAQvqKG4b6YJCbB4UL46Se3SzsI-sJAuc,16
+ladim-2.0.4.dist-info/RECORD,,