ladim 2.1.5__py3-none-any.whl → 2.1.7__py3-none-any.whl

ladim/__init__.py

@@ -1,3 +1,3 @@
-__version__ = '2.1.5'
+__version__ = '2.1.7'
 
 from .main import main, run

ladim/forcing.py

@@ -1,6 +1,10 @@
 import typing
 if typing.TYPE_CHECKING:
     from ladim.model import Model
+import numexpr
+import string
+import numpy as np
+from numba import njit
 
 
 class Forcing:
@@ -98,3 +102,447 @@ class GridReference:
 
     def __getattr__(self, item):
         return getattr(self.modules.grid.grid, item)
+
+
+def load_netcdf_chunk(url, varname, subset):
+    """
+    Download, unzip and decode a netcdf chunk from file or url
+    """
+    import xarray as xr
+    with xr.open_dataset(url) as dset:
+        values = dset.variables[varname][subset].values
+    if varname in ['u', 'v', 'w']:
+        values = np.nan_to_num(values)
+    return values
+
+
+class ChunkCache:
+    """
+    A cache for storing and sharing chunks of data using shared memory.
+
+    This class manages a memory block divided into a header, index, and data section.
+    It is designed for efficient inter-process communication of chunked data arrays.
+
+    :ivar mem: SharedMemory object representing the memory block.
+    :ivar num_chunks: Number of slots/chunks in the cache (read-only).
+    :ivar chunksize: Size of each chunk (read-only).
+    :ivar datatype: Data type of the stored chunks (read-only).
+    :ivar itemsize: Size in bytes of each data item (read-only).
+    :ivar chunk_id: Array of chunk IDs for tracking which data is stored in each slot.
+    :ivar data: 2D array holding the actual chunked data.
+    """
+    def __init__(self, name: str):
+        """
+        Attach to an existing shared memory block and map the cache structure.
+
+        :param name: The name of the shared memory block to attach to.
+        """
+        from multiprocessing.shared_memory import SharedMemory
+        mem = SharedMemory(name=name, create=False)
+        self.mem = mem
+
+        # Header block
+        self.num_chunks = np.ndarray(shape=(), dtype=np.int64, buffer=mem.buf[0:8])
+        self.chunksize = np.ndarray(shape=(), dtype=np.int64, buffer=mem.buf[8:16])
+        self.datatype = np.ndarray(shape=(), dtype='S8', buffer=mem.buf[16:24])
+        self.itemsize = np.ndarray(shape=(), dtype=np.int64, buffer=mem.buf[24:32])
+        self.num_chunks.setflags(write=False)
+        self.chunksize.setflags(write=False)
+        self.datatype.setflags(write=False)
+        self.itemsize.setflags(write=False)
+
+        # LRU block
+        lru_start = 32
+        lru_stop = lru_start + 2*self.num_chunks
+        self.lru = np.ndarray(
+            shape=(self.num_chunks,),
+            dtype=np.int16,
+            buffer=mem.buf[lru_start:lru_stop])
+
+        # Index block
+        idx_start = lru_stop
+        idx_stop = idx_start + 8*self.num_chunks
+        self.chunk_id = np.ndarray(
+            shape=(self.num_chunks, ),
+            dtype=np.int64,
+            buffer=mem.buf[idx_start:idx_stop])
+        
+        # Data block
+        dat_start = idx_stop
+        dat_stop = dat_start + self.num_chunks * self.chunksize * self.itemsize
+        self.data = np.ndarray(
+            shape=(self.num_chunks, self.chunksize),
+            dtype=self.datatype.item().decode('ascii'),
+            buffer=mem.buf[dat_start:dat_stop])
+
+    def _update_lru(self, slot: int) -> None:
+        """
+        Move the given slot to the front (most recently used) in the LRU table.
+        """
+        update_lru(self.lru, slot)
+
+    def read(self, slot: int) -> np.ndarray:
+        """
+        Read data from the given slot and update the LRU table.
+
+        :param slot: The slot index to read
+        :return: The data in the slot
+        """
+        self._update_lru(slot)
+        return self.data[slot, :]
+
+    def write(self, data: np.ndarray, slot: int) -> None:
+        """
+        Overwrite the data in the given slot and update the LRU table.
+
+        :param data: 1D numpy array of length self.chunksize and dtype self.datatype
+        :param slot: The slot index to overwrite
+        """
+        self._update_lru(slot)
+        self.data[slot, :] = data
+
+    def __enter__(self) -> "ChunkCache":
+        """
+        Enter the runtime context related to this object.
+        Returns self for use in 'with' statements.
+
+        :return: self
+        """
+        return self
+
+    def __exit__(self, type: type, value: Exception, tb: object) -> None:
+        """
+        Exit the runtime context and close the shared memory.
+
+        :param type: Exception type
+        :param value: Exception value
+        :param tb: Traceback object
+        """
+        self.close()
+
+    def __setattr__(self, name: str, value: object) -> None:
+        """
+        Prevent reassignment of attributes after initialization.
+        Raises AttributeError if an attribute is already set.
+
+        :param name: Attribute name
+        :param value: Attribute value
+        :raises AttributeError: If attribute is already set
+        """
+        if hasattr(self, name):
+            raise AttributeError(f"Cannot reassign attribute '{name}'")
+        super().__setattr__(name, value)
+
+    @staticmethod
+    def create(slots: int, chunksize: int, datatype: str = 'f4') -> "ChunkCache":
+        """
+        Create a new shared memory block and initialize a ChunkCache.
+
+        :param slots: Number of slots/chunks in the cache.
+        :param chunksize: Size of each chunk.
+        :param datatype: Numpy dtype string for the data (default 'f4').
+        :return: An instance attached to the new shared memory block.
+        """
+        from multiprocessing.shared_memory import SharedMemory
+
+        test_item = np.empty((), dtype=datatype)
+        str_dtype = str(test_item.dtype)
+        if len(str_dtype) > 8:
+            raise ValueError('Unsupported data type: {str_dtype}')
+        
+        # Reserve memory space for the cache block
+        size_header_block = 32
+        size_lru_block = 2 * slots  # int16
+        size_index_block = 8 * slots
+        size_data_block = slots * chunksize * test_item.itemsize
+        bytes = size_header_block + size_lru_block + size_index_block + size_data_block
+        mem = SharedMemory(create=True, size=bytes)
+
+        # Write some header information
+        mem_slots = np.ndarray(shape=(), dtype=np.int64, buffer=mem.buf[0:8])
+        mem_slots[...] = slots
+        mem_chunksize = np.ndarray(shape=(), dtype=np.int64, buffer=mem.buf[8:16])
+        mem_chunksize[...] = chunksize
+        mem_datatype = np.ndarray(shape=(), dtype='S8', buffer=mem.buf[16:24])
+        mem_datatype[...] = str_dtype
+        mem_itemsize = np.ndarray(shape=(), dtype=np.int64, buffer=mem.buf[24:32])
+        mem_itemsize[...] = test_item.itemsize
+
+        # LRU block
+        lru_start = size_header_block
+        mem_lru = np.ndarray(
+            shape=(slots,),
+            dtype=np.int16,
+            buffer=mem.buf[lru_start:lru_start + size_lru_block])
+        mem_lru[...] = np.arange(slots, dtype=np.int16)
+
+        # Index block
+        index_start = lru_start + size_lru_block
+        mem_chunkid = np.ndarray(
+            shape=(slots, ),
+            dtype=np.int64,
+            buffer=mem.buf[index_start:index_start + size_index_block])
+        mem_chunkid[...] = -1
+        
+        # Data block
+        # (no need to initialize, will be written on use)
+        return ChunkCache(mem.name)
+
+    
+    def close(self) -> None:
+        """
+        Close the shared memory block.
+        """
+        self.mem.close()
+
+    def contains(self, id: int) -> bool:
+        """
+        Check if the cache contains a chunk with the given id.
+
+        :param id: The chunk id to check
+        :return: True if the chunk is in the cache, False otherwise
+        """
+        return indexof(self.chunk_id, id) >= 0
+
+    def push(self, data: np.ndarray, id: int) -> None:
+        """
+        Push a chunk of data into the cache with the given id.
+
+        :param data: 1D numpy array of length self.chunksize and dtype self.datatype
+        :param id: The chunk id to associate with this data
+        :note: If no free slots are available, evict the least recently used slot.
+        """
+        free_slots = np.where(self.chunk_id == -1)[0]
+        if len(free_slots) > 0:
+            slot = free_slots[0]
+        else:
+            # Evict the least recently used slot (last in lru)
+            slot = self.lru[-1]
+        self.write(data, slot)
+        self.chunk_id[slot] = id
+
+    def pull(self, id: int) -> np.ndarray:
+        """
+        Retrieve the data for the given chunk id and update the LRU table.
+
+        :param id: The chunk id to retrieve
+        :return: The data array for the chunk
+        :raises KeyError: If the chunk id is not found in the cache
+        """
+        slot = indexof(self.chunk_id, id)
+        if slot < 0:
+            raise KeyError(f"Chunk id {id} not found in cache")
+        return self.read(slot)
+
+
+def timestring_formatter(pattern, time):
+    """
+    Format a time string
+
+    :param pattern: f-string style formatting pattern
+    :param time: Numpy convertible time specification
+    :returns: A formatted time string
+    """
+    posix_time = np.datetime64(time, 's').astype(int)
+
+    class PosixFormatter(string.Formatter):
+        def get_value(self, key: int | str, args: typing.Sequence[typing.Any], kwargs: typing.Mapping[str, typing.Any]) -> typing.Any:
+            return numexpr.evaluate(
+                key, local_dict=kwargs, global_dict=dict())
+        
+        def format_field(self, value: typing.Any, format_spec: str) -> typing.Any:
+            dt = np.int64(value).astype('datetime64[s]').astype(object)
+            return dt.strftime(format_spec)
+        
+    fmt = PosixFormatter()
+    return fmt.format(pattern, time=posix_time)
+
+
+@njit
+def update_lru(lru: np.ndarray, slot: int) -> None:
+    """
+    Update the LRU (Least Recently Used) list by moving the specified slot to the front.
+
+    :param lru: The LRU array
+    :param slot: The slot index to move to the front
+    """
+    v = slot
+    for i in range(len(lru)):
+        u = lru[i]
+        lru[i] = v
+        if u == slot:
+            break
+        v = u
+
+
+@njit
+def indexof(array: np.ndarray, value: int) -> int:
+    """
+    Find the index of the first occurrence of a value in an array.
+
+    :param array: The input array
+    :param value: The value to find
+    :return: The index of the first occurrence, or -1 if not found
+    """
+    for i in range(len(array)):
+        if array[i] == value:
+            return i
+    return -1
+
+
+@njit(inline="always", fastmath=True)
+def get_chunk_id(i, j, l, size_x, size_y, num_x, num_y):
+    """
+    Calculate the chunk ID based on the indices and sizes.
+
+    We assume that the array is chunked in the x and y dimensions,
+    but not in the z dimension. The t dimension is assumed to be
+    chunked with size_t = 1.
+
+    For instance, if the chunk size is x:10, y:5 and the number of chunks
+    in the x and y dimensions is 6 and 7 respectively, then the chunk
+    ID for the coordinates (31, 14, 0) would be calculated as follows:
+        
+        chunk id in x direction: 31 // 10 = 3
+        chunk id in y direction: 14 // 5 = 2
+        chunk id in t direction: 0 // 1 = 0
+        chunk id = 3 + 6*2 + 6*7*0 = 15
+    
+    This means that the chunk ID is a unique identifier for the chunk
+    containing the coordinates (31, 14, 0) in the array.
+
+    :param i: Integer x coordinate (global index)
+    :param j: Integer y coordinate (global index)
+    :param l: Integer t coordinate (global index)
+    :param size_x: Chunk size in x dimension
+    :param size_y: Chunk size in y dimension
+    :param num_x: Number of chunks in x dimension
+    :param num_y: Number of chunks in y dimension
+    :return: Chunk ID
+    """
+
+    # The global index is divided by the chunk size to get the chunk ID
+    # for each dimension. The chunk ID is then combined into a single
+    # integer value.
+    return (i // size_x) + num_x * ((j // size_y) + num_y * l)
+
+
+@njit(inline="always", fastmath=True)
+def interp_xyzt(x, y, z, t, v, ncx, ncy, ncz, nct, cache, ids):
+    """
+    Interpolate the data in the x, y, z, and t dimensions.
+    
+    :param x: x coordinate (global index)
+    :param y: y coordinate (global index)
+    :param z: z coordinate (global index)
+    :param t: t coordinate (global index)
+    :param v: v coordinate (global index)
+    :param ncx: Number of chunks in x dimension
+    :param ncy: Number of chunks in y dimension
+    :param ncz: Number of chunks in z dimension
+    :param nct: Number of chunks in t dimension
+    :param cache: Chunk cache array
+    :param ids: Array of chunk ids for each slot in the cache
+    :return: Interpolated value
+    """
+    _, _, st, sz, sy, sx = cache.shape
+    
+    max_x = ncx * sx
+    max_y = ncy * sy
+    max_z = ncz * sz
+    max_t = nct * st    
+
+    i0 = max(0, min(max_x - 2, np.int32(x)))
+    j0 = max(0, min(max_y - 2, np.int32(y)))
+    k0 = max(0, min(max_z - 2, np.int32(z)))
+    l0 = max(0, min(max_t - 2, np.int32(t)))
+
+    i1 = i0 + 1
+    j1 = j0 + 1
+    k1 = k0 + 1
+    l1 = l0 + 1
+
+    # Chunk ID (chid) for the surrounding points
+    chid0000 = get_chunk_id(i0, j0, l0, sx, sy, ncx, ncy)
+    chid0001 = get_chunk_id(i1, j0, l0, sx, sy, ncx, ncy)
+    chid0010 = get_chunk_id(i0, j1, l0, sx, sy, ncx, ncy)
+    chid0011 = get_chunk_id(i1, j1, l0, sx, sy, ncx, ncy)
+    chid1000 = get_chunk_id(i0, j0, l1, sx, sy, ncx, ncy)
+    chid1001 = get_chunk_id(i1, j0, l1, sx, sy, ncx, ncy)
+    chid1010 = get_chunk_id(i0, j1, l1, sx, sy, ncx, ncy)
+    chid1011 = get_chunk_id(i1, j1, l1, sx, sy, ncx, ncy)
+
+    # Memory offset into cache for each chunk
+    slot0000 = indexof(ids, chid0000)
+    slot0001 = indexof(ids, chid0001)
+    slot0010 = indexof(ids, chid0010)
+    slot0011 = indexof(ids, chid0011)
+    slot1000 = indexof(ids, chid1000)
+    slot1001 = indexof(ids, chid1001)
+    slot1010 = indexof(ids, chid1010)
+    slot1011 = indexof(ids, chid1011)
+
+    # Return nan if any of the slots are not found
+    if (slot0000 < 0 or slot0001 < 0 or slot0010 < 0 or slot0011 < 0 or
+        slot1000 < 0 or slot1001 < 0 or slot1010 < 0 or slot1011 < 0):
+        return np.nan
+
+    # Within-chunk indices
+    ii0 = i0 % sx
+    ii1 = i1 % sx
+    jj0 = j0 % sy
+    jj1 = j1 % sy
+    kk0 = k0 % sz
+    kk1 = k1 % sz
+    ll0 = l0 % st
+    ll1 = l1 % st
+
+    # Memory extraction
+    u0000 = cache[slot0000, v, ll0, kk0, jj0, ii0]
+    u0001 = cache[slot0001, v, ll0, kk0, jj0, ii1]
+    u0010 = cache[slot0010, v, ll0, kk1, jj0, ii0]
+    u0011 = cache[slot0011, v, ll0, kk1, jj0, ii1]
+    u0100 = cache[slot0000, v, ll1, kk0, jj1, ii0]
+    u0101 = cache[slot0001, v, ll1, kk0, jj1, ii1]
+    u0110 = cache[slot0010, v, ll1, kk1, jj1, ii0]
+    u0111 = cache[slot0011, v, ll1, kk1, jj1, ii1]
+    u1000 = cache[slot1000, v, ll0, kk0, jj0, ii0]
+    u1001 = cache[slot1001, v, ll0, kk0, jj0, ii1]
+    u1010 = cache[slot1010, v, ll0, kk1, jj0, ii0]
+    u1011 = cache[slot1011, v, ll0, kk1, jj0, ii1]
+    u1100 = cache[slot1000, v, ll1, kk0, jj1, ii0]
+    u1101 = cache[slot1001, v, ll1, kk0, jj1, ii1]
+    u1110 = cache[slot1010, v, ll1, kk1, jj1, ii0]
+    u1111 = cache[slot1011, v, ll1, kk1, jj1, ii1]
+
+    # Interpolation weights
+    # The weights are calculated as the distance from the lower bound
+    p = x - i0
+    q = y - j0
+    r = z - k0
+    s = t - l0
+
+    w0000 = (1 - s) * (1 - r) * (1 - q) * (1 - p)
+    w0001 = (1 - s) * (1 - r) * (1 - q) * p
+    w0010 = (1 - s) * (1 - r) * q * (1 - p)
+    w0011 = (1 - s) * (1 - r) * q * p
+    w0100 = (1 - s) * r * (1 - q) * (1 - p)
+    w0101 = (1 - s) * r * (1 - q) * p
+    w0110 = (1 - s) * r * q * (1 - p)
+    w0111 = (1 - s) * r * q * p
+    w1000 = s * (1 - r) * (1 - q) * (1 - p)
+    w1001 = s * (1 - r) * (1 - q) * p
+    w1010 = s * (1 - r) * q * (1 - p)
+    w1011 = s * (1 - r) * q * p
+    w1100 = s * r * (1 - q) * (1 - p)
+    w1101 = s * r * (1 - q) * p
+    w1110 = s * r * q * (1 - p)
+    w1111 = s * r * q * p    
+    
+    # Interpolation
+    result = (w0000 * u0000 + w0001 * u0001 + w0010 * u0010 + w0011 * u0011 +
+              w0100 * u0100 + w0101 * u0101 + w0110 * u0110 + w0111 * u0111 +
+              w1000 * u1000 + w1001 * u1001 + w1010 * u1010 + w1011 * u1011 +
+              w1100 * u1100 + w1101 * u1101 + w1110 * u1110 + w1111 * u1111)
+
+    return result

ladim/state.py

@@ -1,4 +1,3 @@
-import pandas as pd
 import numpy as np
 
 
@@ -14,14 +13,17 @@ class State:
     def __init__(self):
         self._num_released = 0
         self._varnames = set()
-        self._data = pd.DataFrame()
+        self._data = dict()  # type: dict[str, np.ndarray]
 
     @property
     def size(self):
         """
         Current number of particles
         """
-        return len(self._data)
+        keys = list(self._data.keys())
+        if len(keys) == 0:
+            return 0
+        return len(self._data[keys[0]])
 
     @property
     def released(self):
@@ -42,23 +44,35 @@ class State:
         if not particles:
             return
 
-        num_new_particles = next(len(v) for v in particles.values())
-        particles['pid'] = np.arange(num_new_particles) + self._num_released
-        particles['alive'] = np.ones(num_new_particles, dtype=bool)
-        if 'active' in particles:
-            particles['active'] = np.array(particles['active'], dtype=bool)
+        # Check that input has correct format
+        num_new = next(len(v) for v in particles.values())
+        fields = {}  # type: dict[str, np.ndarray]
+        for k, v in particles.items():
+            fields[k] = np.asarray(v)
+            if not np.shape(fields[k]) == (num_new, ):
+                raise ValueError('Unequal number of array elements in input')
+
+        # Add standard variables
+        fields['pid'] = np.arange(num_new) + self._num_released
+        fields['alive'] = np.ones(num_new, dtype=bool)
+        if 'active' in fields:
+            fields['active'] = np.array(fields['active'], dtype=bool)
         else:
-            particles['active'] = np.ones(num_new_particles, dtype=bool)
-
-        new_particles = pd.DataFrame(data=particles)
-        self._data = pd.concat(
-            objs=[self._data, new_particles],
-            axis='index',
-            ignore_index=True,
-            join='outer',
-        )
-
-        self._num_released += num_new_particles
+            fields['active'] = np.ones(num_new, dtype=bool)
+
+        # Concatenate old and new particles
+        newdata = {}  # type: dict[str, np.ndarray]
+        num_old = self.size
+        for k, v_new in fields.items():
+            if k in self._data:
+                v_old = self._data[k]
+            else:
+                v_old = np.zeros(num_old, dtype=v_new.dtype)
+            
+            newdata[k] = np.concatenate([v_old, v_new], dtype=v_old.dtype)
+
+        self._data = newdata
+        self._num_released += num_new
 
     def remove(self, particles):
         """
@@ -71,13 +85,16 @@ class State:
             return
 
         keep = ~particles
-        self._data = self._data.iloc[keep]
+        for k in self._data.keys():
+            self._data[k] = self._data[k][keep]
 
     def __getitem__(self, item):
-        return self._data[item].values
+        return self._data[item]
 
     def __setitem__(self, item, value):
-        self._data[item] = value
+        v = np.asarray(value)
+        assert v.shape == (self.size, )
+        self._data[item] = v
 
     def __len__(self):
         return self.size

{ladim-2.1.5.dist-info → ladim-2.1.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ladim
-Version: 2.1.5
+Version: 2.1.7
 Summary: Lagrangian Advection and Diffusion Model
 Home-page: https://github.com/pnsaevik/ladim
 Author: Bjørn Ådlandsvik
@@ -18,6 +18,8 @@ Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: netCDF4
+Requires-Dist: numba
+Requires-Dist: numexpr
 Requires-Dist: numpy
 Requires-Dist: pandas
 Requires-Dist: pyarrow

{ladim-2.1.5.dist-info → ladim-2.1.7.dist-info}/RECORD

@@ -1,7 +1,7 @@
-ladim/__init__.py,sha256=deBjPlj3Ebki-_8oKDrAdITyzOn-VF38BpeUAPOTJUg,51
+ladim/__init__.py,sha256=RcAneNkq971JmIjd87hY3EyxPQJdcGxn4iPnOD5VZ64,51
 ladim/__main__.py,sha256=I1AOHBQDwQNe3fVmDMyC84JcriqidOEURoeoJSOCTzg,24
 ladim/config.py,sha256=A-yLStNqqDwh_wMCIsmd8cmaXuUvz698IMlYvGZT5tE,5710
-ladim/forcing.py,sha256=Dy0kvhax0YTvyAMnPJUHAJItkZdZfY1mrVY4fT8A21M,3214
+ladim/forcing.py,sha256=DgBi2qEH5etOHTL3fWbPjjUvnLPDU50tknHWdWaNqeI,19061
 ladim/grid.py,sha256=WAfvYYLiiiO8MnMkqCqKSSrVpyooymffqFWTWfF9qLM,20945
 ladim/main.py,sha256=jsrJY7G37oCzQQDXLrlzc_I_jM7a1a-vmmQx9cuLRms,2906
 ladim/model.py,sha256=fJNjCoK4FL45KAEUQUksRgKinehsiZre0RfKYgog-3k,2377
@@ -9,7 +9,7 @@ ladim/output.py,sha256=AlP3_FGKU_bmSLRyiR3cbbNCwMVkYcuwOjoy0397-CI,8307
 ladim/release.py,sha256=P9KnZminvFPMfAJPizo72d6z8-X5ttM9Qw9p_yPtfpQ,13150
 ladim/sample.py,sha256=n8wRGd_VsW_qyQe1ZoTpmfZcdcwB929vsM8PoKG6JTs,8292
 ladim/solver.py,sha256=bfpb2z5ZU0k8eoFWliMMbafYddL7-AfoTvNONO43apo,785
-ladim/state.py,sha256=xDP3DfuG7NZyYOkFr-KUotrbwPIGUVHhqy9Gisl-85Q,2872
+ladim/state.py,sha256=tHMn4eB2XJ3Ua-uqaKQY_UR56ErDapSbqdY2bd-040g,3550
 ladim/tracker.py,sha256=Dpf26jAyu1xAuySRsv3-sOCXJhY3sDvmzUiUyMRUYqU,5118
 ladim/utilities.py,sha256=a3ZK3OuJRfzjEDAfASsuEKItyWC-4GsGUWKEZp1hg0E,1790
 ladim/gridforce/ROMS.py,sha256=VzvKXyyYSdQayCszTZQOh36aXyTaCJ7rxOhGDRjbPhE,27796
@@ -19,14 +19,14 @@ ladim/gridforce/zROMS.py,sha256=4bnrmcXiWpCAUch9uqd_0XmyKRh-Ll6sFvIHiTbTOOg,2399
 ladim/ibms/__init__.py,sha256=YUbvHnFXfSJ0lTl6elc-ajyIh1LDqWYlX7Q_MHuNce4,939
 ladim/ibms/light.py,sha256=POltHmKkX8-q3t9wXyfcseCKEq9Bq-kX1WEJYsr1lNQ,2737
 ladim/plugins/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ladim-2.1.5.dist-info/licenses/LICENSE,sha256=BgtXyjNr6Ly9nQ7ZLXKpV3r5kWRLnh5MiN0dxp0Bvfc,1085
+ladim-2.1.7.dist-info/licenses/LICENSE,sha256=BgtXyjNr6Ly9nQ7ZLXKpV3r5kWRLnh5MiN0dxp0Bvfc,1085
 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.1.5.dist-info/METADATA,sha256=QxS46RvOa3FGYSgK74fjgEUlUxokvWzNZWqDihhtFHk,1906
-ladim-2.1.5.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-ladim-2.1.5.dist-info/entry_points.txt,sha256=JDlNJo87GJaOkH0-BpAzTPLCrZcuPSdSlHNQ4XmnoRg,41
-ladim-2.1.5.dist-info/top_level.txt,sha256=TK8Gl7d6MsrAQvqKG4b6YJCbB4UL46Se3SzsI-sJAuc,16
-ladim-2.1.5.dist-info/RECORD,,
+ladim-2.1.7.dist-info/METADATA,sha256=KGCwnDdl7vI0f4q5h5PrrgYVO68gufex-6t9X_wJocc,1950
+ladim-2.1.7.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+ladim-2.1.7.dist-info/entry_points.txt,sha256=JDlNJo87GJaOkH0-BpAzTPLCrZcuPSdSlHNQ4XmnoRg,41
+ladim-2.1.7.dist-info/top_level.txt,sha256=TK8Gl7d6MsrAQvqKG4b6YJCbB4UL46Se3SzsI-sJAuc,16
+ladim-2.1.7.dist-info/RECORD,,

{ladim-2.1.5.dist-info → ladim-2.1.7.dist-info}/WHEEL

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