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

ladim/release/legacy.py

@@ -1,316 +0,0 @@
-# Particle release class
-
-# -------------------
-# release.py
-# part of LADiM
-# --------------------
-
-# ----------------------------------
-# Bjørn Ådlandsvik <bjorn@imr.no>
-# Institute of Marine Research
-# Bergen, Norway
-# ----------------------------------
-
-import logging
-import numpy as np
-import pandas as pd
-from typing import Iterator, List
-
-from netCDF4 import Dataset
-
-from ladim.utilities import ingrid
-
-
-# from .gridforce import Grid
-
-
-def mylen(df: pd.DataFrame) -> int:
-    """Number of rows in a DataFrame,
-
-    A workaround for len() which does not
-    have the expected behaviour with itemizing,
-    """
-    return df.shape[0] if df.ndim > 1 else 1
-    # if df.ndim == 1:
-    #     return 1
-    # else:
-    #     return df.shape[0]
-
-
-class ParticleReleaser(Iterator):
-    """Particle Release Class"""
-
-    def __init__(self, modules, **config) -> None:
-        self.modules = modules
-
-        start_time = pd.to_datetime(config["start_time"])
-        stop_time = pd.to_datetime(config["stop_time"])
-
-        logging.info("Initializing the particle releaser")
-
-        # Read the particle release file
-        A = pd.read_csv(
-            config["particle_release_file"],
-            names=config["release_format"],
-            converters=config["release_dtype"],
-            sep='\\s+',
-        )
-
-        # If no mult column, add a column of ones
-        if "mult" not in config["release_format"]:
-            A["mult"] = 1
-
-        # Use release_time as index
-        A.index = A["release_time"]
-
-        # Conversion from longitude, latitude to grid coordinates
-        if "X" not in A.columns or "Y" not in A.columns:
-            if "lon" not in A.columns or "lat" not in A.columns:
-                logging.critical("Particle release mush have position")
-                raise SystemExit(3)
-            # else
-            X, Y = modules['grid'].ll2xy(A["lon"], A["lat"])
-            A["lon"] = X
-            A["lat"] = Y
-            A.rename(columns={"lon": "X", "lat": "Y"}, inplace=True)
-
-        # Remove everything after simulation stop time
-        # A = A[A['release_time'] <= stop_time]   # Use < ?
-        A = A[A.index <= stop_time]  # Use < ?
-        if len(A) == 0:  # All release after simulation time
-            logging.critical("All particles released after similation stop")
-            raise SystemExit(3)
-
-        # Optionally, remove everything outside a subgrid
-        try:
-            subgrid: List[int] = config["grid_args"]["subgrid"]
-        except KeyError:
-            subgrid = []
-        if subgrid:
-            lenA = len(A)
-            A = A[ingrid(A["X"], A["Y"], subgrid)]
-            if len(A) < lenA:
-                logging.warning("Ignoring particle release outside subgrid")
-
-        # file_times = A['release_time'].unique()
-
-        # TODO: Make a function of continuous -> discrete
-        # Fill out if continuous release
-        if config["release_type"] == "continuous":
-
-            # Find first effective release time
-            # i.e. the last time <= start_time
-            #   and remove too early releases
-            # Can be moved out of if-block?
-            n = np.sum(A.index <= start_time)
-            if n == 0:
-                logging.warning("No particles released at simulation start")
-                n = 1
-            # First effective release:
-            # release_time0 = A.iloc[n-1].release_time
-
-            # TODO: Check pandas, better way to delete rows?
-            times = A["release_time"]
-            try:
-                release_time0 = times[times <= pd.to_datetime(start_time)][-1]
-            except IndexError:
-                release_time0 = times[0]
-            A = A[A.index >= release_time0]
-
-            # time0 = file_times[0]
-            # time1 = max(file_times[-1], stop_time)
-            time0 = A.index[0]
-            time1 = max(A.index[-1], pd.Timestamp(stop_time))
-            # time1 = max(A['release_time'][-1], stop_time)
-            times = np.arange(time0, time1, config["release_frequency"])
-            # A = A.reindex(times, method='pad')
-            # A['release_time'] = A.index
-            # Reindex does not work with non-unique index
-            I = A.index.unique()
-            J = pd.Series(I, index=I).reindex(times, method="pad")
-            M = {i: mylen(A.loc[i]) for i in I}
-            A = A.loc[J]
-            # Correct time index
-            S: List[int] = []
-            for t in times:
-                S.extend(M[J[t]] * [t])
-            A["release_time"] = S
-            A.index = S
-
-            # Remove any new instances before start time
-            # n = np.sum(A['release_time'] <= start_time)
-            # if n == 0:
-            #     n = 1
-            # A = A.iloc[n-1:]
-
-            # If first release is early set it to start time
-            # A['release_time'] = np.maximum(A['release_time'], # tart_time)
-
-        # If discrete, there is an error to have only early releases
-        # OK if warm start
-        else:  # Discrete
-            if A.index[-1] < start_time and config["start"] == "cold":
-                logging.error("All particles released before similation start")
-                raise SystemExit
-
-        # We are now discrete,
-        # remove everything before start time
-        A = A[A.index >= start_time]
-
-        # If warm start, no new release at start time (already accounted for)
-        if config["start"] == "warm":
-            A = A[A.index > start_time]
-
-        # Compute which timestep the release should happen
-        timediff = A["release_time"] - config['start_time']
-        dt = np.timedelta64(config["dt"], 's')
-        rel_tstep = np.int32(timediff / dt)
-
-        # Release times, rounded to nearest time step
-        self.times = np.unique(config['start_time'] + rel_tstep * dt)
-
-        logging.info("Number of release times = {}".format(len(self.times)))
-
-        # Compute the release time steps
-        rel_time = self.times - config["start_time"]
-        rel_time = rel_time.astype("m8[s]").astype("int")
-        self.steps = rel_time // config["dt"]
-
-        # Make dataframes for each timeframe
-        # self._B = [x[1] for x in A.groupby('release_time')]
-        self._B = [x[1] for x in A.groupby(rel_tstep)]
-
-        # Read the particle variables
-        self._index = 0  # Index of next release
-        self._particle_count = 0  # Particle counter
-
-        # Handle the particle variables initially
-        # TODO: Need a test to check that this iw working properly
-        pvars = dict()
-        for name in config["particle_variables"]:
-            dtype = config["release_dtype"][name]
-            if dtype == np.datetime64:
-                dtype = np.float64
-            pvars[name] = np.array([], dtype=dtype)
-
-        # Get particle data from  warm start
-        if config["start"] == "warm":
-            with Dataset(config["warm_start_file"]) as f:
-                # warm_particle_count = len(f.dimensions['particle'])
-                warm_particle_count = np.max(f.variables["pid"][:]) + 1
-                for name in config["particle_variables"]:
-                    pvars[name] = f.variables[name][:warm_particle_count]
-        else:
-            warm_particle_count = 0
-
-        # initital number of particles
-        if config["start"] == "warm":
-            init_released = warm_particle_count
-        else:
-            init_released = 0
-        particles_released = [init_released] + [df['mult'].sum() for df in self._B]
-
-        # Loop through the releases, collect particle variable data
-        mult = A['mult'].values
-        for name in config['particle_variables']:
-            val = np.repeat(A[name].values, mult)
-            if config['release_dtype'][name] == np.datetime64:
-                val = (val - config["reference_time"]) / np.timedelta64(1, 's')
-            pvars[name] = np.concatenate((pvars[name], val))
-
-        self.total_particle_count = warm_particle_count + np.sum(mult)
-        self.particle_variables = pvars
-        logging.info("Total particle count = {}".format(self.total_particle_count))
-        self.particles_released = particles_released
-
-        # Export total particle count
-        # Ugly to write back to config
-        # Easier way to give this piece of information to the
-        #     output initialization?
-        config["total_particle_count"] = self.total_particle_count
-
-        # Reset the counter after the particle counting
-        self._index = 0  # Index of next release
-        self._particle_count = warm_particle_count
-
-    def update(self):
-        step = self.modules['state'].timestep
-        grid = self.modules['grid']
-        state = self.modules['state']
-
-        # Extension, allow inactive particles (not moved next time)
-        if "active" in state.ibm_variables:
-            pass
-            # self.active = self.ibm_variables['active']
-        else:  # Default = active
-            state.active = np.ones_like(state.pid)
-
-        # Surface/bottom boundary conditions
-        #     Reflective  at surface
-        I = state.Z < 0
-        state.Z[I] = -state.Z[I]
-        #     Keep just above bottom
-        H = grid.sample_depth(state.X, state.Y)
-        I = state.Z > H
-        state.Z[I] = 0.99 * H[I]
-
-        # Compactify by removing dead particles
-        # Could have a switch to avoid this if no deaths
-        state.pid = state.pid[state.alive]
-        for key in state.instance_variables:
-            state[key] = state[key][state.alive]
-
-        if step in self.steps:
-            V = next(self)
-            self.modules['state'].append(V, self.modules['forcing'])
-
-        # From physics all particles are alive
-        # self.alive = np.ones(len(self), dtype="bool")
-        state.alive = grid.ingrid(state.X, state.Y)
-
-    def __next__(self) -> pd.DataFrame:
-        """Perform the next particle release
-
-           Return a DataFrame with the release info,
-           repeating mult times
-
-        """
-
-        # This should not happen
-        if self._index >= len(self.times):
-            raise StopIteration
-
-        # Skip first release if warm start (should be present in start file)
-        # Not always, make better test
-        # Moving test to state.py
-        # if self._index == 0 and self._particle_count > 0:  # Warm start
-        #    return
-
-        # rel_time = self.times[self._index]
-        # file_time = self._file_times[self._file_index]
-
-        V = self._B[self._index]
-        nnew = V.mult.sum()
-        # Workaround, missing repeat method for pandas DataFrame
-        V0 = V.to_records(index=False)
-        V0 = V0.repeat(V.mult)
-        V = pd.DataFrame(V0)
-        # Do not need the mult column any more
-        V.drop("mult", axis=1, inplace=True)
-        # Buffer the new values
-        # self.V = V
-        # self._file_index += 1
-
-        # Add the new pids
-        nnew = len(V)
-
-        pids = pd.Series(
-            range(self._particle_count, self._particle_count + nnew), name="pid"
-        )
-        V = V.join(pids)
-
-        # Update the counters
-        self._index += 1
-        self._particle_count += len(V)
-
-        return V

