blobmodel 2.0.0__tar.gz → 2.1.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: blobmodel
-Version: 2.0.0
+Version: 2.1.0
 Summary: Two dimensional model of propagating blobs
 Author-email: gregordecristoforo <gregor.decristoforo@gmail.com>
 License: MIT License
@@ -131,6 +131,8 @@ bm = Model(
 ```
 Alternatively, you can specify all blob parameters exactly as you want by writing your own class which inherits from BlobFactory. See `examples/custom_blobfactory.py` as an example or take a look at the [blobmodel documentation](https://blobmodel.readthedocs.io/en/latest/?badge=latest).
 
+Blobs can decay exponentially from their initial time with a drainage time `t_drain`, and/or be given a finite pulse lifetime `t_lifetime`, a Gaussian envelope symmetric about the blob's `t_init` so that the blob grows, peaks and decays. Both are arguments of `DefaultBlobFactory` and are applied to every sampled blob; see the [drainage time](https://blobmodel.readthedocs.io/en/latest/drainage_time.html) and [pulse lifetime](https://blobmodel.readthedocs.io/en/latest/pulse_lifetime.html) sections of the documentation.
+
 ## Contributing
 
 Feel free to raise issues about anything. Contributions through pull requests are also very welcome. Please take a look at our [Contributor guide](https://blobmodel.readthedocs.io/en/latest/contributor_guide.html) for further details.

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

@@ -85,6 +85,8 @@ bm = Model(
 ```
 Alternatively, you can specify all blob parameters exactly as you want by writing your own class which inherits from BlobFactory. See `examples/custom_blobfactory.py` as an example or take a look at the [blobmodel documentation](https://blobmodel.readthedocs.io/en/latest/?badge=latest).
 
+Blobs can decay exponentially from their initial time with a drainage time `t_drain`, and/or be given a finite pulse lifetime `t_lifetime`, a Gaussian envelope symmetric about the blob's `t_init` so that the blob grows, peaks and decays. Both are arguments of `DefaultBlobFactory` and are applied to every sampled blob; see the [drainage time](https://blobmodel.readthedocs.io/en/latest/drainage_time.html) and [pulse lifetime](https://blobmodel.readthedocs.io/en/latest/pulse_lifetime.html) sections of the documentation.
+
 ## Contributing
 
 Feel free to raise issues about anything. Contributions through pull requests are also very welcome. Please take a look at our [Contributor guide](https://blobmodel.readthedocs.io/en/latest/contributor_guide.html) for further details.

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

@@ -13,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-x_k)-v(t-t_k)}{\ell_x}, \\frac{(y-y_k)-w(t-t_k)}{\ell_y} \\right)
+        a e^{-(t-t_k)/\\tau_\\shortparallel} e^{-\\left((t-t_k)/\\tau_\\mathrm{d}\\right)^2}\\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`.
@@ -26,11 +26,23 @@ class Blob:
         - :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:`\\tau_\\mathrm{d}` is the pulse lifetime, `t_lifetime`. The
+          corresponding factor is absent (equal to 1) when `t_lifetime` is
+          None, which is the default.
         - :math:`\\varphi` is the blob pulse shape, `blob_shape`.
 
+    The two temporal factors are different: `t_drain` is a one-sided
+    exponential decay *from* :math:`t_k`, growing without bound backwards in
+    time, while `t_lifetime` is a Gaussian envelope *symmetric about*
+    :math:`t_k`. They are independent and multiply. When a lifetime is set and
+    `t_drain` is infinite, :math:`t_k` is the time of maximum amplitude.
+
     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.
+
+    .. versionadded:: 2.1.0
+        The `t_lifetime` envelope.
     """
 
     def __init__(
@@ -50,6 +62,7 @@ class Blob:
         shape_parameters_s: Union[dict, None] = None,
         blob_alignment: bool = False,
         theta: Optional[float] = None,
+        t_lifetime: Optional[float] = None,
     ) -> None:
         """
         Initialize a single blob.
@@ -97,14 +110,24 @@ class Blob:
             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.
+        t_lifetime : float, optional
+            Pulse lifetime: the blob is multiplied by the Gaussian envelope
+            ``exp(-((t - t_init) / t_lifetime)**2)``, symmetric about
+            ``t_init``. Scalar only — unlike ``t_drain`` there is no per-x
+            array form. Default None = no envelope; ``np.inf`` is accepted and
+            is equivalent to None. Keyword-only in practice: it is last in the
+            signature so that positional callers are unaffected.
+
+            .. versionadded:: 2.1.0
 
         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).
+            If ``width_p`` or ``width_s`` is not positive, if ``t_drain``
+            is not positive (every element, when it is an array), or if
+            ``t_lifetime`` is given and is not positive.
 
         """
         if blob_shape is None:
@@ -119,6 +142,10 @@ class Blob:
             )
         if np.any(np.asarray(t_drain) <= 0):
             raise ValueError(f"t_drain must be positive, got t_drain = {t_drain}.")
+        if t_lifetime is not None and not t_lifetime > 0:
+            raise ValueError(
+                f"t_lifetime must be positive, got t_lifetime = {t_lifetime}."
+            )
 
         self.blob_id = blob_id
         self.blob_shape = blob_shape
@@ -138,6 +165,9 @@ class Blob:
             if np.ndim(t_drain) == 0
             else np.asarray(t_drain, dtype=np.float64)
         )
+        self.t_lifetime: Optional[float] = (
+            None if t_lifetime is None else float(t_lifetime)
+        )
         self.shape_parameters_p = (
             {} if shape_parameters_p is None else shape_parameters_p
         )
@@ -318,9 +348,46 @@ class Blob:
         )
 
         return (
-            self.amplitude * self._drain(t) * primary_axis_shape * secondary_axis_shape
+            self.amplitude
+            * self._temporal_factor(t)
+            * primary_axis_shape
+            * secondary_axis_shape
         )
 
+    def _temporal_factor(self, t: Union[int, NDArray]) -> NDArray:
+        """
+        Combined drain and lifetime factor.
+
+        Without a lifetime this is exactly `_drain`. With one, the drain and
+        envelope exponents are summed before exponentiating: evaluated
+        separately, far from `t_init` the drain overflows while the envelope
+        underflows, giving ``inf * 0 = nan`` instead of a negligible value.
+
+        Parameters
+        ----------
+        t : NDArray
+            Time coordinates.
+
+        Returns
+        -------
+        temporal_factor : NDArray
+            ``exp(-(t - t_init)/t_drain - ((t - t_init)/t_lifetime)**2)``.
+
+        """
+        if self.t_lifetime is None:
+            return self._drain(t)
+        return np.exp(
+            self._drain_exponent(t) - ((t - self.t_init) / self.t_lifetime) ** 2
+        )
+
+    def _drain_exponent(self, t: Union[int, NDArray]) -> Any:
+        """
+        Exponent of the drain factor, ``-(t - t_init) / t_drain``.
+        """
+        if isinstance(self.t_drain, np.ndarray):
+            return -(t - self.t_init) / self.t_drain[np.newaxis, :, np.newaxis]
+        return -(t - self.t_init) / self.t_drain
+
     def _drain(self, t: Union[int, NDArray]) -> NDArray:
         """
         Calculate the drain factor for the blob.
@@ -336,9 +403,7 @@ class Blob:
             Drain factor.
 
         """
-        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)
+        return np.exp(self._drain_exponent(t))
 
     def _blob_trajectory_x(self, t: Union[int, NDArray]) -> Any:
         """

{blobmodel-2.0.0 → blobmodel-2.1.0}/blobmodel/model.py

@@ -474,29 +474,141 @@ class Model:
         -------
         Tuple[int, int]
             Start and stop indices.
+
+        Notes
+        -----
+        - Two independent windows are intersected: the one derived from the
+          blob crossing the domain (only available when ``v_x != 0``) and,
+          for a blob with a finite `t_lifetime`, the one derived from the
+          support of its temporal envelope. Either may be absent, in which
+          case the other is used alone; with neither the whole time axis is
+          returned.
         """
-        if not speed_up or blob.v_x == 0:
+        if not speed_up:
             return 0, self._geometry.t.size
 
+        n_t = self._geometry.t.size
+        start, stop = 0, n_t
         dt, t0 = self._geometry.dt, self._geometry.t[0]
-        idx_x0 = (blob.t_init - t0) / dt + (self._geometry.x[0] - blob.pos_x0) / (
-            blob.v_x * dt
-        )
-        idx_Lx = idx_x0 + self._geometry.Lx / (blob.v_x * dt)
-        # Decay length of the blob along the x-axis: the blob-frame widths
-        # projected onto x through the tilt angle (width_p for an untilted
-        # blob, width_s at theta = pi/2).
-        width_x = (
-            np.abs(np.cos(blob.theta)) * blob.width_p
-            + np.abs(np.sin(blob.theta)) * blob.width_s
-        )
-        margin = (
-            -width_x * np.log(truncation_error * np.sqrt(np.pi)) / np.abs(blob.v_x * dt)
-        )
-        start = int(np.clip(min(idx_x0, idx_Lx) - margin, 0, self._geometry.t.size))
-        stop = int(np.clip(max(idx_x0, idx_Lx) + margin, 0, self._geometry.t.size))
+        # Bound on |blob contribution| / (temporal factor): every shape peaks
+        # at or below 1, and periodic-y discretization sums three copies.
+        copies = 3 if self._geometry.periodic_y and not self._one_dimensional else 1
+        peak = copies * abs(blob.amplitude)
+
+        if blob.t_lifetime is not None and np.isfinite(blob.t_lifetime):
+            # The envelope is symmetric about t_init, so the window is too.
+            half_width = self._lifetime_half_width(blob, truncation_error, peak)
+            idx_peak = (blob.t_init - t0) / dt
+            margin = half_width / dt
+            start = max(start, int(np.clip(np.floor(idx_peak - margin), 0, n_t)))
+            stop = min(stop, int(np.clip(np.ceil(idx_peak + margin), 0, n_t)))
+
+        if blob.v_x != 0:
+            idx_x0 = (blob.t_init - t0) / dt + (self._geometry.x[0] - blob.pos_x0) / (
+                blob.v_x * dt
+            )
+            idx_Lx = idx_x0 + self._geometry.Lx / (blob.v_x * dt)
+            # Decay length of the blob along the x-axis: the blob-frame widths
+            # projected onto x through the tilt angle (width_p for an untilted
+            # blob, width_s at theta = pi/2).
+            width_x = (
+                np.abs(np.cos(blob.theta)) * blob.width_p
+                + np.abs(np.sin(blob.theta)) * blob.width_s
+            )
+            margin = (
+                width_x
+                * (self._log_temporal_gain(blob, peak) - np.log(truncation_error))
+                / np.abs(blob.v_x * dt)
+            )
+            start = max(start, int(np.clip(min(idx_x0, idx_Lx) - margin, 0, n_t)))
+            stop = min(stop, int(np.clip(max(idx_x0, idx_Lx) + margin, 0, n_t)))
+
+        # The two windows may not overlap at all: collapse rather than invert.
+        return start, max(start, stop)
+
+    @staticmethod
+    def _log_temporal_gain(blob: Blob, peak: float) -> float:
+        r"""
+        Log of a bound on how much the crossing-window margin must widen.
+
+        The crossing margin assumes the blob's contribution is at most its
+        spatial shape. With a finite `t_lifetime` the temporal factor
+        ``exp(-dt / t_drain - (dt / tau_d)**2)`` peaks at
+        ``exp(tau_d**2 / (4 t_drain**2))`` (before `t_init`), and the amplitude
+        and ghost copies scale the field too, so the log of `peak` times that
+        temporal peak is added to the margin's log-threshold. Clamped at 0 so the margin
+        never shrinks below the lifetime-free one. Without a (finite)
+        lifetime this returns 0, leaving the pre-existing window unchanged.
+
+        Parameters
+        ----------
+        blob : Blob
+            Blob object.
+        peak : float
+            Bound on the blob's contribution divided by its temporal factor
+            (``|amplitude|`` times the number of periodic-y copies).
 
-        return start, stop
+        Returns
+        -------
+        float
+            Non-negative log-gain.
+        """
+        tau_d = blob.t_lifetime
+        if tau_d is None or not np.isfinite(tau_d) or peak == 0:
+            return 0.0
+        t_drain = np.min(blob.t_drain)
+        peak_exponent = 0.0 if np.isinf(t_drain) else tau_d**2 / (4 * t_drain**2)
+        return float(max(np.log(peak) + peak_exponent, 0.0))
+
+    @staticmethod
+    def _lifetime_half_width(blob: Blob, truncation_error: float, peak: float) -> float:
+        r"""
+        Half-width in time of the support of a blob's lifetime envelope.
+
+        The envelope ``exp(-(dt / tau_d)**2)`` alone drops below
+        `truncation_error` for ``|dt| >= tau_d * sqrt(-log(error))``. A finite
+        `t_drain` makes the drain factor *grow* backwards in time, so the
+        product ``exp(-(dt / tau_d)**2 + dt / t_drain)`` is the binding
+        constraint; it falls below `truncation_error` for
+
+        .. math::
+            \Delta \geq b + \sqrt{b^2 - \tau_d^2 \log \varepsilon},
+            \quad b = \tau_d^2 / (2 \tau_\text{drain}),
+
+        which reduces to the envelope-only bound at ``t_drain = inf``. The
+        smallest element is used for an array-valued `t_drain` (smallest drain
+        time = widest window = the conservative choice).
+
+        `truncation_error` bounds the field itself, so ``epsilon`` is
+        ``truncation_error / peak``: every blob shape peaks at or below 1 in
+        magnitude and periodic-y discretization sums three copies, hence
+        ``peak * envelope * drain`` bounds the blob's contribution.
+
+        Parameters
+        ----------
+        blob : Blob
+            Blob with a non-None `t_lifetime`.
+        truncation_error : float
+            Amplitude below which the blob is truncated.
+        peak : float
+            Bound on the blob's contribution divided by its temporal factor
+            (``|amplitude|`` times the number of periodic-y copies).
+
+        Returns
+        -------
+        float
+            Half-width in time units; `np.inf` for an infinite `t_lifetime`.
+        """
+        tau_d = blob.t_lifetime
+        if tau_d is None or not np.isfinite(tau_d):
+            return np.inf
+        if peak == 0:
+            return 0.0
+        # Clamped so that an error >= 1 (nothing to keep) cannot produce a nan.
+        neg_log_error = max(-np.log(truncation_error / peak), 0.0)
+        t_drain = np.min(blob.t_drain)
+        b = 0.0 if np.isinf(t_drain) else tau_d**2 / (2 * t_drain)
+        return float(b + np.sqrt(b**2 + tau_d**2 * neg_log_error))
 
     def _reset_fields(self):
         """Reset the density and labels fields."""

{blobmodel-2.0.0 → blobmodel-2.1.0}/blobmodel/stochasticality.py

@@ -183,6 +183,7 @@ class DefaultBlobFactory(BlobFactory):
         "ws": (DistributionEnum.deg, 1.0),
         "vx": (DistributionEnum.deg, 1.0),
         "vy": (DistributionEnum.zeros, 0.0),
+        "posx": (DistributionEnum.zeros, 0.0),
         "spp": (DistributionEnum.deg, 0.5),
         "sps": (DistributionEnum.deg, 0.5),
     }
@@ -192,6 +193,7 @@ class DefaultBlobFactory(BlobFactory):
         t_drain: Union[float, NDArray, int] = np.inf,
         blob_alignment: bool = False,
         seed: Union[int, np.random.Generator, None] = None,
+        t_lifetime: Union[float, None] = None,
     ) -> None:
         """
         Default implementation of BlobFactory.
@@ -225,14 +227,26 @@ class DefaultBlobFactory(BlobFactory):
             By default None, i.e. a freshly seeded generator (non-reproducible).
             Note that a seed passed to `Model` takes precedence: it replaces
             this factory's generator via `set_rng`.
+        t_lifetime : float, optional
+            Pulse lifetime of the blobs: every sampled blob is multiplied by
+            the Gaussian envelope ``exp(-((t - t_init) / t_lifetime)**2)``,
+            symmetric about its own `t_init`. Scalar only. By default None,
+            i.e. no envelope. Last in the signature so that positional callers
+            are unaffected.
+
+            .. versionadded:: 2.1.0
 
         Raises
         ------
         ValueError
-            If `t_drain` is not positive.
+            If `t_drain` or `t_lifetime` is not positive.
         """
         if np.any(np.asarray(t_drain) <= 0):
             raise ValueError(f"t_drain must be positive, got t_drain = {t_drain}.")
+        if t_lifetime is not None and not t_lifetime > 0:
+            raise ValueError(
+                f"t_lifetime must be positive, got t_lifetime = {t_lifetime}."
+            )
 
         # Per-parameter distribution (None for custom callables) and sampler.
         self._dists: dict = {}
@@ -242,6 +256,7 @@ class DefaultBlobFactory(BlobFactory):
             self.set_sampler(parameter, dist, free_parameter)
 
         self.t_drain = t_drain
+        self.t_lifetime = None if t_lifetime is None else float(t_lifetime)
         self.blob_alignment = blob_alignment
         self.theta_setter: Union[Callable[[], float], None] = None
         self.rng = np.random.default_rng(seed)
@@ -264,6 +279,11 @@ class DefaultBlobFactory(BlobFactory):
             - "ws": width in the secondary (perpendicular) blob direction
             - "vx": velocity in the x-direction
             - "vy": velocity in the y-direction
+            - "posx": blob position in the x-direction at ``t_init``
+              (`DistributionEnum.zeros` by default, i.e. every blob is seeded
+              at x = 0; the factory does not know the domain, so seeding
+              blobs across it means supplying a callable, e.g.
+              ``lambda rng, n: rng.uniform(-pad, Lx + pad, n)``)
             - "spp": pulse shape parameter in the principal direction
             - "sps": pulse shape parameter in the secondary direction
         sampler : DistributionEnum or Callable[[np.random.Generator, int], np.ndarray]
@@ -371,7 +391,8 @@ class DefaultBlobFactory(BlobFactory):
         Creates a list of Blobs used in the Model.
 
         Every blob is given the factory's `t_drain` (a constructor argument,
-        `np.inf` — no draining — by default).
+        `np.inf` — no draining — by default) and its `t_lifetime` (also a
+        constructor argument, None — no envelope — by default).
 
         Parameters
         ----------
@@ -407,10 +428,10 @@ class DefaultBlobFactory(BlobFactory):
         vys = self._draw_random_variables("vy", num_blobs)
         spxs = self._draw_random_variables("spp", num_blobs)
         spys = self._draw_random_variables("sps", num_blobs)
+        posxs = self._draw_random_variables("posx", num_blobs)
         # For now, only a lambda parameter is implemented
         spxs_dict = [{"lam": s} for s in spxs]
         spys_dict = [{"lam": s} for s in spys]
-        posxs = np.zeros(num_blobs)
         posys = self.rng.uniform(low=0.0, high=Ly, size=num_blobs)
         t_inits = self.rng.uniform(low=0, high=T, size=num_blobs)
 
@@ -427,6 +448,7 @@ class DefaultBlobFactory(BlobFactory):
                 pos_y0=posys[i],
                 t_init=t_inits[i],
                 t_drain=self.t_drain,
+                t_lifetime=self.t_lifetime,
                 shape_parameters_p=spxs_dict[i],
                 shape_parameters_s=spys_dict[i],
                 blob_alignment=self.blob_alignment,

{blobmodel-2.0.0 → blobmodel-2.1.0}/blobmodel.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: blobmodel
-Version: 2.0.0
+Version: 2.1.0
 Summary: Two dimensional model of propagating blobs
 Author-email: gregordecristoforo <gregor.decristoforo@gmail.com>
 License: MIT License
@@ -131,6 +131,8 @@ bm = Model(
 ```
 Alternatively, you can specify all blob parameters exactly as you want by writing your own class which inherits from BlobFactory. See `examples/custom_blobfactory.py` as an example or take a look at the [blobmodel documentation](https://blobmodel.readthedocs.io/en/latest/?badge=latest).
 
+Blobs can decay exponentially from their initial time with a drainage time `t_drain`, and/or be given a finite pulse lifetime `t_lifetime`, a Gaussian envelope symmetric about the blob's `t_init` so that the blob grows, peaks and decays. Both are arguments of `DefaultBlobFactory` and are applied to every sampled blob; see the [drainage time](https://blobmodel.readthedocs.io/en/latest/drainage_time.html) and [pulse lifetime](https://blobmodel.readthedocs.io/en/latest/pulse_lifetime.html) sections of the documentation.
+
 ## Contributing
 
 Feel free to raise issues about anything. Contributions through pull requests are also very welcome. Please take a look at our [Contributor guide](https://blobmodel.readthedocs.io/en/latest/contributor_guide.html) for further details.

blobmodel-2.1.0/blobmodel.egg-info/SOURCES.txt

@@ -0,0 +1,36 @@
+LICENSE
+README.md
+pyproject.toml
+blobmodel/__init__.py
+blobmodel/blob_shape.py
+blobmodel/blobs.py
+blobmodel/distributions.py
+blobmodel/geometry.py
+blobmodel/model.py
+blobmodel/plotting.py
+blobmodel/stochasticality.py
+blobmodel.egg-info/PKG-INFO
+blobmodel.egg-info/SOURCES.txt
+blobmodel.egg-info/dependency_links.txt
+blobmodel.egg-info/requires.txt
+blobmodel.egg-info/top_level.txt
+tests/test_analytical.py
+tests/test_blob.py
+tests/test_blob_factories.py
+tests/test_changing_t_drain.py
+tests/test_docs.py
+tests/test_docs_scripts.py
+tests/test_drain.py
+tests/test_geometry.py
+tests/test_imaging_layout.py
+tests/test_input_validation.py
+tests/test_labels.py
+tests/test_lifetime.py
+tests/test_one_dim.py
+tests/test_pulse_shape.py
+tests/test_seed.py
+tests/test_show_model.py
+tests/test_speed_up.py
+tests/test_stochasticality.py
+tests/test_str.py
+tests/test_vx_or_vy=0.py

{blobmodel-2.0.0 → blobmodel-2.1.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "blobmodel"
-version = "2.0.0"
+version = "2.1.0"
 description = "Two dimensional model of propagating blobs"
 authors = [
   { name = "gregordecristoforo", email = "gregor.decristoforo@gmail.com" }

{blobmodel-2.0.0 → blobmodel-2.1.0}/tests/test_docs.py

@@ -38,6 +38,33 @@ def test_drainage_time():
     # PLACEHOLDER drainage_time_1
 
 
+def test_pulse_lifetime():
+    # PLACEHOLDER pulse_lifetime_0
+    from blobmodel import DefaultBlobFactory, Geometry, Model
+
+    geometry = Geometry(Nx=100, Ny=1, Lx=10, Ly=0, dt=0.1, T=100, periodic_y=False)
+
+    # Blobs peak at their t_init and live for a time t_lifetime. Seeding them
+    # uniformly over an interval wider than the domain keeps the process
+    # homogeneous over the observed region.
+    pad = 10.0
+    blob_factory = DefaultBlobFactory(t_lifetime=1.0).set_sampler(
+        "posx",
+        lambda rng, n: rng.uniform(
+            geometry.x0 - pad, geometry.x0 + geometry.Lx + pad, n
+        ),
+    )
+
+    tmp = Model(
+        geometry=geometry,
+        blob_factory=blob_factory,
+        num_blobs=100,
+        one_dimensional=True,
+    )
+    tmp.make_realization()
+    # PLACEHOLDER pulse_lifetime_1
+
+
 def test_one_dim():
     # PLACEHOLDER one_dim_0
     from blobmodel import (

{blobmodel-2.0.0 → blobmodel-2.1.0}/tests/test_docs_scripts.py

@@ -18,6 +18,7 @@ SCRIPTS = [
     "create_logo.py",
     "plot_pulses.py",
     "changing_t_drain_plot.py",
+    "pulse_lifetime_plot.py",
 ]