ladim 2.0.4__py3-none-any.whl → 2.0.6__py3-none-any.whl

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

ladim/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.4.dist-info → ladim-2.0.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: ladim
-Version: 2.0.4
+Version: 2.0.6
 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
 ====================================================

ladim-2.0.6.dist-info/RECORD

@@ -0,0 +1,32 @@
+ladim/__init__.py,sha256=aQKGEYwOZyFPYOq2KX1uhUn41APv8PRIaY71yxI3Shg,51
+ladim/__main__.py,sha256=I1AOHBQDwQNe3fVmDMyC84JcriqidOEURoeoJSOCTzg,24
+ladim/config.py,sha256=p6swxS4yF0wHPNxE8psNtRxr4YGyhqnsrBs5kdYkUc0,5698
+ladim/forcing.py,sha256=Wv9VPHTRLr_xgxKyNPINBXNwGTLfUVPRYoMcP9ObeNU,3037
+ladim/grid.py,sha256=aZl8HUrY5oJSUKoVEY40reOfAEjClHuNlpzNO1GJK8k,20897
+ladim/main.py,sha256=jsrJY7G37oCzQQDXLrlzc_I_jM7a1a-vmmQx9cuLRms,2906
+ladim/model.py,sha256=zTGZtpXFsVlhT8OqaGFMteMc_nsCJEv3ENehhzKuG60,4221
+ladim/output.py,sha256=1d7p2f3fP5flsRaMdGgGAMU3FaQJg-0OASBAF_cN1II,8317
+ladim/release.py,sha256=lYpuwVYXHntW1Q-jFjkVbveGl7SSIb-EfsJfEZutbXs,8339
+ladim/sample.py,sha256=n8wRGd_VsW_qyQe1ZoTpmfZcdcwB929vsM8PoKG6JTs,8292
+ladim/solver.py,sha256=vOfVUzuQnAylPvtgdP6Ez7_pQGbYDCIYgYfXIbJJ-6M,765
+ladim/state.py,sha256=RkKZQn1G9SbhdA3CTq4jpiN-8YIv1QXDRgI6RZlI7U0,3436
+ladim/tracker.py,sha256=hSlCKlBRyLVEYP40QIGKub6mDYFOApyGhUypLrrP9w8,4977
+ladim/utilities.py,sha256=r7-zShqJhh0cBctDUmtfw-GBOk1eTTYR4S72b0ouiSQ,994
+ladim/gridforce/ROMS.py,sha256=yjEf6KM-nxSn4Hexr-5YctQ0rqjzxMDeL4mmQe3w7Vk,27788
+ladim/gridforce/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ladim/gridforce/analytical.py,sha256=qI-1LJdjmnwwanzOdrsDZqwGgo73bT75CB7pMaxbHKM,1094
+ladim/gridforce/zROMS.py,sha256=4bnrmcXiWpCAUch9uqd_0XmyKRh-Ll6sFvIHiTbTOOg,23996
+ladim/ibms/__init__.py,sha256=LLKhHJgEu-W6cbFjzg2apc-MPoY9wJF2z7S9W2EeWA0,698
+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.6.dist-info/LICENSE,sha256=BgtXyjNr6Ly9nQ7ZLXKpV3r5kWRLnh5MiN0dxp0Bvfc,1085
+ladim-2.0.6.dist-info/METADATA,sha256=Ijt1Va9KemQDmpaF8cG8EddY9VLftTU847irrlWSn58,1884
+ladim-2.0.6.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
+ladim-2.0.6.dist-info/entry_points.txt,sha256=JDlNJo87GJaOkH0-BpAzTPLCrZcuPSdSlHNQ4XmnoRg,41
+ladim-2.0.6.dist-info/top_level.txt,sha256=TK8Gl7d6MsrAQvqKG4b6YJCbB4UL46Se3SzsI-sJAuc,16
+ladim-2.0.6.dist-info/RECORD,,

{ladim-2.0.4.dist-info → ladim-2.0.6.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.1.0)
+Generator: setuptools (75.8.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

ladim-2.0.4.dist-info/RECORD

@@ -1,32 +0,0 @@
-ladim/__init__.py,sha256=1pOaNTt2-oJQ33nsnZyDsOulYErImxLErxjlfOb8Oyg,51
-ladim/__main__.py,sha256=8f07EMfxQllDZSgpak5ECyYHnfQFy8LaHl2xdC-aO9c,23
-ladim/config.py,sha256=tnTyKDeaDG1M9T5fiUGXG8Ezc_n7Xwm8l6--UpBJhaE,5449
-ladim/forcing.py,sha256=f4PpSwyilSScXeNyorTWLMgVTiat9htSLkCwAkRlJVM,3048
-ladim/grid.py,sha256=m6bQrGJ3cux7rqC8pbRXD86cOI-VQKF-XjP9m1jCIcY,2221
-ladim/main.py,sha256=6_blu3PYnDXaYdPxfZoukWsjN0o9vh7O8_-W2-aguAI,2894
-ladim/model.py,sha256=iXClvieChhipCSZ-dDrmnjqwS4cuM53VpJv7oaJyQ88,3794
-ladim/output.py,sha256=Rz7iujvS7Z3LoABiJduQqyb3zPswNqhhFsywr3MLsBY,8373
-ladim/release.py,sha256=1j__9Gj0BD0CqVCM2KLZhio1Ia-hz1gbUIhTsa0J3Rg,8451
-ladim/sample.py,sha256=n8wRGd_VsW_qyQe1ZoTpmfZcdcwB929vsM8PoKG6JTs,8292
-ladim/solver.py,sha256=sZvYgOxzJ-EItI-IB2y8_z8Tf-SJAQSrmydlhDRa7ZQ,755
-ladim/state.py,sha256=4XNIIx5sGjlqkZ6bg-dGbqzp8ujFNkHHFL2D9qCQA2w,4119
-ladim/tracker.py,sha256=VVX6T5CqiU6nGSCgLlSCC8w0UYhW273OGFE7ApPjdyI,5091
-ladim/utilities.py,sha256=r7-zShqJhh0cBctDUmtfw-GBOk1eTTYR4S72b0ouiSQ,994
-ladim/gridforce/ROMS.py,sha256=DF5CSR2iJsPWAmTOrqYavARVtqokQbtAWLSCDWb_9f0,27525
-ladim/gridforce/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ladim/gridforce/analytical.py,sha256=qI-1LJdjmnwwanzOdrsDZqwGgo73bT75CB7pMaxbHKM,1094
-ladim/gridforce/zROMS.py,sha256=4bnrmcXiWpCAUch9uqd_0XmyKRh-Ll6sFvIHiTbTOOg,23996
-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.4.dist-info/LICENSE,sha256=BgtXyjNr6Ly9nQ7ZLXKpV3r5kWRLnh5MiN0dxp0Bvfc,1085
-ladim-2.0.4.dist-info/METADATA,sha256=9zVlHY1N0c5JKYGu9_ayPTmBVcPnzHaj9i8kJgLRgOU,1841
-ladim-2.0.4.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-ladim-2.0.4.dist-info/entry_points.txt,sha256=JDlNJo87GJaOkH0-BpAzTPLCrZcuPSdSlHNQ4XmnoRg,41
-ladim-2.0.4.dist-info/top_level.txt,sha256=TK8Gl7d6MsrAQvqKG4b6YJCbB4UL46Se3SzsI-sJAuc,16
-ladim-2.0.4.dist-info/RECORD,,