ladim/state/__init__.py

@@ -1 +0,0 @@
-from .legacy import State

ladim/state/legacy.py

@@ -1,126 +0,0 @@
-"""
-Class for the state of the model
-"""
-
-import sys
-import os
-import importlib
-import logging
-from typing import Any, Dict, Sized  # mypy
-
-import numpy as np
-from netCDF4 import Dataset, num2date
-
-from ladim.tracker.legacy import Tracker
-from ladim.gridforce.legacy import Grid, Forcing
-
-# ------------------------
-
-Config = Dict[str, Any]
-
-
-class State(Sized):
-    """The model variables at a given time"""
-
-    def __init__(self, modules, **config):
-        self.modules = modules
-
-        logging.info("Initializing the model state")
-
-        self.timestep = 0
-        self.timestamp = config["start_time"].astype("datetime64[s]")
-        self.dt = np.timedelta64(config["dt"], "s")
-        self.position_variables = ["X", "Y", "Z"]
-        if "ibm" in config and "variables" in config["ibm"]:
-            self.ibm_variables = config["ibm"]["variables"]
-        else:
-            self.ibm_variables = config.get("ibm_variables", [])
-        self.ibm_forcing = config["ibm_forcing"]
-        self.particle_variables = config["particle_variables"]
-        self.instance_variables = self.position_variables + [
-            var for var in self.ibm_variables if var not in self.particle_variables
-        ]
-
-        self.pid = np.array([], dtype=int)
-        for name in self.instance_variables:
-            setattr(self, name, np.array([], dtype=float))
-
-        for name in self.particle_variables:
-            setattr(self, name, np.array([], dtype=config["release_dtype"][name]))
-
-        self.dt = config["dt"]
-        self.alive = []
-
-        # self.num_particles = len(self.X)
-        self.nnew = 0  # Modify with warm start?
-
-        if config["warm_start_file"]:
-            self.warm_start(config, self.modules['grid'])
-
-    def __getitem__(self, name: str) -> None:
-        return getattr(self, name)
-
-    def __setitem__(self, name: str, value: Any) -> None:
-        return setattr(self, name, value)
-
-    def __len__(self) -> int:
-        return len(getattr(self, "X"))
-
-    def append(self, new: Dict[str, Any], forcing: Forcing) -> None:
-        """Append new particles to the model state"""
-        nnew = len(new["pid"])
-        self.pid = np.concatenate((self.pid, new["pid"]))
-        for name in self.instance_variables:
-            if name in new:
-                self[name] = np.concatenate((self[name], new[name]))
-            elif name in self.ibm_forcing:
-                # Take values as Z must be a numpy array
-                self[name] = np.concatenate(
-                    (self[name], forcing.field(new["X"], new["Y"], new["Z"].values, name))
-                )
-            else:  # Initialize to zero
-                self[name] = np.concatenate((self[name], np.zeros(nnew)))
-        self.nnew = nnew
-
-    def update(self):
-        """Update the model state to the next timestep"""
-        self.timestep += 1
-        self.timestamp += np.timedelta64(self.dt, "s")
-
-        if self.timestamp.astype("int") % 3600 == 0:  # New hour
-            logging.info("Model time = {}".format(self.timestamp.astype("M8[h]")))
-
-    def warm_start(self, config: Config, grid: Grid) -> None:
-        """Perform a warm (re)start"""
-
-        warm_start_file = config["warm_start_file"]
-        try:
-            f = Dataset(warm_start_file)
-        except FileNotFoundError:
-            logging.critical(f"Can not open warm start file: {warm_start_file}")
-            raise SystemExit(1)
-
-        logging.info("Reading warm start file")
-        # Using last record in file
-        tvar = f.variables["time"]
-        warm_start_time = np.datetime64(num2date(tvar[-1], tvar.units))
-        # Not needed anymore, explicitly set in configuration
-        # if warm_start_time != config['start_time']:
-        #    print("warm start time = ", warm_start_time)
-        #    print("start time      = ", config['start_time'])
-        #    logging.error("Warm start time and start time differ")
-        #    raise SystemExit(1)
-
-        pstart = f.variables["particle_count"][:-1].sum()
-        pcount = f.variables["particle_count"][-1]
-        self.pid = f.variables["pid"][pstart : pstart + pcount]
-        # Give error if variable not in restart file
-        for var in config["warm_start_variables"]:
-            logging.debug(f"Reading {var} from warm start file")
-            self[var] = f.variables[var][pstart : pstart + pcount]
-
-        # Remove particles near edge of grid
-        I = grid.ingrid(self["X"], self["Y"])
-        self.pid = self.pid[I]
-        for var in config["warm_start_variables"]:
-            self[var] = self[var][I]

