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

ladim/tracker.py

@@ -0,0 +1,165 @@
+from .model import Model, Module
+import numpy as np
+
+
+class Tracker(Module):
+    def __init__(self, model: Model):
+        super().__init__(model)
+
+
+class HorizontalTracker:
+    """The physical particle tracking kernel"""
+
+    def __init__(self, model: Model, method, diffusion) -> None:
+        self.model = model
+
+        if not diffusion:
+            method += "_nodiff"
+        self.integrator = StochasticDifferentialEquationIntegrator.from_keyword(method)
+        self.D = diffusion  # [m2.s-1]
+
+    def update(self):
+        state = self.model.state
+        grid = self.model.grid
+        forcing = self.model.forcing
+
+        t0 = self.model.solver.time
+        dt = self.model.solver.step
+
+        act = state['active']
+        X, Y, Z = state['X'][act], state['Y'][act], state['Z'][act]
+        dx, dy = grid.sample_metric(X, Y)
+        r0 = np.stack([X, Y])
+
+        # Set diffusion function
+        def mixing(t, r):
+            _ = t
+            stddev = (2 * self.D) ** 0.5
+            u_diff = stddev / dx
+            return np.broadcast_to(u_diff, r.shape)
+
+        # Set advection function
+        def velocity(t, r):
+            x, y = r.reshape([2, -1])
+            u, v = forcing.velocity(x, y, Z, tstep=(t - t0) / dt)
+            return np.concatenate([u / dx, v / dy]).reshape(r.shape)
+
+        X1, Y1 = self.integrator(velocity, mixing, t0, r0, dt)
+
+        # Land, boundary treatment. Do not move the particles
+        # Consider a sequence of different actions
+        # I = (grid.ingrid(X1, Y1)) & (grid.atsea(X1, Y1))
+        should_move = grid.atsea(X1, Y1)
+        # I = True
+        X[should_move] = X1[should_move]
+        Y[should_move] = Y1[should_move]
+
+        state['X'][act] = X
+        state['Y'][act] = Y
+
+
+class StochasticDifferentialEquationIntegrator:
+    @staticmethod
+    def from_keyword(kw):
+        integrators = {
+            "RK4": RK4Integrator,
+            "EF": EFIntegrator,
+            "RK4_nodiff": RK4NodiffIntegrator,
+            "EF_nodiff": EFNodiffIntegrator,
+        }
+        if kw not in integrators:
+            raise NotImplementedError(f"Unknown integration method: {kw}")
+        return integrators[kw]()
+
+    def __call__(self, vel, mix, t0, r0, dt):
+        """
+        Integrate a stochastic differential equation, one time step
+
+        For both ``vel`` and ``mix``, the calling signature is fun(t, r) where t is
+        scalar time and r is an array of particle positions. The function should
+        return an array of the same shape as r.
+
+        Both ``vel`` and ``mix`` should  assume the same coordinate system and units as
+        the input particle positions and time. For instance, if time is given in
+        seconds and positions are given in grid coordinates, velocity should have units
+        of grid cells per second and mixing should have units of grid cells squared per
+        second.
+
+        :param vel: Velocity function. Calling signature is fun(t, r) where t is scalar
+        and r is an array of particle positions. Should return an array of the
+        same shape as r.
+
+        :param mix: Mixing function. Calling signature is fun(t, r) where t is scalar
+        and r is an array of particle positions. Should return an array of the
+        same shape as r.
+
+        :param t0: Initial time
+
+        :param r0: Initial positions
+
+        :param dt: Time step size
+
+        :return: Final particle positions (same shape as r0)
+        """
+
+        return r0
+
+
+class RK4Integrator(StochasticDifferentialEquationIntegrator):
+    def __call__(self, velocity, mixing, t0, r0, dt):
+        u1 = velocity(t0, r0)
+        r1 = r0 + 0.5 * u1 * dt
+
+        u2 = velocity(t0 + 0.5 * dt, r1)
+        r2 = r0 + 0.5 * u2 * dt
+
+        u3 = velocity(t0 + 0.5 * dt, r2)
+        r3 = r0 + u3 * dt
+
+        u4 = velocity(t0 + dt, r3)
+
+        u_adv = (u1 + 2 * u2 + 2 * u3 + u4) / 6.0
+        r_adv = r0 + u_adv * dt
+
+        # Diffusive velocity
+        u_diff = mixing(t0, r_adv)
+        dw = np.random.normal(size=np.size(r0)).reshape(r0.shape) * np.sqrt(dt)
+
+        return r_adv + u_diff * dw
+
+
+class EFIntegrator(StochasticDifferentialEquationIntegrator):
+    def __call__(self, velocity, mixing, t0, r0, dt):
+        u1 = velocity(t0, r0)
+        r_adv = r0 + u1 * dt
+
+        # Diffusive velocity
+        u_diff = mixing(t0, r_adv)
+        dw = np.random.normal(size=np.size(r0)).reshape(r0.shape) * np.sqrt(dt)
+
+        return r_adv + u_diff * dw
+
+
+class RK4NodiffIntegrator(StochasticDifferentialEquationIntegrator):
+    def __call__(self, velocity, mixing, t0, r0, dt):
+        u1 = velocity(t0, r0)
+        r1 = r0 + 0.5 * u1 * dt
+
+        u2 = velocity(t0 + 0.5 * dt, r1)
+        r2 = r0 + 0.5 * u2 * dt
+
+        u3 = velocity(t0 + 0.5 * dt, r2)
+        r3 = r0 + u3 * dt
+
+        u4 = velocity(t0 + dt, r3)
+
+        u_adv = (u1 + 2 * u2 + 2 * u3 + u4) / 6.0
+        r_adv = r0 + u_adv * dt
+
+        return r_adv
+
+
+class EFNodiffIntegrator(StochasticDifferentialEquationIntegrator):
+    def __call__(self, velocity, mixing, t0, r0, dt):
+        u1 = velocity(t0, r0)
+        return r0 + u1 * dt

