blobmodel 1.2.2__tar.gz → 2.0.0__tar.gz

blobmodel-2.0.0/.github/workflows/workflow.yml

@@ -0,0 +1,46 @@
+name: Tests
+
+on: [push, pull_request]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ['3.10', '3.11']
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v5
+      with:
+        python-version: ${{ matrix.python-version }}
+        cache: 'pip'
+        cache-dependency-path: pyproject.toml
+
+    - name: Install dependencies
+      run: |
+        python -m pip install .[dev]
+
+    - name: Check formatting with black
+      if: matrix.python-version == '3.10'
+      run: |
+        black --version
+        black --check .
+
+    - name: Type checking with mypy
+      if: matrix.python-version == '3.10'
+      run: |
+        mypy --ignore-missing-imports blobmodel
+
+    - name: Test with pytest
+      run: |
+        pytest --cov --cov-report=xml
+
+    - name: Upload coverage to Codecov
+      if: matrix.python-version == '3.10'
+      uses: codecov/codecov-action@v4
+      with:
+        token: ${{ secrets.CODECOV_TOKEN }}

{blobmodel-1.2.2 → blobmodel-2.0.0}/.readthedocs.yml

@@ -24,9 +24,11 @@ sphinx:
 #    - pdf
 #    - epub
 
-# Optional but recommended, declare the Python requirements required
-# to build your documentation
-# See https://docs.readthedocs.io/en/stable/guides/reproducible-builds.html
+# Install the package itself (autodoc imports it) together with the
+# docs extra declared in pyproject.toml
 python:
    install:
-   - requirements: docs/requirements.txt
+   - method: pip
+     path: .
+     extra_requirements:
+       - docs