ladim/tracker/__init__.py

@@ -1 +0,0 @@
-from .legacy import Tracker

ladim/tracker/legacy.py

@@ -1,225 +0,0 @@
-# ------------------------------------
-# tracker.py
-# Part of the LADiM Model
-#
-# Bjørn Ådlandsvik, <bjorn@imr.no>
-# Institute of Marine Research
-#
-# Licenced under the MIT license
-# ------------------------------------
-
-import logging
-from typing import Any, Tuple
-import numpy as np
-
-from ladim.gridforce.legacy import Grid, Forcing
-
-# from .state import State   # Circular import
-
-Velocity = Tuple[np.ndarray, np.ndarray]
-State = Any  # Could not find any better
-
-
-class Tracker:
-    """The physical particle tracking kernel"""
-
-    def __init__(self, modules, **config) -> None:
-        self.modules = modules
-
-        logging.info("Initiating the particle tracking")
-        self.dt = config["dt"]
-        if config["advection"]:
-            self.advect = getattr(self, config["advection"])
-        else:
-            self.advect = None
-        # Read from config:
-        self.diffusion = config["diffusion"]
-        if self.diffusion:
-            self.D = config["diffusion_coefficient"]  # [m2.s-1]
-        self.active_check = 'active' in config['ibm_variables']
-
-    def update(self):
-        self.move_particles(
-            self.modules['grid'],
-            self.modules['forcing'],
-            self.modules['state'],
-        )
-
-    def move_particles(self, grid: Grid, forcing: Forcing, state: State) -> None:
-        """Move the particles"""
-
-        X, Y = state.X, state.Y
-        dx, dy = grid.sample_metric(X, Y)
-        self.dx, self.dy = dx, dy
-        dt = self.dt
-        self.num_particles = len(X)
-        # Make more elegant, need not do every time
-        # Works for C-grid
-        self.xmin = grid.xmin + 0.01
-        self.xmax = grid.xmax - 0.01
-        self.ymin = grid.ymin + 0.01
-        self.ymax = grid.ymax - 0.01
-
-        U = np.zeros(self.num_particles, dtype=float)
-        V = np.zeros(self.num_particles, dtype=float)
-
-        # --- Advection ---
-        if self.advect:
-            Uadv, Vadv = self.advect(forcing, state)
-            U += Uadv
-            V += Vadv
-
-        # --- Diffusion ---
-        if self.diffusion:
-            Udiff, Vdiff = self.diffuse()
-            U += Udiff
-            V += Vdiff
-
-        # --- Move the particles
-
-        # New position, if OK
-        X1 = X + U * dt / dx
-        Y1 = Y + V * dt / dy
-
-        # Do not move out of grid
-        I = ~grid.ingrid(X1, Y1)
-        X1[I] = X[I]
-        Y1[I] = Y[I]
-        # Kill particles trying to move out of the grid
-        state.alive[I] = False
-
-        if self.active_check:
-            # Do not move inactive particles
-            I = state.active < 1
-            X1[I] = X[I]
-            Y1[I] = Y[I]
-
-        # Land, boundary treatment. Do not move the particles
-        # Consider a sequence of different actions
-        # I = (grid.ingrid(X1, Y1)) & (grid.atsea(X1, Y1))
-        I = grid.atsea(X1, Y1)
-        # I = True
-        X[I] = X1[I]
-        Y[I] = Y1[I]
-
-        state.X = X
-        state.Y = Y
-
-    def EF(self, forcing: Forcing, state: State) -> Velocity:
-        """Euler-Forward advection"""
-
-        X, Y, Z = state["X"], state["Y"], state["Z"]
-        # dt = self.dt
-        # pm, pn = grid.sample_metric(X, Y)
-
-        U, V = forcing.velocity(X, Y, Z)
-
-        return U, V
-
-    def RK2a(self, forcing: Forcing, state: State) -> Velocity:
-        """Runge-Kutta second order = Heun scheme"""
-
-        X, Y, Z = state["X"], state["Y"], state["Z"]
-        dt = self.dt
-
-        U, V = forcing.velocity(X, Y, Z)
-        X1 = X + 0.5 * U * dt / self.dx
-        Y1 = Y + 0.5 * V * dt / self.dy
-
-        U, V = forcing.velocity(X1, Y1, Z, tstep=0.5)
-        return U, V
-
-    def RK2b(self, forcing: Forcing, state: State) -> Velocity:
-        """Runge-Kutta second order = Heun scheme
-
-        This version does not sample velocities outside the grid
-        """
-
-        X, Y, Z = state["X"], state["Y"], state["Z"]
-        dt = self.dt
-
-        U, V = forcing.velocity(X, Y, Z)
-        X1 = X + 0.5 * U * dt / self.dx
-        Y1 = Y + 0.5 * V * dt / self.dy
-        X1.clip(self.xmin, self.xmax, out=X1)
-        Y1.clip(self.ymin, self.ymax, out=Y1)
-
-        U, V = forcing.velocity(X1, Y1, Z, tstep=0.5)
-        return U, V
-
-    RK2 = RK2b
-
-    def RK4a(self, forcing: Forcing, state: State) -> Velocity:
-        """Runge-Kutta fourth order advection"""
-
-        X, Y, Z = state["X"], state["Y"], state["Z"]
-        dt = self.dt
-        dx, dy = self.dx, self.dy
-
-        U1, V1 = forcing.velocity(X, Y, Z, tstep=0.0)
-        X1 = X + 0.5 * U1 * dt / dx
-        Y1 = Y + 0.5 * V1 * dt / dy
-
-        U2, V2 = forcing.velocity(X1, Y1, Z, tstep=0.5)
-        X2 = X + 0.5 * U2 * dt / dx
-        Y2 = Y + 0.5 * V2 * dt / dy
-
-        U3, V3 = forcing.velocity(X2, Y2, Z, tstep=0.5)
-        X3 = X + U3 * dt / dx
-        Y3 = Y + V3 * dt / dy
-
-        U4, V4 = forcing.velocity(X3, Y3, Z, tstep=1.0)
-
-        U = (U1 + 2 * U2 + 2 * U3 + U4) / 6.0
-        V = (V1 + 2 * V2 + 2 * V3 + V4) / 6.0
-
-        return U, V
-
-    def RK4b(self, forcing: Forcing, state: State) -> Velocity:
-        """Runge-Kutta fourth order advection
-
-        This version does not sample velocities outside the grid
-
-        """
-
-        X, Y, Z = state["X"], state["Y"], state["Z"]
-        dt = self.dt
-        dx, dy = self.dx, self.dy
-        xmin, xmax, ymin, ymax = self.xmin, self.xmax, self.ymin, self.ymax
-
-        U1, V1 = forcing.velocity(X, Y, Z, tstep=0.0)
-        X1 = X + 0.5 * U1 * dt / dx
-        Y1 = Y + 0.5 * V1 * dt / dy
-        X1.clip(xmin, xmax, out=X1)
-        Y1.clip(ymin, ymax, out=Y1)
-
-        U2, V2 = forcing.velocity(X1, Y1, Z, tstep=0.5)
-        X2 = X + 0.5 * U2 * dt / dx
-        Y2 = Y + 0.5 * V2 * dt / dy
-        X2.clip(xmin, xmax, out=X2)
-        Y2.clip(ymin, ymax, out=Y2)
-
-        U3, V3 = forcing.velocity(X2, Y2, Z, tstep=0.5)
-        X3 = X + U3 * dt / dx
-        Y3 = Y + V3 * dt / dy
-        X3.clip(xmin, xmax, out=X3)
-        Y3.clip(ymin, ymax, out=Y3)
-
-        U4, V4 = forcing.velocity(X3, Y3, Z, tstep=1.0)
-
-        U = (U1 + 2 * U2 + 2 * U3 + U4) / 6.0
-        V = (V1 + 2 * V2 + 2 * V3 + V4) / 6.0
-
-        return U, V
-
-    RK4 = RK4b
-
-    def diffuse(self) -> Velocity:
-        """Random walk diffusion"""
-
-        # Diffusive velocity
-        stddev = (2 * self.D / self.dt) ** 0.5
-        U = stddev * np.random.normal(size=self.num_particles)
-        V = stddev * np.random.normal(size=self.num_particles)
-
-        return U, V