ladim 2.0.1__tar.gz → 2.0.3__tar.gz

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

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

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

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

ladim-2.0.3/ladim/config.py

@@ -0,0 +1,145 @@
+"""
+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 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 = {}
+
+    # 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')
+
+    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', [])
+
+    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:
+        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
+    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 dict_get(c, 'state.ibm_variables', []) + dict_get(c, 'ibm.variables', [])
+        if k not in out['release']['colnames']
+    }
+
+    out['ibm'] = {}
+    if 'ibm' in c:
+        out['ibm']['module'] = 'ladim.ibms.LegacyIBM'
+        out['ibm']['legacy_module'] = dict_get(c, ['ibm.ibm_module', 'ibm.module'])
+        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 out['output']['variables'].items()
+        }
+        out['ibm']['conf']['ibm'] = {k: v for k, v in c['ibm'].items() if k != 'ibm_module'}
+
+    return out

{ladim-2.0.1 → ladim-2.0.3}/ladim/gridforce/ROMS.py

@@ -15,10 +15,12 @@ import glob
 import logging
 import numpy as np
 from netCDF4 import Dataset, num2date
-
 from ladim.sample import sample2D, bilin_inv
 
 
+logger = logging.getLogger(__name__)
+
+
 class Grid:
     """Simple ROMS grid object
 
@@ -34,7 +36,7 @@ class Grid:
 
     def __init__(self, config):
 
-        logging.info("Initializing ROMS-type grid object")
+        logger.info("Initializing ROMS-type grid object")
 
         # Grid file
         if "grid_file" in config["gridforce"]:
@@ -44,14 +46,14 @@ class Grid:
             files.sort()
             grid_file = files[0]
         else:
-            logging.error("No grid file specified")
+            logger.error("No grid file specified")
             raise SystemExit(1)
 
         try:
             ncid = Dataset(grid_file)
             ncid.set_auto_mask(False)
         except OSError:
-            logging.error("Could not open grid file " + grid_file)
+            logger.error("Could not open grid file " + grid_file)
             raise SystemExit(1)
 
         # Subgrid, only considers internal grid cells
@@ -180,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"):
@@ -189,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:
@@ -204,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
@@ -242,7 +253,7 @@ class Forcing:
 
     def __init__(self, config, grid):
 
-        logging.info("Initiating forcing")
+        logger.info("Initiating forcing")
 
         self._grid = grid  # Get the grid object, make private?
         # self.config = config["gridforce"]
@@ -255,9 +266,9 @@ class Forcing:
         files = self.find_files(config["gridforce"])
         numfiles = len(files)
         if numfiles == 0:
-            logging.error("No input file: {}".format(config["gridforce"]["input_file"]))
+            logger.error("No input file: {}".format(config["gridforce"]["input_file"]))
             raise SystemExit(3)
-        logging.info("Number of forcing files = {}".format(numfiles))
+        logger.info("Number of forcing files = {}".format(numfiles))
 
         # ---------------------------
         # Overview of all the files
@@ -357,6 +368,7 @@ class Forcing:
         all_frames = []  # All time frames
         num_frames = {}  # Number of time frames in each file
         for fname in files:
+            logger.info(f'Open forcing file {fname}')
             with Dataset(fname) as nc:
                 new_times = nc.variables["ocean_time"][:]
                 num_frames[fname] = len(new_times)
@@ -370,11 +382,11 @@ class Forcing:
         if np.any(I):
             i = I.nonzero()[0][0] + 1   # Index of first out-of-order frame
             oooframe = str(all_frames[i]).split('.')[0]  # Remove microseconds
-            logging.info(f"Time frame {i} = {oooframe} out of order")
-            logging.critical("Forcing time frames not strictly sorted")
+            logger.info(f"Time frame {i} = {oooframe} out of order")
+            logger.critical("Forcing time frames not strictly sorted")
             raise SystemExit(4)
 
-        logging.info(f"Number of available forcing times = {len(all_frames)}")
+        logger.info(f"Number of available forcing times = {len(all_frames)}")
         return all_frames, num_frames
 
     @staticmethod
@@ -382,8 +394,8 @@ class Forcing:
 
         time0 = all_frames[0]
         time1 = all_frames[-1]
-        logging.info(f"First forcing time = {time0}")
-        logging.info(f"Last forcing time = {time1}")
+        logger.info(f"First forcing time = {time0}")
+        logger.info(f"Last forcing time = {time1}")
         start_time = np.datetime64(config["start_time"])
         dt = np.timedelta64(int(config["dt"]), "s")
 
