ladim 2.0.5__py3-none-any.whl → 2.0.7__py3-none-any.whl

ladim/gridforce/ROMS.py

@@ -251,10 +251,11 @@ class Forcing:
 
     """
 
-    def __init__(self, config, grid):
+    def __init__(self, config, _):
 
         logger.info("Initiating forcing")
 
+        grid = Grid(config)
         self._grid = grid  # Get the grid object, make private?
         # self.config = config["gridforce"]
         self.ibm_forcing = config["ibm_forcing"]
@@ -292,7 +293,12 @@ class Forcing:
         # --------------
         # prestep = last forcing step < 0
         #
+        self.has_been_initialized = False
+        self.steps = steps
+        self._files = files
 
+    def _remaining_initialization(self):
+        steps = self.steps
         V = [step for step in steps if step < 0]
         if V:  # Forcing available before start time
             prestep = max(V)
@@ -335,9 +341,7 @@ class Forcing:
         else:
             # No forcing at start, should already be excluded
             raise SystemExit(3)
-
-        self.steps = steps
-        self._files = files
+        self.has_been_initialized = True
 
     # ===================================================
     @staticmethod
@@ -435,6 +439,9 @@ class Forcing:
     def update(self, t):
         """Update the fields to time step t"""
 
+        if not self.has_been_initialized:
+            self._remaining_initialization()
+
         # Read from config?
         interpolate_velocity_in_time = True
         interpolate_ibm_forcing_in_time = False

ladim/ibms/__init__.py

@@ -1,21 +1,26 @@
 from ..model import Model, Module
+import numpy as np
 
 
 class IBM(Module):
-    def __init__(self, model: Model):
-        super().__init__(model)
+    pass
 
 
 class LegacyIBM(IBM):
-    def __init__(self, model: Model, legacy_module, conf):
-        super().__init__(model)
-
+    def __init__(self, legacy_module, conf):
         from ..model import load_class
         LegacyIbmClass = load_class(legacy_module + '.IBM')
         self._ibm = LegacyIbmClass(conf)
 
-    def update(self):
-        grid = self.model['grid']
-        state = self.model['state']
-        forcing = self.model['forcing']
+    def update(self, model: Model):
+        grid = model.grid
+        state = model.state
+
+        state.dt = model.solver.step
+        state.timestamp = np.int64(model.solver.time).astype('datetime64[s]')
+        state.timestep = (
+                (model.solver.time - model.solver.start) // model.solver.step
+        )
+
+        forcing = model.forcing
         self._ibm.update_ibm(grid, state, forcing)

ladim/main.py

@@ -29,7 +29,7 @@ def main(config_stream, loglevel=logging.INFO):
     # Read configuration
     config = configure(config_stream)
 
-    model = Model(config)
+    model = Model.from_config(config)
     model.run()
     model.close()
 

ladim/model.py

@@ -27,74 +27,72 @@ DEFAULT_MODULES = dict(
 
 
 class Model:
-    def __init__(self, config):
+    """
+    The Model class represents the entire simulation model. The different
+    submodules control the simulation behaviour. In particular, the solver
+    submodule controls the execution flow while the other submodules are
+    called once every time step within the main simulation loop.
+    """
+
+    def __init__(
+            self, grid: "Grid", forcing: "Forcing", release: "Releaser",
+            state: "State", output: "Output", ibm: "IBM", tracker: "Tracker",
+            solver: "Solver",
+    ):
+        self.grid = grid
+        self.forcing = forcing
+        self.release = release
+        self.state = state
+        self.output = output
+        self.ibm = ibm
+        self.tracker = tracker
+        self.solver = solver
+
+    @staticmethod
+    def from_config(config: dict) -> "Model":
+        """
+        Initialize a model class by supplying the configuration parameters
+        of each submodule.
+
+        :param config: Configuration parameters for each submodule
+        :return: An initialized Model class
+        """
+
+        # Create new version of the config dict without the 'model' keyword
+        def remove_module_key(d: dict):
+            return {k: v for k, v in d.items() if k != 'module'}
+
+        # Initialize modules
         module_names = (
             'grid', 'forcing', 'release', 'state', 'output', 'ibm', 'tracker',
             'solver',
         )
-
-        self.modules = dict()
+        modules = dict()
         for name in module_names:
-            self.add_module(name, config.get(name, dict()))
-
-    def add_module(self, name, conf):
-        module_name = conf.get('module', DEFAULT_MODULES[name])
-        conf_without_module = {
-            k: v for k, v in conf.items()
-            if k != 'module'
-        }
-
-        cls = load_class(module_name)
-        self.modules[name] = cls(self, **conf_without_module)
-
-    @property
-    def grid(self) -> "Grid":
-        # noinspection PyTypeChecker
-        return self.modules.get('grid', None)
-
-    @property
-    def forcing(self) -> "Forcing":
-        # noinspection PyTypeChecker
-        return self.modules.get('forcing', None)
-
-    @property
-    def release(self) -> "Releaser":
-        # noinspection PyTypeChecker
-        return self.modules.get('release', None)
+            subconf = config.get(name, dict())
+            modules[name] = Module.from_config(
+                conf=remove_module_key(subconf),
+                module=subconf.get('module', DEFAULT_MODULES[name]),
+            )
 
-    @property
-    def state(self) -> "State":
-        # noinspection PyTypeChecker
-        return self.modules.get('state', None)
-
-    @property
-    def output(self) -> "Output":
-        # noinspection PyTypeChecker
-        return self.modules.get('output', None)
+        # Initialize model
+        return Model(**modules)
 
     @property
-    def ibm(self) -> "IBM":
-        # noinspection PyTypeChecker
-        return self.modules.get('ibm', None)
-
-    @property
-    def tracker(self) -> "Tracker":
-        # noinspection PyTypeChecker
-        return self.modules.get('tracker', None)
-
-    @property
-    def solver(self) -> "Solver":
-        # noinspection PyTypeChecker
-        return self.modules.get('solver', None)
-
-    def __getitem__(self, item):
-        return self.modules[item]
-
-    def __contains__(self, item):
-        return item in self.modules
+    def modules(self) -> dict:
+        return dict(
+            grid=self.grid,
+            forcing=self.forcing,
+            release=self.release,
+            state=self.state,
+            output=self.output,
+            ibm=self.ibm,
+            tracker=self.tracker,
+            solver=self.solver,
+        )
 
     def run(self):
-        self.solver.run()
+        self.solver.run(self)
 
     def close(self):
         for m in self.modules.values():
@@ -127,18 +125,19 @@ def load_class(name):
 
 
 class Module:
-    def __init__(self, model: Model):
-        self._model = model
-
-    @property
-    def model(self) -> Model:
-        return self._model
-
-    @model.setter
-    def model(self, value: Model):
-        self._model = value
-
-    def update(self):
+    @staticmethod
+    def from_config(conf: dict, module: str) -> "Module":
+        """
+        Initialize a module using a configuration dict.
+
+        :param conf: The configuration parameters of the module
+        :param module: The fully qualified name of the module
+        :return: An initialized module
+        """
+        cls = load_class(module)
+        return cls(**conf)
+
+    def update(self, model: Model):
         pass
 
     def close(self):

ladim/output.py

@@ -4,16 +4,14 @@ import numpy as np
 
 
 class Output(Module):
-    def __init__(self, model: Model):
-        super().__init__(model)
+    pass
 
 
 class RaggedOutput(Output):
-    def __init__(self, model: Model, variables: dict, file: str, frequency):
+    def __init__(self, variables: dict, file: str, frequency):
         """
         Writes simulation output to netCDF file in ragged array format
 