ladim/utilities.py

@@ -25,3 +25,8 @@ def ingrid(x: float, y: float, subgrid: List[int]) -> bool:
     """Check if position (x, y) is in a subgrid"""
     i0, i1, j0, j1 = subgrid
     return (i0 <= x) & (x <= i1 - 1) & (j0 <= y) & (y <= j1 - 1)
+
+
+def read_timedelta(conf) -> np.timedelta64:
+    time_value, time_unit = conf
+    return np.timedelta64(time_value, time_unit)

{ladim-1.3.3.dist-info → ladim-2.0.0.dist-info}/METADATA

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

ladim-2.0.0.dist-info/RECORD

@@ -0,0 +1,31 @@
+ladim/__init__.py,sha256=Ns1alQ3-vgq1Hh0sgRGMsYsmH5LnEReoG-M-ajzLg04,51
+ladim/config.py,sha256=6b0ikBrBnq_sSElgO2YcVtJHjQU0nyZsVyPV3q9fy5I,4233
+ladim/forcing.py,sha256=f4PpSwyilSScXeNyorTWLMgVTiat9htSLkCwAkRlJVM,3048
+ladim/grid.py,sha256=m6bQrGJ3cux7rqC8pbRXD86cOI-VQKF-XjP9m1jCIcY,2221
+ladim/main.py,sha256=wO91-nLd1gvF3V20XK5qRvvOIV4xoTOKiWFcbwV2oag,2812
+ladim/model.py,sha256=jpjq_ZSh7ULpwi3_RqDb-p5SG8WcdgCPaBkSpnNWblU,3137
+ladim/output.py,sha256=Rz7iujvS7Z3LoABiJduQqyb3zPswNqhhFsywr3MLsBY,8373
+ladim/release.py,sha256=5QD0hxQNmkxGmtrQX72T5QumHeWLQMFHysJD6Sc0BUE,8067
+ladim/sample.py,sha256=n8wRGd_VsW_qyQe1ZoTpmfZcdcwB929vsM8PoKG6JTs,8292
+ladim/solver.py,sha256=sZvYgOxzJ-EItI-IB2y8_z8Tf-SJAQSrmydlhDRa7ZQ,755
+ladim/state.py,sha256=5ICIiujsV3KOAUYagGLK7YdmhcItgJmtntZeR11nIpw,3781
+ladim/tracker.py,sha256=VVX6T5CqiU6nGSCgLlSCC8w0UYhW273OGFE7ApPjdyI,5091
+ladim/utilities.py,sha256=r7-zShqJhh0cBctDUmtfw-GBOk1eTTYR4S72b0ouiSQ,994
+ladim/gridforce/ROMS.py,sha256=yrMr1GiDgr7VG9V630nHFdeajPY4WHLu653ZRwAk1aw,26888
+ladim/gridforce/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ladim/gridforce/analytical.py,sha256=qI-1LJdjmnwwanzOdrsDZqwGgo73bT75CB7pMaxbHKM,1094
+ladim/gridforce/zROMS.py,sha256=MVA6PQuY1ukvs2E20sWY4kr5-QieeQHTrA5ruxCqbUM,22826
+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
+postladim/__init__.py,sha256=ND-wa5_GNg01Tp0p_1zA1VD804zbfP3o4Cmd8pWU7OE,113
+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.0.dist-info/LICENSE,sha256=BgtXyjNr6Ly9nQ7ZLXKpV3r5kWRLnh5MiN0dxp0Bvfc,1085
+ladim-2.0.0.dist-info/METADATA,sha256=ap0yaeqHIhnmQiMwuH8gaCT__YNxESVoudzgFuko9Zs,1841
+ladim-2.0.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+ladim-2.0.0.dist-info/entry_points.txt,sha256=JDlNJo87GJaOkH0-BpAzTPLCrZcuPSdSlHNQ4XmnoRg,41
+ladim-2.0.0.dist-info/top_level.txt,sha256=TK8Gl7d6MsrAQvqKG4b6YJCbB4UL46Se3SzsI-sJAuc,16
+ladim-2.0.0.dist-info/RECORD,,