@@ -391,10 +403,10 @@ class Forcing:
         # ------------------------------------------------------
 
         if time0 > start_time:
-            logging.error("No forcing at start time")
+            logger.error("No forcing at start time")
             raise SystemExit(3)
         if time1 < config["stop_time"]:
-            logging.error("No forcing at stop time")
+            logger.error("No forcing at stop time")
             raise SystemExit(3)
 
         # Make a list steps of the forcing time steps
@@ -427,7 +439,7 @@ class Forcing:
         interpolate_velocity_in_time = True
         interpolate_ibm_forcing_in_time = False
 
-        logging.debug("Updating forcing, time step = {}".format(t))
+        logger.debug("Updating forcing, time step = {}".format(t))
         if t in self.steps:  # No time interpolation
             self.U = self.Unew
             self.V = self.Vnew
@@ -486,7 +498,7 @@ class Forcing:
 
         # Handle file opening/closing
         # Always read velocity before other fields
-        logging.info("Reading velocity for time step = {}".format(n))
+        logger.info("Reading velocity for time step = {}".format(n))
 
         # If finished a file or first read (self._nc == "")
         if not self._nc:  # First read
@@ -799,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-2.0.1 → ladim-2.0.3}/ladim/gridforce/zROMS.py

@@ -18,6 +18,9 @@ from netCDF4 import Dataset, num2date
 from ladim.sample import sample2D
 
 