-        :param model: Parent model
         :param variables: Simulation variables to include in output, and their formatting
         :param file: Name of output file, or empty if a diskless dataset is desired
         :param frequency: Output frequency in seconds. Alternatively, as a two-element
@@ -21,8 +19,6 @@ class RaggedOutput(Output):
         unit.
 
         """
-        super().__init__(model)
-
         # Convert output format specification from ladim.yaml config to OutputFormat
         self._formats = {
             k: OutputFormat.from_ladim_conf(v)
@@ -47,7 +43,7 @@ class RaggedOutput(Output):
             freq_unit = 's'
         self._write_frequency = np.timedelta64(freq_num, freq_unit).astype('timedelta64[s]').astype('int64')
 
-        self._dset = None
+        self._dset = None  # type: nc.Dataset | None
         self._num_writes = 0
         self._last_write_time = np.int64(-4611686018427387904)
 
@@ -56,47 +52,48 @@ class RaggedOutput(Output):
         """Returns a handle to the netCDF dataset currently being written to"""
         return self._dset
 
-    def update(self):
+    def update(self, model: Model):
         if self._dset is None:
             self._create_dset()
 
-        self._write_init_vars()
-        self._write_instance_vars()
+        self._write_init_vars(model)
+        self._write_instance_vars(model)
 
-    def _write_init_vars(self):
+    def _write_init_vars(self, model):
         """
         Write the initial state of new particles
         """
 
         # Check if there are any new particles
         part_size = self._dset.dimensions['particle'].size
-        num_new = self.model.state.released - part_size
+        num_new = model.state.released - part_size
         if num_new == 0:
             return
 
         # Write variable data
-        idx = self.model.state['pid'] > part_size - 1
-        pid = self.model.state['pid'][idx]
+        idx = model.state['pid'] > part_size - 1
+        pid = model.state['pid'][idx]
         for v in set(self._init_vars) - {'release_time'}:
             # The idx array is not necessarily monotonically increasing by 1
             # all the way. We therefore copy the data into a temporary,
             # continuous array.
-            data_raw = self.model.state[v][idx]
+            data_raw = model.state[v][idx]
             data = np.zeros(num_new, dtype=data_raw.dtype)
             data[pid - part_size] = data_raw
             self._dset.variables[v][part_size:part_size + num_new] = data
 
         # Write release time variable
-        data = np.broadcast_to(self.model.solver.time, shape=(num_new, ))
+        data = np.broadcast_to(model.solver.time, shape=(num_new, ))
         self._dset.variables['release_time'][part_size:part_size + num_new] = data
+        self._dset.sync()
 
-    def _write_instance_vars(self):
+    def _write_instance_vars(self, model):
         """
         Write the current state of dynamic varaibles
         """
 
         # Check if this is a write time step
-        current_time = self.model.solver.time
+        current_time = model.solver.time
         elapsed_since_last_write = current_time - self._last_write_time
         if elapsed_since_last_write < self._write_frequency:
             return
@@ -109,16 +106,17 @@ class RaggedOutput(Output):
 
         # Write variable values
         inst_size = self._dset.dimensions['particle_instance'].size
-        inst_num = self.model.state.size
-        inst_vars = {k: self.model.state[k] for k in set(self._inst_vars) - {'lat', 'lon'}}
+        inst_num = model.state.size
+        inst_vars = {k: model.state[k] for k in set(self._inst_vars) - {'lat', 'lon'}}
         if {'lat', 'lon'}.intersection(self._inst_vars):
-            x, y = self.model.state['X'], self.model.state['Y']
-            inst_vars['lon'], inst_vars['lat'] = self.model.grid.xy2ll(x, y)
+            x, y = model.state['X'], model.state['Y']
+            inst_vars['lon'], inst_vars['lat'] = model.grid.xy2ll(x, y)
         for name, data in inst_vars.items():
             self._dset.variables[name][inst_size:inst_size + inst_num] = data
 
         # Write particle count
         self._dset.variables['particle_count'][time_size] = inst_num
+        self._dset.sync()
 
     def _create_dset(self):
         default_formats = dict(
@@ -161,6 +159,7 @@ class RaggedOutput(Output):
         )
 
         self._dset.variables['instance_offset'][:] = 0
+        self._dset.sync()
 
     def close(self):
         if self._dset is not None:

ladim/release.py

@@ -11,13 +11,12 @@ logger = logging.getLogger(__name__)
 
 
 class Releaser(Module):
-    def __init__(self, model: Model):
-        super().__init__(model)
+    pass
 
 
 class TextFileReleaser(Releaser):
     def __init__(
-            self, model: Model, file, colnames: list = None, formats: dict = None,
+            self, file, colnames: list = None, formats: dict = None,
             frequency=(0, 's'), defaults=None,
     ):
         """