{ladim-1.3.3.dist-info → ladim-2.0.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.42.0)
+Generator: bdist_wheel (0.43.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

ladim/configuration/__init__.py

@@ -1 +0,0 @@
-from .modularized import configure

ladim/configuration/legacy.py

@@ -1,425 +0,0 @@
-"""
-Configuration module for ladim
-"""
-
-# ----------------------------------
-# Bjørn Ådlandsvik <bjorn@imr.no>
-# Institute of Marine Research
-# 2017-01-17
-# ----------------------------------
-
-# import datetime
-import logging
-from typing import Dict, Any
-import numpy as np
-import yaml
-import yaml.parser
-from netCDF4 import Dataset, num2date
-
-Config = Dict[str, Any]  # type of the config dictionary
-
-
-def configure(conf):
-    config = read_configuration(conf)
-    config = to_modularized_conf(config)
-    return config
-
-def configure_ibm(conf: Dict[str, Any]) -> Config:
-    """Configure the IBM module
-
-    Input: Raw conf dictionary from configuration file
-
-    Return: Dictionary with IBM configuration
-
-    If an IBM is used, check that module name is present
-    Special treatment for the variables item
-    Other items are stored for the IBM module
-    """
-
-    logging.info("Configuration: IBM")
-    if conf is None:  # No ibm section
-        return {}
-    D = conf.get("ibm")  # Empty ibm section
-    if D is None:
-        return {}
-
-    # Mandatory: module name (or obsolete ibm_module)
-    if "module" not in D:
-        if "ibm_module" in D:
-            D["module"] = D.pop("ibm_module")
-        else:
-            logging.error("No IBM module specified")
-            raise SystemExit(1)
-    logging.info(f'    {"module":15s}: {D["module"]}')
-
-    # The variables item
-    if "variables" not in D:
-        if "ibm_variables" in D:
-            D["variables"] = D.pop("ibm_variables")
-        # ibm_variables may live under state (obsolete)
-        elif "state" in conf and conf["state"] is not None:
-            if "ibm_variables" in conf.get("state", dict()):
-                D["variables"] = conf["state"]["ibm_variables"]
-        else:
-            D["variables"] = []
-
-    for key in D:
-        if key != "module":
-            logging.info(f"    {key:15s}: {D[key]}")
-
-    return D
-
-
-def configure_gridforce(conf: Dict[str, Any]) -> Config:
-    """Parse gridforce related info and pass on
-
-    Input: raw conf dictionary from configuration file
-
-    Return: dictionary with gridforce configuration
-
-    """
-    logging.info("Configuration: gridforce")
-    if conf is None:
-        logging.error("No gridforce section in configuration file")
-        raise SystemExit(1)
-    D = conf.get("gridforce")
-    if D is None:
-        logging.error("Empty gridforce section in configuration file")
-        raise SystemExit(1)
-
-    # module is the only mandatory field
-    if "module" not in D:
-        logging.error("No gridforce module specified")
-        raise SystemExit(1)
-    logging.info(f'    {"module":15s}: {D["module"]}')
-
-    # Backwards compability (for ROMS.py)
-    if "files" in conf and conf["files"] is not None:
-        if "grid_file" in conf["files"]:
-            # Give grid_file under gridforce highest priority
-            if "grid_file" not in D:
-                D["grid_file"] = conf["files"]["grid_file"]
-        if "input_file" in conf["files"]:
-            # Give input_file under gridforce highest priority
-            if "input_file" not in D:
-                D["input_file"] = conf["files"]["input_file"]
-
-    for key in D:
-        if key != "module":
-            logging.info(f"    {key:15s}: {D[key]}")
-
-    return D
-
-
-# ---------------------------------------
-
-
-def read_configuration(conf) -> Config:
-    """The main configuration handling function
-
-    Input: Name of configuration file in yaml format
-
-    Returns: Configuration dictionary
-
-    """
-
-    config: Config = dict()
-
-
-    # ----------------
-    # Time control
-    # ----------------
-    logging.info("Configuration: Time Control")
-    for name in ["start_time", "stop_time"]:
-        config[name] = np.datetime64(conf["time_control"][name]).astype("M8[s]")
-        logging.info(f"    {name.replace('_', ' '):15s}: {config[name]}")
-    # reference_time, default = start_time
-    config["reference_time"] = np.datetime64(
-        conf["time_control"].get("reference_time", config["start_time"])
-    ).astype("M8[s]")
-    logging.info(f'    {"reference time":15s}: {config["reference_time"]}')
-
-    # -------------
-    # Files
-    # -------------
-    logging.info("Configuration: Files")
-    #logging.info(f'    {"config_stream":15s}: {config_stream}')
-    for name in ["particle_release_file", "output_file"]:
-        config[name] = conf["files"][name]
-        logging.info(f"    {name:15s}: {config[name]}")
-
-    try:
-        config["warm_start_file"] = conf["files"]["warm_start_file"]
-        config["start"] = "warm"
-        logging.info(f'    {"Warm start from":15s}: {config["warm_start_file"]}')
-    except KeyError:
-        config["start"] = "cold"
-        config["warm_start_file"] = ""
-
-    # Override start time for warm start
-    if config["start"] == "warm":
-        try:
-            nc = Dataset(config["warm_start_file"])
-        except (FileNotFoundError, OSError):
-            logging.error(f"Could not open warm start file,{config['warm_start_file']}")
-            raise SystemExit(1)
-        tvar = nc.variables["time"]
-        # Use last record in restart file
-        warm_start_time = np.datetime64(num2date(tvar[-1], tvar.units))
-        warm_start_time = warm_start_time.astype("M8[s]")
-        config["start_time"] = warm_start_time
-        logging.info(f"    Warm start at {warm_start_time}")
-
-        # Variables needed by restart, mightwarm_ be changed
-        # default should be instance variables among release variables
-        try:
-            warm_start_variables = conf["state"]["warm_start_variables"]
-        except KeyError:
-            warm_start_variables = ["X", "Y", "Z"]
-        config["warm_start_variables"] = warm_start_variables
-
-    # --- Time stepping ---
-    logging.info("Configuration: Time Stepping")
-    # Read time step and convert to seconds
-    dt = np.timedelta64(*tuple(conf["numerics"]["dt"]))
-    config["dt"] = int(dt.astype("m8[s]").astype("int"))
-    config["simulation_time"] = np.timedelta64(
-        config["stop_time"] - config["start_time"], "s"
-    ).astype("int")
-    config["numsteps"] = config["simulation_time"] // config["dt"]
-    logging.info(f'    {"dt":15s}: {config["dt"]} seconds')
-    logging.info(
-        f'    {"simulation time":15s}: {config["simulation_time"] // 3600} hours'
-    )
-    logging.info(f'    {"number of time steps":15s}: {config["numsteps"]}')
-
-    #  --- Grid ---
-    config["gridforce"] = configure_gridforce(conf)
-
-    # --- Forcing ---
-    try:
-        config["ibm_forcing"] = conf["gridforce"]["ibm_forcing"]
-    except (KeyError, TypeError):
-        config["ibm_forcing"] = []
-    # ibm_forcing used to be a dictionary
-    if isinstance(config["ibm_forcing"], dict):
-        config["ibm_forcing"] = list(config["ibm_forcing"].keys())
-    logging.info(f'    {"ibm_forcing":15s}: {config["ibm_forcing"]}')
-
-    # --- IBM ---
-
-    config["ibm"] = configure_ibm(conf)
-    # Make obsolete
-    config["ibm_variables"] = config["ibm"].get("variables", [])
-    config["ibm_module"] = config["ibm"].get("module")
-
-    # --- Particle release ---
-    logging.info("Configuration: Particle Releaser")
-    prelease = conf["particle_release"]
-    try:
-        config["release_type"] = prelease["release_type"]
-    except KeyError:
-        config["release_type"] = "discrete"
-    logging.info(f'    {"release_type":15s}: {config["release_type"]}')
-    if config["release_type"] == "continuous":
-        config["release_frequency"] = np.timedelta64(
-            *tuple(prelease["release_frequency"])
-        )
-        logging.info(
-            f'    {"release_frequency":11s}: {str(config["release_frequency"])}'
-        )
-    config["release_format"] = conf["particle_release"]["variables"]
-    config["release_dtype"] = dict()
-    # Map from str to converter
-    type_mapping = dict(int=int, float=float, time=np.datetime64, str=str)
-    for name in config["release_format"]:
-        config["release_dtype"][name] = type_mapping[
-            conf["particle_release"].get(name, "float")
-        ]
-        logging.info(f'    {name:15s}: {config["release_dtype"][name]}')
-    config["particle_variables"] = prelease["particle_variables"]
-
-    # --- Model state ---
-    # logging.info("Configuration: Model State Variables")
-
-    # -----------------
-    # Output control
-    # -----------------
-    logging.info("Configuration: Output Control")
-    try:
-        output_format = conf["output_variables"]["format"]
-    except KeyError:
-        output_format = "NETCDF3_64BIT_OFFSET"
-    config["output_format"] = output_format
-    logging.info(f'    {"output_format":15s}: {config["output_format"]}')
-
-    # Skip output of initial state, useful for restart
-    # with cold start the default is False
-    # with warm start, the default is true
-    try:
-        skip_initial = conf["output_variables"]["skip_initial_output"]
-    except KeyError:
-        skip_initial = config["start"] == "warm"
-    config["skip_initial"] = skip_initial
-    logging.info(f"    {'Skip inital output':15s}: {skip_initial}")
-
-    try:
-        numrec = conf["output_variables"]["numrec"]
-    except KeyError:
-        numrec = 0
-    config["output_numrec"] = numrec
-    logging.info(f'    {"output_numrec":15s}: {config["output_numrec"]}')
-
-    outper = np.timedelta64(*tuple(conf["output_variables"]["outper"]))
-    outper = outper.astype("m8[s]").astype("int") // config["dt"]
-    config["output_period"] = outper
-    logging.info(f'    {"output_period":15s}: {config["output_period"]} timesteps')
-    config["num_output"] = 1 + config["numsteps"] // config["output_period"]
-    logging.info(f'    {"numsteps":15s}: {config["numsteps"]}')
-    config["output_particle"] = conf["output_variables"]["particle"]
-    config["output_instance"] = conf["output_variables"]["instance"]
-    config["nc_attributes"] = dict()
-    for name in config["output_particle"] + config["output_instance"]:
-        value = conf["output_variables"][name]
-        if "units" in value:
-            if value["units"] == "seconds since reference_time":
-                timeref = str(config["reference_time"]).replace("T", " ")
-                value["units"] = f"seconds since {timeref}"
-        config["nc_attributes"][name] = conf["output_variables"][name]
-    logging.info("    particle variables")
-    for name in config["output_particle"]:
-        logging.info(8 * " " + name)
-        for item in config["nc_attributes"][name].items():
-            logging.info(12 * " " + "{:11s}: {:s}".format(*item))
-    logging.info("    particle instance variables")
-    for name in config["output_instance"]:
-        logging.info(8 * " " + name)
-        for item in config["nc_attributes"][name].items():
-            logging.info(12 * " " + "{:11s}: {:s}".format(*item))
-
-    # --- Numerics ---
-
-    # dt belongs here, but is already read
-    logging.info("Configuration: Numerics")
-    try:
-        config["advection"] = conf["numerics"]["advection"]
-    except KeyError:
-        config["advection"] = "RK4"
-    logging.info(f'    {"advection":15s}: {config["advection"]}')
-    try:
-        diffusion = conf["numerics"]["diffusion"]
-    except KeyError:
-        diffusion = 0.0
-    if diffusion > 0:
-        config["diffusion"] = True
-        config["diffusion_coefficient"] = diffusion
-        logging.info(
-            f'    {"diffusion coefficient":15s}: {config["diffusion_coefficient"]}'
-        )
-    else:
-        config["diffusion"] = False
-        logging.info("    no diffusion")
-    config["seed"] = conf['numerics'].get('seed', None)
-
-    return config
-
-
-def to_modularized_conf(c):
-    mconf = dict(
-        release=dict(
-            module='ladim.release.legacy.ParticleReleaser',
-            release_type=c['release_type'],
-            release_format=c['release_format'],
-            release_dtype=c['release_dtype'],
-            start_time=c['start_time'],
-            stop_time=c['stop_time'],
-            particle_release_file=c['particle_release_file'],
-            start=c['start'],
-            dt=c['dt'],
-            warm_start_file=c['warm_start_file'],
-            particle_variables=c['particle_variables'],
-            reference_time=c['reference_time'],
-            release_frequency=c.get("release_frequency", None),
-        ),
-        state=dict(
-            module='ladim.state.legacy.State',
-            particle_variables=c['particle_variables'],
-            start_time=c['start_time'],
-            dt=c['dt'],
-            ibm=dict(variables=c['ibm'].get('variables', [])),
-            release_dtype=c['release_dtype'],
-            warm_start_file=c['warm_start_file'],
-            ibm_forcing=c['ibm_forcing'],
-        ),
-        grid={
-            **c['gridforce'],
-            **dict(
-                start_time=c['start_time'],
-                legacy_module=c['gridforce']['module'],
-                module='ladim.gridforce.legacy.Grid',
-            ),
-        },
-        forcing={
-            **c['gridforce'],
-            **dict(
-                start_time=c['start_time'],
-                stop_time=c['stop_time'],
-                dt=c['dt'],
-                legacy_module=c['gridforce']['module'],
-                module='ladim.gridforce.legacy.Forcing',
-            ),
-        },
-        output=dict(
-            module='ladim.output.legacy.OutPut',
-            output_format=c['output_format'],
-            skip_initial=c['skip_initial'],
-            output_numrec=c['output_numrec'],
-            output_period=c['output_period'],
-            num_output=c['num_output'],
-            output_particle=c['output_particle'],
-            output_instance=c['output_instance'],
-            nc_attributes=c['nc_attributes'],
-            reference_time=c['reference_time'],
-            output_file=c['output_file'],
-            dt=c['dt'],
-        ),
-        timestepper=dict(
-            start=c['start_time'],
-            stop=c['stop_time'],
-            step=c['dt'],
-            order=('release', 'forcing', 'output', 'tracker', 'ibm', 'state'),
-            seed=c.get("seed", None),
-        ),
-        tracker=dict(
-            module='ladim.tracker.legacy.Tracker',
-            advection=c['advection'],
-            diffusion=c['diffusion'],
-            dt=c['dt'],
-            ibm_variables=c['ibm_variables'],
-            diffusion_coefficient=c.get('diffusion_coefficient', 0),
-        ),
-        ibm={
-            **c['ibm'],
-            **dict(
-                module='ladim.ibms.legacy.Legacy_IBM',
-                dt=c['dt'],
-                start_time=c['start_time'],
-                nc_attributes=c['nc_attributes'],
-                output_instance=c['output_instance'],
-                legacy_module=c['ibm'].get('module', None),
-            ),
-        },
-    )
-    return mconf
-
-
-def strdict(d, ind=0):
-    s = ""
-    for k, v in d.items():
-        if isinstance(v, dict):
-            s += (" " * ind) + f"{k}:\n"
-            s += strdict(v, ind + 2)
-        else:
-            s += (" " * ind) + f"{k}: {v}\n"
-
-    return s

ladim/configuration/modularized.py

@@ -1,22 +0,0 @@
-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' in config_dict:
-        return _versioned_configure(config_dict)
-    else:
-        return _legacy_configure(config_dict)
-
-
-def _versioned_configure(config_dict):
-    return config_dict
-
-
-def _legacy_configure(config_dict):
-    from .legacy import configure as legacy_configure
-    return legacy_configure(config_dict)