+logger = logging.getLogger(__name__)
+
+
 class Grid:
     """Simple ROMS grid object
 
@@ -33,13 +36,24 @@ class Grid:
 
     def __init__(self, config):
 
-        logging.info("Initializing zROMS grid object")
+        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:
-            logging.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
@@ -188,7 +202,7 @@ class Forcing:
 
     def __init__(self, config, grid):
 
-        logging.info("Initiating forcing")
+        logger.info("Initiating forcing")
 
         self._grid = grid  # Get the grid object, make private?
 
@@ -199,9 +213,9 @@ class Forcing:
         files.sort()
         numfiles = len(files)
         if numfiles == 0:
-            logging.error("No input file: {}".format(config["gridforce"]["input_file"]))
+            logger.error("No input file: {}".format(config["gridforce"]["input_file"]))
             raise SystemExit(3)
-        logging.info("Number of forcing files = {}".format(numfiles))
+        logger.info("Number of forcing files = {}".format(numfiles))
 
         # ----------------------------------------
         # Open first file for some general info
@@ -244,20 +258,20 @@ 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"][:]
                 times.extend(new_times)
                 num_frames.append(len(new_times))
-        logging.info("Number of available forcing times = {:d}".format(len(times)))
+        logger.info("Number of available forcing times = {:d}".format(len(times)))
 
         # Find first/last forcing times
         # -----------------------------
         time0 = num2date(times[0], time_units)
         time1 = num2date(times[-1], time_units)
-        logging.info("time0 = {}".format(str(time0)))
-        logging.info("time1 = {}".format(str(time1)))
+        logger.info("time0 = {}".format(str(time0)))
+        logger.info("time1 = {}".format(str(time1)))
         # print(time0)
         # print(time1)
         start_time = np.datetime64(config["start_time"])
@@ -269,10 +283,10 @@ class Forcing:
         # Use logging module for this
 
         if time0 > start_time:
-            logging.error("No forcing at start time")
+            logger.error("No forcing at start time")
             raise SystemExit(3)
         if time1 < config["stop_time"]:
-            logging.error("No forcing at stop time")
+            logger.error("No forcing at stop time")
             raise SystemExit(3)
 
         # Make a list steps of the forcing time steps
@@ -362,7 +376,7 @@ class Forcing:
         interpolate_velocity_in_time = True
         interpolate_ibm_forcing_in_time = False
 
-        logging.debug("Updating forcing, time step = {}".format(t))
+        logger.debug("Updating forcing, time step = {}".format(t))
         if t in self.steps:  # No time interpolation
             self.U = self.Unew
             self.V = self.Vnew
@@ -399,7 +413,7 @@ class Forcing:
 
         # Handle file opening/closing
         # Always read velocity before other fields
-        logging.debug("Reading velocity for time step = {}".format(n))
+        logger.debug("Reading velocity for time step = {}".format(n))
         first = True
         if first:  # Open file initiallt
             self._nc = Dataset(self._files[self.file_idx[n]])

{ladim-2.0.1 → ladim-2.0.3}/ladim/main.py

@@ -12,13 +12,14 @@ Lagrangian Advection and Diffusion Model
 # ---------------------------------
 
 import logging
-
 import ladim
-
 from .config import configure
 from .model import Model
 
 
+logger = logging.getLogger(__name__)
+
+
 def main(config_stream, loglevel=logging.INFO):
     """Main function for LADiM"""
 
@@ -46,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
@@ -67,23 +70,23 @@ def run():
 
     args = parser.parse_args()
 
-    logging.info(" ================================================")
-    logging.info(" === Lagrangian Advection and Diffusion Model ===")
-    logging.info(" ================================================\n")
+    logger.info(" ================================================")
+    logger.info(" === Lagrangian Advection and Diffusion Model ===")
+    logger.info(" ================================================\n")
 
-    logging.info(f"ladim path: {ladim.__file__.strip('__init.py__')}")
-    logging.info(f"ladim version:  {ladim.__version__}\n")
-    logging.info(f"python version:  {sys.version.split()[0]}\n")
+    logger.info(f"ladim path: {ladim.__file__.strip('__init.py__')}")
+    logger.info(f"ladim version:  {ladim.__version__}\n")
+    logger.info(f"python version:  {sys.version.split()[0]}\n")
 
-    logging.info(f"  Configuration file: {args.config_file}")
-    logging.info(f"  loglevel = {logging.getLevelName(args.loglevel)}")
+    logger.info(f"  Configuration file: {args.config_file}")
+    logger.info(f"  loglevel = {logging.getLevelName(args.loglevel)}")
 
     # =============
     # Sanity check
     # =============
 
     if not Path(args.config_file).exists():
-        logging.critical(f'Configuration file {args.config_file} not found')
+        logger.critical(f'Configuration file {args.config_file} not found')
         raise SystemExit(1)
 
     # ===================
@@ -92,7 +95,7 @@ def run():
 
     # Start message
     now = datetime.datetime.now().replace(microsecond=0)
-    logging.info(f'LADiM simulation starting, wall time={now}')
+    logger.info(f'LADiM simulation starting, wall time={now}')
 
     fp = open(args.config_file, encoding='utf8')
     ladim.main(config_stream=fp, loglevel=args.loglevel)
@@ -100,4 +103,4 @@ def run():
     # Reset logging and print final message
     logging.getLogger().setLevel(logging.INFO)
     now = datetime.datetime.now().replace(microsecond=0)
-    logging.info(f'LADiM simulation finished, wall time={now}')
+    logger.info(f'LADiM simulation finished, wall time={now}')

{ladim-2.0.1 → ladim-2.0.3}/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.1 → ladim-2.0.3}/ladim/state.py

@@ -122,6 +122,14 @@ class DynamicState(State):
             raise AttributeError(f'Attribute not defined: {item}')
         return self[item]
 
+    def __setattr__(self, item, value):
+        if item in list(self.__dict__.keys()) + ['_data', '_model', '_num_released', '_varnames']:
+            super().__setattr__(item, value)
+        elif item in self._data:
+            self._data[item] = value
+        else:
+            raise AttributeError(f"Attribute not defined: '{item}'")
+
     def __contains__(self, item):
         return item in self._data
 

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

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

{ladim-2.0.1 → ladim-2.0.3}/ladim.egg-info/SOURCES.txt

@@ -34,7 +34,10 @@ postladim/cellcount.py
 postladim/kde_plot.py
 postladim/particlefile.py
 postladim/variable.py
+tests/test_config.py
+tests/test_forcing.py
 tests/test_ladim.py
+tests/test_model.py
 tests/test_output.py
 tests/test_release.py
 tests/test_solver.py

ladim-2.0.3/tests/test_config.py

@@ -0,0 +1,88 @@
+from ladim import config
+from pathlib import Path
+import yaml
+import numpy as np
+import datetime
+
+
+class Test_dict_get:
+    def test_returns_correct_when_existing(self):
+        mydict = dict(a=1, b=dict(c=2, d=3))
+        assert config.dict_get(mydict, 'a') == 1
+        assert config.dict_get(mydict, 'b') == dict(c=2, d=3)
+        assert config.dict_get(mydict, 'b.c') == 2
+        assert config.dict_get(mydict, 'b.d') == 3
+
+    def test_returns_default_when_nonexisting(self):
+        mydict = dict(a=1, b=dict(c=2, d=3))
+        assert config.dict_get(mydict, 'A', 23) == 23
+        assert config.dict_get(mydict, 'b.C') is None
+
+    def test_can_try_alternatives(self):
+        mydict = dict(a=1, b=dict(c=2, d=3))
+        assert config.dict_get(mydict, ['A', 'a'], 23) == 1
+        assert config.dict_get(mydict, ['b.C', 'b.c']) == 2
+        assert config.dict_get(mydict, ['b.C', 'b.D']) is None
+
+
+class Test_convert_1_to_2:
+    def test_matches_snapshot(self):
+        fname_in = Path(__file__).parent / 'sample_data/ex1/ladim.yaml'
+        with open(fname_in, encoding='utf-8') as fp:
+            dict_in = yaml.safe_load(fp)
+
+        dict_out = config.convert_1_to_2(dict_in)
+
+        assert dict_out == {
+            'forcing': {
+                'dt': 60,
+                'file': '../forcing*.nc',
+                'ibm_forcing': [],
+                'legacy_module': 'ladim.gridforce.ROMS.Forcing',
+                'start_time': np.datetime64('2015-09-07T01:00:00'),
+                'stop_time': np.datetime64('2015-09-07T01:05:00')},
+            'grid': {
+                'file': '../forcing*.nc',
+                'legacy_module': 'ladim.gridforce.ROMS.Grid',
+                'start_time': np.datetime64('2015-09-07T01:00:00')},
+            'ibm': {},
+            'output': {
+                'file': 'out.nc',
+                'frequency': [60, 's'],
+                'variables': {
+                    'X': {
+                        'long_name': 'particle X-coordinate', 'ncformat': 'f4'},
+                    'Y': {
+                        'long_name': 'particle Y-coordinate', 'ncformat': 'f4'},
+                    'Z': {
+                        'long_name': 'particle depth',
+                        'ncformat': 'f4',
+                        'positive': 'down',
+                        'standard_name': 'depth_below_surface',
+                        'units': 'm'},
+                    'pid': {
+                        'long_name': 'particle identifier', 'ncformat': 'i4'},
+                    'release_time': {
+                        'kind': 'initial',
+                        'long_name': 'particle release time',
+                        'ncformat': 'i4',
+                        'units': 'seconds since '
+                        '1970-01-01'}}},
+            'release': {
+                'colnames': ['release_time', 'X', 'Y', 'Z', 'group_id'],
+                'defaults': {},
+                'file': 'particles.rls',
+                'formats': {'time': 'release_time'},
+                'frequency': [1, 'm']},
+            'solver': {
+                'order': ['release', 'forcing', 'output', 'tracker', 'ibm', 'state'],
+                'seed': 0,
+                'start': datetime.datetime(2015, 9, 7, 1, 0),
+                'step': 60,
+                'stop': datetime.datetime(2015, 9, 7, 1, 5)},
+            'tracker': {'diffusion': 0.1, 'method': 'RK4'},
+            'version': 2
+        }
+
+    def test_accepts_empty_dict(self):
+        config.convert_1_to_2(dict())

ladim-2.0.3/tests/test_forcing.py

@@ -0,0 +1,10 @@
+from ladim.gridforce import ROMS
+import numpy as np
+
+
+class Test_z2s:
+    def test_returns_interpolated_s_level(self):
+        zrho = np.array([-5, -4, -3, -2]).reshape((4, 1, 1))
+        k, a = ROMS.z2s(zrho, np.zeros(5), np.zeros(5), np.array([6, 5, 3.5, 2, 0]))
+        assert k.tolist() == [1, 1, 2, 3, 3]
+        assert a.tolist() == [1.0, 1.0, 0.5, 0.0, 0.0]

ladim-2.0.3/tests/test_model.py

@@ -0,0 +1,33 @@
+
+from ladim import model
+import pytest
+import os
+
+
+@pytest.fixture()
+def tmp_path_with_chdir(tmp_path):
+    original_dir = os.getcwd()
+    os.chdir(tmp_path)
+    yield tmp_path
+    os.chdir(original_dir)
+
+
+class Test_load_class:
+    def test_can_load_fully_qualified_class(self):
+        numpy_dtype_class = model.load_class('numpy.dtype')
+        numpy_dtype_i4 = numpy_dtype_class('i4')
+        assert numpy_dtype_i4.itemsize == 4
+
+    def test_can_load_class_in_current_directory(self, tmp_path_with_chdir):
+        # Set up a python file in the temp dir which contains a class
+        module_path = tmp_path_with_chdir / 'my_module.py'
+        module_path.write_text(
+            'class MyClass:\n'
+            '  def timestwo(self, a):\n'
+            '    return a * 2\n'
+        )
+
+        # Run and test code
+        MyClass = model.load_class('my_module.MyClass')
+        obj = MyClass()
+        assert obj.timestwo(4) == 8

ladim-2.0.1/ladim/config.py

@@ -1,125 +0,0 @@
-"""
-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