{blobmodel-1.2.2 → blobmodel-2.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: blobmodel
-Version: 1.2.2
+Version: 2.0.0
 Summary: Two dimensional model of propagating blobs
 Author-email: gregordecristoforo <gregor.decristoforo@gmail.com>
 License: MIT License
@@ -25,7 +25,7 @@ License: MIT License
         OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
         SOFTWARE.
         
-Requires-Python: >=3
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy
@@ -34,11 +34,14 @@ Requires-Dist: tqdm
 Requires-Dist: nptyping
 Requires-Dist: matplotlib
 Requires-Dist: netcdf4
-Requires-Dist: pytest-cov
-Requires-Dist: black
-Requires-Dist: mypy
-Requires-Dist: sphinx
-Requires-Dist: sphinx-rtd-theme
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: sphinx; extra == "docs"
+Requires-Dist: sphinx-rtd-theme; extra == "docs"
 Dynamic: license-file
 
 # blobmodel  <img align="left" src="https://github.com/uit-cosmo/blobmodel/blob/main/readme_files/logo.png" width="120px" >
@@ -97,9 +100,11 @@ python -m pip install -e .
 Create a grid on which the blobs are discretized using the `Model` class. The `make_realization()` method computes the output as an xarray dataset which can also be written out as a `netcdf` file if the argument `file_name` is specified. A simple example is shown below:
 
 ```Python
-from blobmodel import Model, show_model
+from blobmodel import Geometry, Model, show_model
 
-bm = Model(Nx=200, Ny=100, Lx=10, Ly=10, dt=0.1, T=20, num_blobs=100)
+bm = Model(
+    geometry=Geometry(Nx=200, Ny=100, Lx=10, Ly=10, dt=0.1, T=20), num_blobs=100
+)
 
 ds = bm.make_realization(file_name="example.nc")
 ```
@@ -110,21 +115,17 @@ show_model(ds)
 You can specify the blob parameters with a BlobFactory class. The DefaultBlobFactory class has some of the most common distribution functions implemented. An example would look like this:
 
 ```Python
-from blobmodel import DefaultBlobFactory, DistributionEnum, Model
+from blobmodel import DefaultBlobFactory, DistributionEnum, Geometry, Model
 
 # use DefaultBlobFactory to define distribution functions of random variables
-my_blob_factory = DefaultBlobFactory(A_dist=DistributionEnum.normal, A_parameter=5)
+my_blob_factory = DefaultBlobFactory(t_drain=100).set_sampler(
+    "amplitude", DistributionEnum.normal, free_parameter=5
+)
 
 # pass on my_blob_factory when creating the Model
 bm = Model(
-        Nx=100,
-        Ny=100,
-        Lx=10,
-        Ly=10,
-        dt=0.1,
-        T=20,
+        geometry=Geometry(Nx=100, Ny=100, Lx=10, Ly=10, dt=0.1, T=20),
         blob_factory=my_blob_factory,
-        t_drain=100,
         num_blobs=100,
     )
 ```

{blobmodel-1.2.2 → blobmodel-2.0.0}/README.md

@@ -54,9 +54,11 @@ python -m pip install -e .
 Create a grid on which the blobs are discretized using the `Model` class. The `make_realization()` method computes the output as an xarray dataset which can also be written out as a `netcdf` file if the argument `file_name` is specified. A simple example is shown below:
 
 ```Python
-from blobmodel import Model, show_model
+from blobmodel import Geometry, Model, show_model
 
-bm = Model(Nx=200, Ny=100, Lx=10, Ly=10, dt=0.1, T=20, num_blobs=100)
+bm = Model(
+    geometry=Geometry(Nx=200, Ny=100, Lx=10, Ly=10, dt=0.1, T=20), num_blobs=100
+)
 
 ds = bm.make_realization(file_name="example.nc")
 ```
@@ -67,21 +69,17 @@ show_model(ds)
 You can specify the blob parameters with a BlobFactory class. The DefaultBlobFactory class has some of the most common distribution functions implemented. An example would look like this:
 
 ```Python
-from blobmodel import DefaultBlobFactory, DistributionEnum, Model
+from blobmodel import DefaultBlobFactory, DistributionEnum, Geometry, Model
 
 # use DefaultBlobFactory to define distribution functions of random variables
-my_blob_factory = DefaultBlobFactory(A_dist=DistributionEnum.normal, A_parameter=5)
+my_blob_factory = DefaultBlobFactory(t_drain=100).set_sampler(
+    "amplitude", DistributionEnum.normal, free_parameter=5
+)
 
 # pass on my_blob_factory when creating the Model
 bm = Model(
-        Nx=100,
-        Ny=100,
-        Lx=10,
-        Ly=10,
-        dt=0.1,
-        T=20,
+        geometry=Geometry(Nx=100, Ny=100, Lx=10, Ly=10, dt=0.1, T=20),
         blob_factory=my_blob_factory,
-        t_drain=100,
         num_blobs=100,
     )
 ```

{blobmodel-1.2.2 → blobmodel-2.0.0}/blobmodel/__init__.py

@@ -1,7 +1,13 @@
-from .model import Model
+from .model import Model, to_imaging_dataset
 from .blobs import Blob
 from .plotting import show_model
-from .stochasticality import BlobFactory, DefaultBlobFactory
+from .stochasticality import (
+    BlobFactory,
+    BlobListFactory,
+    CallableBlobFactory,
+    DefaultBlobFactory,
+    ParameterSampler,
+)
 from .geometry import Geometry
 from .blob_shape import AbstractBlobShape, BlobShapeImpl, BlobShapeEnum
 from .distributions import DistributionEnum

{blobmodel-1.2.2 → blobmodel-2.0.0}/blobmodel/blob_shape.py

@@ -78,6 +78,19 @@ def _get_lorentz_shape(theta: np.ndarray, **kwargs) -> np.ndarray:
 def _get_double_exponential_shape(theta: np.ndarray, **kwargs) -> np.ndarray:
     """Compute the double-exponential pulse shape.
 
+    The shape is ``exp(-theta / lam)`` for ``theta >= 0`` and
+    ``exp(theta / (1 - lam))`` for ``theta < 0``, i.e. ``lam`` is the
+    e-folding fraction of the leading (``theta >= 0``) side of the pulse.
+    For a blob propagating with ``v_x > 0`` observed at a fixed position,
+    ``lam`` is therefore the temporal *rise* fraction of the measured pulse,
+    matching the asymmetry-parameter convention of the FPP literature.
+
+    .. versionchanged:: 2.0.0
+        The convention was flipped: ``lam`` previously weighted the trailing
+        (``theta < 0``) side, so ``lam`` was the temporal *fall* fraction.
+        Code written against older versions that passed ``1 - lam`` to
+        compensate should now pass ``lam`` directly.
+
     Parameters
     ----------
     theta : np.ndarray
@@ -85,18 +98,29 @@ def _get_double_exponential_shape(theta: np.ndarray, **kwargs) -> np.ndarray:
     kwargs
         Additional keyword arguments.
         lam : float
-            Asymmetry parameter controlling the shape.
+            Asymmetry parameter controlling the shape, in the interval [0, 1].
+            The limits are the one-sided shapes: lam = 0 is nonzero only for
+            theta < 0 (a pure temporal decay for v_x > 0), lam = 1 is nonzero
+            only for theta >= 0 (a pure temporal rise for v_x > 0).
 
     Returns
     -------
     np.ndarray
         Array representing the double-exponential pulse shape.
+
+    Raises
+    ------
+    ValueError
+        If lam lies outside the interval [0, 1].
     """
     lam = kwargs["lam"]
-    assert (lam > 0.0) & (lam < 1.0)
+    if not 0.0 <= lam <= 1.0:
+        raise ValueError(f"lam must be in the interval [0, 1], got lam = {lam}.")
     kern = np.zeros(shape=np.shape(theta))
-    kern[theta < 0] = np.exp(theta[theta < 0] / lam)
-    kern[theta >= 0] = np.exp(-theta[theta >= 0] / (1 - lam))
+    if lam < 1.0:
+        kern[theta < 0] = np.exp(theta[theta < 0] / (1 - lam))
+    if lam > 0.0:
+        kern[theta >= 0] = np.exp(-theta[theta >= 0] / lam)
     return kern
 
 
@@ -171,43 +195,73 @@ def _get_dipole_shape(theta: np.ndarray, **kwargs) -> np.ndarray:
 
 
 class BlobShapeImpl(AbstractBlobShape):
-    """Implementation of the AbstractPulseShape class."""
+    """Implementation of the AbstractBlobShape class."""
 
     def __init__(
         self,
-        pulse_shape_p=BlobShapeEnum.gaussian,
-        pulse_shape_s=BlobShapeEnum.gaussian,
+        pulse_shape_p: BlobShapeEnum = BlobShapeEnum.gaussian,
+        pulse_shape_s: BlobShapeEnum = BlobShapeEnum.gaussian,
     ):
         """Initialize the BlobShapeImpl object.
 
-        Attributes
+        Parameters
         ----------
-        pulse_shape_p : str, optional
-            Type of pulse shape in the principal direction, by default "gauss".
-        pulse_shape_s : str, optional
-            Type of pulse shape in the secondary direction, by default "gauss".
+        pulse_shape_p : BlobShapeEnum, optional
+            Type of pulse shape in the principal direction,
+            by default BlobShapeEnum.gaussian.
+        pulse_shape_s : BlobShapeEnum, optional
+            Type of pulse shape in the secondary direction,
+            by default BlobShapeEnum.gaussian.
+
+        Raises
+        ------
+        NotImplementedError
+            If a pulse shape is not a member of BlobShapeEnum with an
+            implemented shape function.
         """
         if (
-            pulse_shape_p not in BlobShapeImpl.__GENERATORS.keys()
-            or pulse_shape_s not in BlobShapeImpl.__GENERATORS.keys()
+            pulse_shape_p not in BlobShapeImpl.__GENERATORS
+            or pulse_shape_s not in BlobShapeImpl.__GENERATORS
         ):
             raise NotImplementedError(
                 f"{self.__class__.__name__}.blob_shape not implemented"
             )
-        self.get_blob_shape_p = BlobShapeImpl.__GENERATORS.get(pulse_shape_p)
-        self.get_blob_shape_s = BlobShapeImpl.__GENERATORS.get(pulse_shape_s)
+        self._shape_p = BlobShapeImpl.__GENERATORS[pulse_shape_p]
+        self._shape_s = BlobShapeImpl.__GENERATORS[pulse_shape_s]
 
     def get_blob_shape_p(self, theta: np.ndarray, **kwargs) -> np.ndarray:
+        """Compute the pulse shape in the principal direction.
+
+        Parameters
+        ----------
+        theta : np.ndarray
+            Array of theta values.
+        kwargs
+            Additional keyword arguments passed to the shape function.
+
+        Returns
+        -------
+        np.ndarray
+            Array representing the pulse shape in the principal direction.
         """
-        Compute the pulse shape in the principal direction.
-        """
-        raise NotImplementedError
+        return self._shape_p(theta, **kwargs)
 
     def get_blob_shape_s(self, theta: np.ndarray, **kwargs) -> np.ndarray:
+        """Compute the pulse shape in the secondary direction.
+
+        Parameters
+        ----------
+        theta : np.ndarray
+            Array of theta values.
+        kwargs
+            Additional keyword arguments passed to the shape function.
+
+        Returns
+        -------
+        np.ndarray
+            Array representing the pulse shape in the secondary direction.
         """
-        Compute the pulse shape in the secondary direction.
-        """
-        raise NotImplementedError
+        return self._shape_s(theta, **kwargs)
 
     __GENERATORS = {
         BlobShapeEnum.exp: _get_exponential_shape,

{blobmodel-1.2.2 → blobmodel-2.0.0}/blobmodel/blobs.py

@@ -1,10 +1,9 @@
 """This module defines a Blob class and related functions for discretizing and manipulating blobs."""
 
-import warnings
-from typing import Union, Any
+from typing import Union, Any, Optional
 from nptyping import NDArray
 import numpy as np
-from .blob_shape import AbstractBlobShape
+from .blob_shape import AbstractBlobShape, BlobShapeImpl
 import cmath
 
 
@@ -14,7 +13,7 @@ class Blob:
     the function `discretize_blob`. The contribution of a single blob to a grid defined by `x`, `y` and `t` is given by:
 
     .. math::
-        a e^{-(t-t_k)/\\tau_\\shortparallel}\\varphi\\left( \\frac{x-v(t-t_k)}{\ell_x}, \\frac{(y-y_k)-w(t-t_k)}{\ell_y} \\right)
+        a e^{-(t-t_k)/\\tau_\\shortparallel}\\varphi\\left( \\frac{(x-x_k)-v(t-t_k)}{\ell_x}, \\frac{(y-y_k)-w(t-t_k)}{\ell_y} \\right)
 
     Where:
         - :math:`a` is the blob amplitude, `amplitude`.
@@ -22,76 +21,105 @@ class Blob:
         - :math:`\ell_y` is the blob width in the secondary direction, `width_s`.
         - :math:`v` is the horizontal blob velocity.
         - :math:`w` is the vertical blob velocity.
-        - :math:`t_k` is the blob arriving time at the position x=0, `t_init`.
+        - :math:`x_k` and :math:`y_k` are the blob position at time :math:`t_k`,
+          `pos_x0` and `pos_y0`.
+        - :math:`t_k` is the time at which the blob is seeded at
+          :math:`(x_k, y_k)`, `t_init`.
         - :math:`\\tau_\\shortparallel` is the drainage time, `t_drain`.
         - :math:`\\varphi` is the blob pulse shape, `blob_shape`.
 
-    Additionally, a tilt angle can be provided through `theta`.
+    Additionally, a tilt angle can be provided through `theta`, in which case
+    the two arguments of :math:`\\varphi` are rotated by `theta` around the
+    blob center.
     """
 
     def __init__(
         self,
-        blob_id: int,
-        blob_shape: AbstractBlobShape,
-        amplitude: float,
-        width_p: float,
-        width_s: float,
-        v_x: float,
-        v_y: float,
-        pos_x0: float,
-        pos_y0: float,
-        t_init: float,
-        t_drain: Union[float, NDArray],
+        blob_id: int = 0,
+        blob_shape: Optional[AbstractBlobShape] = None,
+        amplitude: float = 1.0,
+        width_p: float = 1.0,
+        width_s: float = 1.0,
+        v_x: float = 1.0,
+        v_y: float = 0.0,
+        pos_x0: float = 0.0,
+        pos_y0: float = 0.0,
+        t_init: float = 0.0,
+        t_drain: Union[float, NDArray] = np.inf,
         shape_parameters_p: Union[dict, None] = None,
         shape_parameters_s: Union[dict, None] = None,
         blob_alignment: bool = False,
-        theta: float = 0,
+        theta: Optional[float] = None,
     ) -> None:
         """
         Initialize a single blob.
 
         Parameters
         ----------
-        blob_id : int
-            Identifier for the blob.
-        blob_shape : AbstractBlobShape
-            Shape of the blob.
-        amplitude : float
-            Amplitude of the blob.
-        width_p : float
-            Width of the blob in the propagation direction.
-        width_s : float
-            Width of the blob in the perpendicular direction.
-        v_x : float
-            Velocity of the blob in the x-direction.
-        v_y : float
-            Velocity of the blob in the y-direction.
-        pos_x0 : float
-            Initial position of the blob in the x-direction.
-        pos_y0 : float
-            Initial position of the blob in the y-direction.
-        t_init : float
-            Initial time of the blob.
-        t_drain : Union[float, NDArray]
-            Time scale for the blob to drain.
+        blob_id : int, optional
+            Identifier for the blob (default 0). Purely metadata: blob labels
+            in ``Model`` (``labels="individual"``) are assigned from each
+            blob's position in the factory output, not from ``blob_id``.
+        blob_shape : AbstractBlobShape, optional
+            Shape of the blob. Default None, which means a Gaussian shape in
+            both directions, ``BlobShapeImpl()``.
+        amplitude : float, optional
+            Amplitude of the blob. Default 1.
+        width_p : float, optional
+            Width of the blob in the propagation direction. Default 1.
+        width_s : float, optional
+            Width of the blob in the perpendicular direction. Default 1.
+        v_x : float, optional
+            Velocity of the blob in the x-direction. Default 1.
+        v_y : float, optional
+            Velocity of the blob in the y-direction. Default 0.
+        pos_x0 : float, optional
+            Initial position of the blob in the x-direction. Default 0.
+        pos_y0 : float, optional
+            Initial position of the blob in the y-direction. Default 0.
+        t_init : float, optional
+            Initial time of the blob. Default 0.
+        t_drain : Union[float, NDArray], optional
+            Time scale for the blob to drain. Either a scalar or a 1D
+            array-like of length Nx (one value per grid point in the
+            x-direction); array-likes are stored as float numpy arrays.
+            Default ``np.inf`` = no draining.
         shape_parameters_p : dict
             Additional shape parameters for the propagation direction.
         shape_parameters_s : dict
             Additional shape parameters for the perpendicular direction.
         blob_alignment : bool, optional
-            If blob_alignment == True, the blob shapes are rotated in the propagation direction of the blob
-            If blob_alignment == False, the blob shapes are independent of the propagation direction
-        theta : float
-            Blob rotation with respect to the x-axis.
-
-            it is computed according to blob_alignment. If set to a no None value,
-        the blob alignment flag is ignored. Important: the blob angle is measured with respect to the x axis, not with
-         respect to the velocity vector.
+            Only used when ``theta is None``. If True, the blob shape is rotated to
+            align with the blob propagation direction; if False, the blob shape is
+            axis-aligned (no rotation). Default False.
+        theta : float or None, optional
+            Blob rotation angle with respect to the x-axis (not the velocity
+            vector). If not None, this angle is used directly and ``blob_alignment``
+            is ignored. If None (the default), the angle is determined by
+            ``blob_alignment``: the velocity phase when it is True, or 0 when False.
+
+        Raises
+        ------
+        TypeError
+            If ``blob_shape`` is not an ``AbstractBlobShape`` instance.
+        ValueError
+            If ``width_p`` or ``width_s`` is not positive, or if ``t_drain``
+            is not positive (every element, when it is an array).
 
         """
-        assert isinstance(blob_shape, AbstractBlobShape)
+        if blob_shape is None:
+            blob_shape = BlobShapeImpl()
+        if not isinstance(blob_shape, AbstractBlobShape):
+            raise TypeError(
+                f"blob_shape must be an AbstractBlobShape, got {type(blob_shape).__name__}."
+            )
+        if width_p <= 0 or width_s <= 0:
+            raise ValueError(
+                f"Blob widths must be positive, got width_p = {width_p} and width_s = {width_s}."
+            )
+        if np.any(np.asarray(t_drain) <= 0):
+            raise ValueError(f"t_drain must be positive, got t_drain = {t_drain}.")
 
-        self.int = int
         self.blob_id = blob_id
         self.blob_shape = blob_shape
         self.amplitude = amplitude
@@ -102,7 +130,14 @@ class Blob:
         self.pos_x0 = pos_x0
         self.pos_y0 = pos_y0
         self.t_init = t_init
-        self.t_drain = t_drain
+        # Normalize to float scalar or float array so downstream code can
+        # rely on np.ndim and numpy indexing (lists and numpy integer
+        # scalars would otherwise fail deep inside _drain).
+        self.t_drain: Union[float, np.ndarray] = (
+            float(t_drain)
+            if np.ndim(t_drain) == 0
+            else np.asarray(t_drain, dtype=np.float64)
+        )
         self.shape_parameters_p = (
             {} if shape_parameters_p is None else shape_parameters_p
         )
@@ -110,9 +145,19 @@ class Blob:
             {} if shape_parameters_s is None else shape_parameters_s
         )
         self.blob_alignment = blob_alignment
-        self._theta = theta
-        if blob_alignment:
+        if theta is not None:
+            self._theta = theta
+        elif blob_alignment:
             self._theta = cmath.phase(self.v_x + self.v_y * 1j)
+        else:
+            self._theta = 0
+
+    @property
+    def theta(self) -> float:
+        """float: Tilt angle used when discretizing the blob, measured from
+        the x-axis (read-only). Resolved at construction from the explicit
+        ``theta`` argument or, when that is None, from ``blob_alignment``."""
+        return self._theta
 
     def discretize_blob(
         self,
@@ -122,6 +167,7 @@ class Blob:
         Ly: float,
         periodic_y: bool = False,
         one_dimensional: bool = False,
+        y0: float = 0,
     ) -> NDArray:
         """
         Discretize blob on grid. If one_dimensional the secondary pulse shape is ignored.
@@ -129,17 +175,28 @@ class Blob:
         Parameters
         ----------
         x : NDArray
-            Grid coordinates in the x-direction.
+            Grid coordinates in the x-direction, as an array broadcastable to
+            shape (Ny, Nx, Nt): either a full meshgrid array or a 1D
+            coordinate array reshaped as ``x[np.newaxis, :, np.newaxis]``.
         y : NDArray
-            Grid coordinates in the y-direction.
+            Grid coordinates in the y-direction, as an array broadcastable to
+            shape (Ny, Nx, Nt): either a full meshgrid array or a 1D
+            coordinate array reshaped as ``y[:, np.newaxis, np.newaxis]``.
         t : NDArray
-            Time coordinates.
+            Time coordinates, as an array broadcastable to shape (Ny, Nx, Nt):
+            either a full meshgrid array or a 1D coordinate array reshaped as
+            ``t[np.newaxis, np.newaxis, :]``. A scalar t (single time point)
+            is also accepted.
         Ly : float
             Length of domain in the y-direction.
         periodic_y : bool, optional
             Flag indicating periodicity in the y-direction (default: False).
         one_dimensional : bool, optional
             Flag indicating a one-dimensional blob (default: False).
+        y0 : float, optional
+            Origin of the domain in the y-direction (default: 0). Only used
+            when ``periodic_y`` is True, where the blob position is wrapped
+            into the domain ``[y0, y0 + Ly)``.
 
         Notes
         -----
@@ -149,25 +206,27 @@ class Blob:
         Returns
         -------
         discretized_blob : NDArray
-            Discretized blob on a 3D array with dimensions (x, y, t).
+            Discretized blob on a 3D array with dimensions (y, x, t),
+            i.e. shape (Ny, Nx, Nt).
 
-        """
-        # If one_dimensional, then Ly should be 0.
-        assert (one_dimensional and Ly == 0) or not one_dimensional
+        Raises
+        ------
+        ValueError
+            If ``one_dimensional`` is True and ``Ly`` is not 0.
 
-        if (self.width_s > Ly / 3 or self.width_p > Ly / 3) and periodic_y:
-            warnings.warn(
-                "blob width big compared to Ly, mirrored blobs might become apparent."
-            )
+        """
+        if one_dimensional and Ly != 0:
+            raise ValueError(f"One dimensional blobs require Ly == 0, got Ly = {Ly}.")
 
         if not periodic_y or one_dimensional:
             return self._single_blob(
                 x, y, t, Ly, periodic_y, one_dimensional=one_dimensional
             )
 
-        time = t if type(t) in [int, float] else t[0][0]
+        time = t if np.ndim(t) == 0 else t[0][0]
         vertical_prop = self.v_y * (time - self.t_init) + self.pos_y0
-        number_of_y_propagations = vertical_prop // Ly
+        # Wrap the blob position into the domain [y0, y0 + Ly).
+        number_of_y_propagations = (vertical_prop - y0) // Ly
 
         # Sum of a centered blob is two "ghost blobs" at vertical positions +-Ly.
         return (
@@ -277,9 +336,9 @@ class Blob:
             Drain factor.
 
         """
-        if isinstance(self.t_drain, (int, float)):
-            return np.exp(-(t - self.t_init) / float(self.t_drain))
-        return np.exp(-(t - self.t_init) / self.t_drain[np.newaxis, :, np.newaxis])
+        if isinstance(self.t_drain, np.ndarray):
+            return np.exp(-(t - self.t_init) / self.t_drain[np.newaxis, :, np.newaxis])
+        return np.exp(-(t - self.t_init) / self.t_drain)
 
     def _blob_trajectory_x(self, t: Union[int, NDArray]) -> Any:
         """