@@ -25,7 +24,6 @@ class TextFileReleaser(Releaser):
 
         The text file must be a whitespace-separated csv file
 
-        :param model: Parent model
         :param file: Release file
 
         :param colnames: Column names, if the release file does not contain any
@@ -44,8 +42,6 @@ class TextFileReleaser(Releaser):
             release.
         """
 
-        super().__init__(model)
-
         # Release file
         self._csv_fname = file   # Path name
         self._csv_column_names = colnames   # Column headers
@@ -60,30 +56,31 @@ class TextFileReleaser(Releaser):
         # Other parameters
         self._defaults = defaults or dict()
 
-    def update(self):
-        self._add_new()
-        self._kill_old()
+    def update(self, model: Model):
+        self._add_new(model)
+        self._kill_old(model)
 
-    def _kill_old(self):
-        state = self.model.state
+    # noinspection PyMethodMayBeStatic
+    def _kill_old(self, model: Model):
+        state = model.state
         if 'alive' in state:
             alive = state['alive']
-            alive &= self.model.grid.ingrid(state['X'], state['Y'])
+            alive &= model.grid.ingrid(state['X'], state['Y'])
             state.remove(~alive)
 
-    def _add_new(self):
+    def _add_new(self, model: Model):
         # Get the portion of the release dataset that corresponds to
         # current simulation time
         df = release_data_subset(
             dataframe=self.dataframe,
-            start_time=self.model.solver.time,
-            stop_time=self.model.solver.time + self.model.solver.step,
+            start_time=model.solver.time,
+            stop_time=model.solver.time + model.solver.step,
         ).copy(deep=True)
 
         # If there are no new particles, but the state is empty, we should
         # still initialize the state by adding the appropriate columns
-        if (len(df) == 0) and ('X' not in self.model.state):
-            self.model.state.append(df.to_dict(orient='list'))
+        if (len(df) == 0) and ('X' not in model.state):
+            model.state.append(df.to_dict(orient='list'))
             self._last_release_dataframe = df
 
         # If there are no new particles and we don't use continuous release,
@@ -94,14 +91,14 @@ class TextFileReleaser(Releaser):
 
         # If we have continuous release, but there are no new particles and
         # the last release is recent, we are also done
-        current_time = self.model.solver.time
+        current_time = model.solver.time
         elapsed_since_last_write = current_time - self._last_release_time
         last_release_is_recent = (elapsed_since_last_write < self._frequency)
         if continuous_release and (len(df) == 0) and last_release_is_recent:
             return
 
         # If we are at the final time step, we should not release any more particles
-        if continuous_release and self.model.solver.time >= self.model.solver.stop:
+        if continuous_release and model.solver.time >= model.solver.stop:
             return
 
         # If we have continuous release, but there are no new particles and
@@ -119,7 +116,7 @@ class TextFileReleaser(Releaser):
                 logger.critical("Particle release must have position")
                 raise ValueError()
             # else
-            X, Y = self.model.grid.ll2xy(df["lon"].values, df["lat"].values)
+            X, Y = model.grid.ll2xy(df["lon"].values, df["lat"].values)
             df.rename(columns=dict(lon="X", lat="Y"), inplace=True)
             df["X"] = X
             df["Y"] = Y
@@ -136,7 +133,7 @@ class TextFileReleaser(Releaser):
 
         # Add new particles
         new_particles = df.to_dict(orient='list')
-        state = self.model.state
+        state = model.state
         state.append(new_particles)
 
     @property

ladim/solver.py

@@ -2,9 +2,8 @@ import numpy as np
 
 
 class Solver:
-    def __init__(self, modules, start, stop, step, order=None, seed=None):
+    def __init__(self, start, stop, step, order=None, seed=None):
         self.order = order or ('release', 'forcing', 'tracker', 'ibm', 'output')
-        self.modules = modules
         self.start = np.datetime64(start, 's').astype('int64')
         self.stop = np.datetime64(stop, 's').astype('int64')
         self.step = np.timedelta64(step, 's').astype('int64')
@@ -13,11 +12,12 @@ class Solver:
         if seed is not None:
             np.random.seed(seed)
 
-    def run(self):
-        modules = [self.modules[k] for k in self.order if k in self.modules]
+    def run(self, model):
+        modules = model.modules
+        ordered_modules = [modules[k] for k in self.order if k in modules]
 
         self.time = self.start
         while self.time <= self.stop:
-            for m in modules:
-                m.update()
+            for m in ordered_modules:
+                m.update(model)
             self.time += self.step

ladim/state.py

@@ -4,19 +4,13 @@ from .model import Model, Module
 
 
 class State(Module):
-    def __init__(self, model: Model):
-        """
-        The state module contains static and dynamic particle properties
-
-        The other modules interact with the state module mostly through
-        the getitem and setitem methods. For instance, to increase the
-        depth of all particles by 1, use
-
-        >>> model.state['Z'] += 1
+    """
+    The state module contains static and dynamic particle properties
 
-        :param model: Parent model
-        """
-        super().__init__(model)
+    The other modules interact with the state module mostly through
+    the getitem and setitem methods. For instance, to increase the
+    depth of all particles by 1, use state['Z'] += 1
+    """
 
     @property
     def size(self):
@@ -65,12 +59,9 @@ class State(Module):
 
 
 class DynamicState(State):
-    def __init__(self, model: Model):
-        super().__init__(model)
-
+    def __init__(self):
         self._num_released = 0
         self._varnames = set()
-
         self._data = pd.DataFrame()
 
     @property
@@ -123,7 +114,11 @@ class DynamicState(State):
         return self[item]
 
     def __setattr__(self, item, value):
-        if item in list(self.__dict__.keys()) + ['_data', '_model', '_num_released', '_varnames']:
+        excepted_values = [
+            '_data', '_model', '_num_released', '_varnames', 'dt', 'timestep',
+            'timestamp'
+        ]
+        if item in list(self.__dict__.keys()) + excepted_values:
             super().__setattr__(item, value)
         elif item in self._data:
             self._data[item] = value
@@ -132,19 +127,3 @@ class DynamicState(State):
 
     def __contains__(self, item):
         return item in self._data
-
-    @property
-    def dt(self):
-        """Backwards-compatibility function for returning model.solver.step"""
-        return self.model.solver.step
-
-    @property
-    def timestamp(self):
-        """Backwards-compatibility function for returning solver time as numpy datetime"""
-        return np.int64(self.model.solver.time).astype('datetime64[s]')
-
-    @property
-    def timestep(self):
-        """Backwards-compatibility function for returning solver time as timestep"""
-        elapsed = self.model.solver.time - self.model.solver.start
-        return elapsed // self.model.solver.step

ladim/tracker.py

@@ -3,28 +3,25 @@ import numpy as np
 
 
 class Tracker(Module):
-    def __init__(self, model: Model):
-        super().__init__(model)
+    pass
 
 
 class HorizontalTracker:
     """The physical particle tracking kernel"""
 
-    def __init__(self, model: Model, method, diffusion) -> None:
-        self.model = model
-
+    def __init__(self, method, diffusion) -> None:
         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
+    def update(self, model: Model):
+        state = model.state
+        grid = model.grid
+        forcing = model.forcing
 
-        t0 = self.model.solver.time
-        dt = self.model.solver.step
+        t0 = model.solver.time
+        dt = model.solver.step
 
         act = state['active']
         X, Y, Z = state['X'][act], state['Y'][act], state['Z'][act]

{ladim-2.0.5.dist-info → ladim-2.0.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: ladim
-Version: 2.0.5
+Version: 2.0.7
 Summary: Lagrangian Advection and Diffusion Model
 Home-page: https://github.com/pnsaevik/ladim
 Author: Bjørn Ådlandsvik
@@ -17,12 +17,14 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: numpy
-Requires-Dist: pyyaml
 Requires-Dist: netCDF4
+Requires-Dist: numpy
 Requires-Dist: pandas
-Requires-Dist: xarray
 Requires-Dist: pyarrow
+Requires-Dist: pyproj
+Requires-Dist: pyyaml
+Requires-Dist: scipy
+Requires-Dist: xarray
 
 LADiM – the Lagrangian Advection and Diffusion Model
 ====================================================