ladim 2.0.3__tar.gz → 2.0.5__tar.gz

{ladim-2.0.3 → ladim-2.0.5}/PKG-INFO

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

{ladim-2.0.3 → ladim-2.0.5}/ladim/__init__.py

@@ -1,3 +1,3 @@
-__version__ = '2.0.3'
+__version__ = '2.0.5'
 
 from .main import main, run

{ladim-2.0.3 → ladim-2.0.5}/ladim/__main__.py

@@ -1,2 +1,2 @@
 from . import run
-run()
+run()

{ladim-2.0.3 → ladim-2.0.5}/ladim/config.py

@@ -59,15 +59,21 @@ def dict_get_single(d, item):
 
 
 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_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')
+            dt_sec = int(np.timedelta64(dt_value, dt_unit).astype('timedelta64[s]').astype(int))
 
     out['version'] = 2
 
@@ -80,13 +86,17 @@ def convert_1_to_2(c):
 
     out['grid'] = {}
     out['grid']['file'] = dict_get(c, [
+        'gridforce.first_file',
         '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['grid']['subgrid'] = dict_get(c, 'gridforce.subgrid', None)
 
     out['forcing'] = {}
     out['forcing']['file'] = dict_get(c, ['gridforce.input_file', 'files.input_file'])
+    out['forcing']['first_file'] = dict_get(c, 'gridforce.first_file', "")
+    out['forcing']['last_file'] = dict_get(c, 'gridforce.last_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')
@@ -133,6 +143,8 @@ def convert_1_to_2(c):
     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', [])

{ladim-2.0.3 → ladim-2.0.5}/ladim/forcing.py

@@ -45,6 +45,8 @@ class RomsForcing(Forcing):
         legacy_conf = dict(
             gridforce=dict(
                 input_file=file,
+                first_file=conf.get('first_file', ""),
+                last_file=conf.get('last_file', ""),
             ),
             ibm_forcing=conf.get('ibm_forcing', []),
             start_time=conf.get('start_time', None),

{ladim-2.0.3 → ladim-2.0.5}/ladim/grid.py

@@ -22,18 +22,28 @@ class Grid(Module):
 
 
 class RomsGrid(Grid):
-    def __init__(self, model: Model, **conf):
+    def __init__(
+            self,
+            model: Model,
+            file: str,
+            start_time=None,
+            subgrid=None,
+            legacy_module='ladim.gridforce.ROMS.Grid',
+            **_,
+    ):
         super().__init__(model)
 
         legacy_conf = dict(
             gridforce=dict(
-                input_file=conf['file'],
+                input_file=file,
             ),
-            start_time=conf.get('start_time', None),
+            start_time=start_time,
         )
+        if subgrid is not None:
+            legacy_conf['gridforce']['subgrid'] = subgrid
 
         from .model import load_class
-        LegacyGrid = load_class(conf.get('legacy_module', 'ladim.gridforce.ROMS.Grid'))
+        LegacyGrid = load_class(legacy_module)
 
         # Allow gridforce module in current directory
         import sys

{ladim-2.0.3 → ladim-2.0.5}/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__)
@@ -107,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)
@@ -137,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
@@ -145,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
@@ -176,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):
@@ -205,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
@@ -324,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)
@@ -345,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
@@ -372,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
 
@@ -413,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]])
@@ -430,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"]:
@@ -446,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]:
@@ -579,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
@@ -595,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")
 
 
 # ------------------------
@@ -660,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
@@ -689,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-2.0.3 → ladim-2.0.5}/ladim/output.py

@@ -242,5 +242,4 @@ def create_netcdf_file(fname: str, formats: dict[str, OutputFormat], diskless=Fa
         dset.variables[varname].set_auto_mask(False)
         dset.variables[varname].setncatts(item.attributes)
 
-
     return dset

{ladim-2.0.3 → ladim-2.0.5}/ladim.egg-info/PKG-INFO

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

{ladim-2.0.3 → ladim-2.0.5}/tests/test_config.py

@@ -37,6 +37,8 @@ class Test_convert_1_to_2:
             'forcing': {
                 'dt': 60,
                 'file': '../forcing*.nc',
+                'first_file': '',
+                'last_file': '',
                 'ibm_forcing': [],
                 'legacy_module': 'ladim.gridforce.ROMS.Forcing',
                 'start_time': np.datetime64('2015-09-07T01:00:00'),
@@ -44,7 +46,9 @@ class Test_convert_1_to_2:
             'grid': {
                 'file': '../forcing*.nc',
                 'legacy_module': 'ladim.gridforce.ROMS.Grid',
-                'start_time': np.datetime64('2015-09-07T01:00:00')},
+                'start_time': np.datetime64('2015-09-07T01:00:00'),
+                'subgrid': None,
+            },
             'ibm': {},
             'output': {
                 'file': 'out.nc',