blobmodel 1.1.2__tar.gz → 1.2.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: blobmodel
-Version: 1.1.2
+Version: 1.2.2
 Summary: Two dimensional model of propagating blobs
 Author-email: gregordecristoforo <gregor.decristoforo@gmail.com>
 License: MIT License

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

@@ -23,15 +23,17 @@ class AbstractBlobShape(ABC):
     """Abstract class containing the blob pulse shapes. Two-dimensional blob
     pulse shapes are written in the form:
 
-    ``phi(theta_x, theta_y) = phi_x(theta_x) * phi_y(theta_y)``
+    ``phi(theta_p, theta_s) = phi_p(theta_p) * phi_s(theta_s)``
+
+    Where the p and s subindexes stand for primary and secondary directions.
     """
 
     @abstractmethod
-    def get_blob_shape_prop(self, theta: np.ndarray, **kwargs) -> np.ndarray:
+    def get_blob_shape_p(self, theta: np.ndarray, **kwargs) -> np.ndarray:
         raise NotImplementedError
 
     @abstractmethod
-    def get_blob_shape_perp(self, theta: np.ndarray, **kwargs) -> np.ndarray:
+    def get_blob_shape_s(self, theta: np.ndarray, **kwargs) -> np.ndarray:
         raise NotImplementedError
 
 
@@ -173,59 +175,37 @@ class BlobShapeImpl(AbstractBlobShape):
 
     def __init__(
         self,
-        pulse_shape_prop=BlobShapeEnum.gaussian,
-        pulse_shape_perp=BlobShapeEnum.gaussian,
+        pulse_shape_p=BlobShapeEnum.gaussian,
+        pulse_shape_s=BlobShapeEnum.gaussian,
     ):
         """Initialize the BlobShapeImpl object.
 
         Attributes
         ----------
-        pulse_shape_prop : str, optional
-            Type of pulse shape in the propagation direction, by default "gauss".
-        pulse_shape_perp : str, optional
-            Type of pulse shape perpendicular to the propagation direction, by default "gauss".
+        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".
         """
         if (
-            pulse_shape_prop not in BlobShapeImpl.__GENERATORS.keys()
-            or pulse_shape_perp not in BlobShapeImpl.__GENERATORS.keys()
+            pulse_shape_p not in BlobShapeImpl.__GENERATORS.keys()
+            or pulse_shape_s not in BlobShapeImpl.__GENERATORS.keys()
         ):
             raise NotImplementedError(
                 f"{self.__class__.__name__}.blob_shape not implemented"
             )
-        self.get_blob_shape_prop = BlobShapeImpl.__GENERATORS.get(pulse_shape_prop)
-        self.get_blob_shape_perp = BlobShapeImpl.__GENERATORS.get(pulse_shape_perp)
-
-    def get_blob_shape_prop(self, theta: np.ndarray, **kwargs) -> np.ndarray:
-        """Compute the pulse shape in the propagation direction.
+        self.get_blob_shape_p = BlobShapeImpl.__GENERATORS.get(pulse_shape_p)
+        self.get_blob_shape_s = BlobShapeImpl.__GENERATORS.get(pulse_shape_s)
 
-        Parameters
-        ----------
-        theta : np.ndarray
-            Array of theta values.
-        kwargs
-            Additional keyword arguments.
-
-        Returns
-        -------
-        np.ndarray
-            Array representing the pulse shape in the propagation direction.
+    def get_blob_shape_p(self, theta: np.ndarray, **kwargs) -> np.ndarray:
+        """
+        Compute the pulse shape in the principal direction.
         """
         raise NotImplementedError
 
-    def get_blob_shape_perp(self, theta: np.ndarray, **kwargs) -> np.ndarray:
-        """Compute the pulse shape perpendicular to the propagation direction.
-
-        Parameters
-        ----------
-        theta : np.ndarray
-            Array of theta values.
-        kwargs
-            Additional keyword arguments.
-
-        Returns
-        -------
-        np.ndarray
-            Array representing the pulse shape perpendicular to the propagation direction.
+    def get_blob_shape_s(self, theta: np.ndarray, **kwargs) -> np.ndarray:
+        """
+        Compute the pulse shape in the secondary direction.
         """
         raise NotImplementedError
 

blobmodel-1.2.2/blobmodel/blobs.py

@@ -0,0 +1,294 @@
+"""This module defines a Blob class and related functions for discretizing and manipulating blobs."""
+
+import warnings
+from typing import Union, Any
+from nptyping import NDArray
+import numpy as np
+from .blob_shape import AbstractBlobShape
+import cmath
+
+
+class Blob:
+    """
+    Class representing a single blob. It stores all blob parameters and discretizes the blob on a grid through
+    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)
+
+    Where:
+        - :math:`a` is the blob amplitude, `amplitude`.
+        - :math:`\ell_x` is the blob width in the principal direction, `width_p`.
+        - :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:`\\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`.
+    """
+
+    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],
+        shape_parameters_p: Union[dict, None] = None,
+        shape_parameters_s: Union[dict, None] = None,
+        blob_alignment: bool = False,
+        theta: float = 0,
+    ) -> 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.
+        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.
+
+        """
+        assert isinstance(blob_shape, AbstractBlobShape)
+
+        self.int = int
+        self.blob_id = blob_id
+        self.blob_shape = blob_shape
+        self.amplitude = amplitude
+        self.width_p = width_p  # Primary width
+        self.width_s = width_s  # Secondary width
+        self.v_x = v_x
+        self.v_y = v_y
+        self.pos_x0 = pos_x0
+        self.pos_y0 = pos_y0
+        self.t_init = t_init
+        self.t_drain = t_drain
+        self.shape_parameters_p = (
+            {} if shape_parameters_p is None else shape_parameters_p
+        )
+        self.shape_parameters_s = (
+            {} if shape_parameters_s is None else shape_parameters_s
+        )
+        self.blob_alignment = blob_alignment
+        self._theta = theta
+        if blob_alignment:
+            self._theta = cmath.phase(self.v_x + self.v_y * 1j)
+
+    def discretize_blob(
+        self,
+        x: NDArray,
+        y: NDArray,
+        t: NDArray,
+        Ly: float,
+        periodic_y: bool = False,
+        one_dimensional: bool = False,
+    ) -> NDArray:
+        """
+        Discretize blob on grid. If one_dimensional the secondary pulse shape is ignored.
+
+        Parameters
+        ----------
+        x : NDArray
+            Grid coordinates in the x-direction.
+        y : NDArray
+            Grid coordinates in the y-direction.
+        t : NDArray
+            Time coordinates.
+        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).
+
+        Notes
+        -----
+        The periodicity in the y direction is implemented by first substracting the number of full domain Ly
+        propagations made by the blob and by summing mirror blobs at vertical positions +-Ly.
+
+        Returns
+        -------
+        discretized_blob : NDArray
+            Discretized blob on a 3D array with dimensions (x, y, t).
+
+        """
+        # If one_dimensional, then Ly should be 0.
+        assert (one_dimensional and Ly == 0) or not one_dimensional
+
+        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 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]
+        vertical_prop = self.v_y * (time - self.t_init) + self.pos_y0
+        number_of_y_propagations = vertical_prop // Ly
+
+        # Sum of a centered blob is two "ghost blobs" at vertical positions +-Ly.
+        return (
+            self._single_blob(
+                x,
+                y,
+                t,
+                Ly,
+                periodic_y,
+                number_of_y_propagations,
+                one_dimensional=one_dimensional,
+            )
+            + self._single_blob(
+                x,
+                y + Ly,
+                t,
+                Ly,
+                periodic_y,
+                number_of_y_propagations,
+                one_dimensional=one_dimensional,
+            )
+            + self._single_blob(
+                x,
+                y - Ly,
+                t,
+                Ly,
+                periodic_y,
+                number_of_y_propagations,
+                one_dimensional=one_dimensional,
+            )
+        )
+
+    def _single_blob(
+        self,
+        x: Union[int, NDArray],
+        y: Union[int, NDArray],
+        t: Union[int, NDArray],
+        Ly: float,
+        periodic_y: bool,
+        number_of_y_propagations: Union[NDArray, int] = 0,
+        one_dimensional: bool = False,
+    ) -> NDArray:
+        """
+        Calculate the discretized blob for a single blob instance.
+
+        Parameters
+        ----------
+        x : NDArray
+            x-coordinate
+        y : NDArray
+            y-coordinate
+        t : NDArray
+            Time coordinates.
+        Ly : float
+            Length of domain in the y-direction.
+        periodic_y : bool
+            Flag indicating periodicity in the y-direction.
+        number_of_y_propagations : NDArray, optional
+            Number of times the blob propagates through the domain in y-direction (default: 0).
+        one_dimensional : bool, optional
+            Flag indicating a one-dimensional blob (default: False).
+
+        Returns
+        -------
+        blob : NDArray
+            Discretized blob.
+
+        """
+        # Blob position
+        pos_x = self._blob_trajectory_x(t)
+        pos_y = self._blob_trajectory_y(t)
+        if periodic_y:
+            pos_y -= number_of_y_propagations * Ly
+
+        # Blob frame coordinates
+        xb = np.cos(self._theta) * (x - pos_x) + np.sin(self._theta) * (y - pos_y)
+        yb = -np.sin(self._theta) * (x - pos_x) + np.cos(self._theta) * (y - pos_y)
+
+        theta_x = xb / self.width_p
+        theta_y = yb / self.width_s
+        primary_axis_shape = self.blob_shape.get_blob_shape_p(
+            theta_x, **self.shape_parameters_p
+        )
+
+        secondary_axis_shape = (
+            1
+            if one_dimensional
+            else self.blob_shape.get_blob_shape_s(theta_y, **self.shape_parameters_s)
+        )
+
+        return (
+            self.amplitude * self._drain(t) * primary_axis_shape * secondary_axis_shape
+        )
+
+    def _drain(self, t: Union[int, NDArray]) -> NDArray:
+        """
+        Calculate the drain factor for the blob.
+
+        Parameters
+        ----------
+        t : NDArray
+            Time coordinates.
+
+        Returns
+        -------
+        drain_factor : NDArray
+            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])
+
+    def _blob_trajectory_x(self, t: Union[int, NDArray]) -> Any:
+        """
+        Position of the blob in the x-direction at a given time t.
+        """
+        return self.pos_x0 + self.v_x * (t - self.t_init)
+
+    def _blob_trajectory_y(self, t: Union[int, NDArray]) -> Any:
+        """
+        Position of the blob in the y-direction at a given time t.
+        """
+        return self.pos_y0 + self.v_y * (t - self.t_init)

{blobmodel-1.1.2 → blobmodel-1.2.2}/blobmodel/model.py

@@ -335,22 +335,23 @@ class Model:
             int(
                 (
                     np.abs(blob.t_init * blob.v_x)
-                    + blob.width_prop * np.log(error * np.sqrt(np.pi))
-                    + blob.pos_x
-                    - self._geometry.t[0]
+                    + blob.width_p * np.log(error * np.sqrt(np.pi))
+                    + blob.pos_x0
+                    - self._geometry.t[0] * blob.v_x
                 )
                 / np.abs(self._geometry.dt * blob.v_x)
             ),
         )
+        start = np.minimum(self._geometry.t.size, start)
         # ignores t_drain when calculating stop time
         stop = np.minimum(
             self._geometry.t.size,
             int(
                 (
                     np.abs(blob.t_init * blob.v_x)
-                    - blob.width_prop * np.log(error * np.sqrt(np.pi))
+                    - blob.width_p * np.log(error * np.sqrt(np.pi))
                     + self._geometry.Lx
-                    - blob.pos_x
+                    - blob.pos_x0
                 )
                 / np.abs(blob.v_x * self._geometry.dt)
             ),

{blobmodel-1.1.2 → blobmodel-1.2.2}/blobmodel/stochasticality.py

@@ -44,19 +44,19 @@ class DefaultBlobFactory(BlobFactory):
     def __init__(
         self,
         A_dist: DistributionEnum = DistributionEnum.exp,
-        wx_dist: DistributionEnum = DistributionEnum.deg,
-        wy_dist: DistributionEnum = DistributionEnum.deg,
+        wp_dist: DistributionEnum = DistributionEnum.deg,
+        ws_dist: DistributionEnum = DistributionEnum.deg,
         vx_dist: DistributionEnum = DistributionEnum.deg,
         vy_dist: DistributionEnum = DistributionEnum.deg,
-        spx_dist: DistributionEnum = DistributionEnum.deg,
-        spy_dist: DistributionEnum = DistributionEnum.deg,
+        spp_dist: DistributionEnum = DistributionEnum.deg,
+        sps_dist: DistributionEnum = DistributionEnum.deg,
         A_parameter: float = 1.0,
-        wx_parameter: float = 1.0,
-        wy_parameter: float = 1.0,
+        wp_parameter: float = 1.0,
+        ws_parameter: float = 1.0,
         vx_parameter: float = 1.0,
         vy_parameter: float = 1.0,
-        shape_param_x_parameter: float = 0.5,
-        shape_param_y_parameter: float = 0.5,
+        shape_param_p_parameter: float = 0.5,
+        shape_param_s_parameter: float = 0.5,
         blob_alignment: bool = True,
     ) -> None:
         """
@@ -69,32 +69,32 @@ class DefaultBlobFactory(BlobFactory):
         ----------
         A_dist : Distribution, optional
             Distribution type for amplitude, by default "Distribution.exp"
-        wx_dist : Distribution, optional
-            Distribution type for width in the x-direction, by default "Distribution.deg"
-        wy_dist : Distribution, optional
-            Distribution type for width in the y-direction, by default "Distribution.deg"
+        wp_dist : Distribution, optional
+            Distribution type for width in the principal blob direction, by default "Distribution.deg"
+        ws_dist : Distribution, optional
+            Distribution type for width in the secondary blob direction, by default "Distribution.deg"
         vx_dist : Distribution, optional
             Distribution type for velocity in the x-direction, by default "Distribution.deg"
         vy_dist : Distribution, optional
             Distribution type for velocity in the y-direction, by default "Distribution.deg"
-        spx_dist : Distribution, optional
-            Distribution type for shape parameter in the x-direction, by default "Distribution.deg"
-        spy_dist : Distribution, optional
-            Distribution type for shape parameter in the y-direction, by default "Distribution.deg"
+        spp_dist : Distribution, optional
+            Distribution type for shape parameter in the principal blob direction, by default "Distribution.deg"
+        sps_dist : Distribution, optional
+            Distribution type for shape parameter in the secondary blob direction, by default "Distribution.deg"
         A_parameter : float, optional
             Free parameter for the amplitude distribution, by default 1.0
-        wx_parameter : float, optional
-            Free parameter for the width distribution in the x-direction, by default 1.0
-        wy_parameter : float, optional
-            Free parameter for the width distribution in the y-direction, by default 1.0
+        wp_parameter : float, optional
+            Free parameter for the width distribution in the principal direction, by default 1.0
+        ws_parameter : float, optional
+            Free parameter for the width distribution in the secondary direction, by default 1.0
         vx_parameter : float, optional
             Free parameter for the velocity distribution in the x-direction, by default 1.0
         vy_parameter : float, optional
             Free parameter for the velocity distribution in the y-direction, by default 1.0
-        shape_param_x_parameter : float, optional
-            Free parameter for the shape parameter distribution in the x-direction, by default 0.5
-        shape_param_y_parameter : float, optional
-            Free parameter for the shape parameter distribution in the y-direction, by default 0.5
+        shape_param_p_parameter : float, optional
+            Free parameter for the shape parameter distribution in the principal direction, by default 0.5
+        shape_param_s_parameter : float, optional
+            Free parameter for the shape parameter distribution in the secondary direction, by default 0.5
         blob_alignment : bool, optional
             If blob_aligment == True, the blob shapes are rotated in the propagation direction of the blob
             If blob_aligment == False, the blob shapes are independent of the propagation direction
@@ -112,27 +112,27 @@ class DefaultBlobFactory(BlobFactory):
 
         """
         assert isinstance(A_dist, DistributionEnum)
-        assert isinstance(wx_dist, DistributionEnum)
-        assert isinstance(wy_dist, DistributionEnum)
+        assert isinstance(wp_dist, DistributionEnum)
+        assert isinstance(ws_dist, DistributionEnum)
         assert isinstance(vx_dist, DistributionEnum)
         assert isinstance(vy_dist, DistributionEnum)
-        assert isinstance(spx_dist, DistributionEnum)
-        assert isinstance(spy_dist, DistributionEnum)
+        assert isinstance(spp_dist, DistributionEnum)
+        assert isinstance(sps_dist, DistributionEnum)
 
         self.amplitude_dist = A_dist
-        self.width_x_dist = wx_dist
-        self.width_y_dist = wy_dist
+        self.width_p_dist = wp_dist
+        self.width_s_dist = ws_dist
         self.velocity_x_dist = vx_dist
         self.velocity_y_dist = vy_dist
-        self.shape_param_x_dist = spx_dist
-        self.shape_param_y_dist = spy_dist
+        self.shape_param_p_dist = spp_dist
+        self.shape_param_s_dist = sps_dist
         self.amplitude_parameter = A_parameter
-        self.width_x_parameter = wx_parameter
-        self.width_y_parameter = wy_parameter
+        self.width_p_parameter = wp_parameter
+        self.width_s_parameter = ws_parameter
         self.velocity_x_parameter = vx_parameter
         self.velocity_y_parameter = vy_parameter
-        self.shape_param_x_parameter = shape_param_x_parameter
-        self.shape_param_y_parameter = shape_param_y_parameter
+        self.shape_param_p_parameter = shape_param_p_parameter
+        self.shape_param_s_parameter = shape_param_s_parameter
         self.blob_alignment = blob_alignment
         self.theta_setter = lambda: 0
 
@@ -179,10 +179,10 @@ class DefaultBlobFactory(BlobFactory):
             num_blobs,
         )
         wxs = self._draw_random_variables(
-            self.width_x_dist, self.width_x_parameter, num_blobs
+            self.width_p_dist, self.width_p_parameter, num_blobs
         )
         wys = self._draw_random_variables(
-            self.width_y_dist, self.width_y_parameter, num_blobs
+            self.width_s_dist, self.width_s_parameter, num_blobs
         )
         vxs = self._draw_random_variables(
             self.velocity_x_dist, self.velocity_x_parameter, num_blobs
@@ -191,10 +191,10 @@ class DefaultBlobFactory(BlobFactory):
             self.velocity_y_dist, self.velocity_y_parameter, num_blobs
         )
         spxs = self._draw_random_variables(
-            self.shape_param_x_dist, self.shape_param_x_parameter, num_blobs
+            self.shape_param_p_dist, self.shape_param_p_parameter, num_blobs
         )
         spys = self._draw_random_variables(
-            self.shape_param_y_dist, self.shape_param_y_parameter, num_blobs
+            self.shape_param_s_dist, self.shape_param_s_parameter, num_blobs
         )
         # For now, only a lambda parameter is implemented
         spxs_dict = [{"lam": s} for s in spxs]
@@ -208,16 +208,16 @@ class DefaultBlobFactory(BlobFactory):
                 blob_id=i,
                 blob_shape=blob_shape,
                 amplitude=amps[i],
-                width_prop=wxs[i],
-                width_perp=wys[i],
+                width_p=wxs[i],
+                width_s=wys[i],
                 v_x=vxs[i],
                 v_y=vys[i],
-                pos_x=posxs[i],
-                pos_y=posys[i],
+                pos_x0=posxs[i],
+                pos_y0=posys[i],
                 t_init=t_inits[i],
                 t_drain=t_drain,
-                prop_shape_parameters=spxs_dict[i],
-                perp_shape_parameters=spys_dict[i],
+                shape_parameters_p=spxs_dict[i],
+                shape_parameters_s=spys_dict[i],
                 blob_alignment=self.blob_alignment,
                 theta=self.theta_setter(),
             )

{blobmodel-1.1.2 → blobmodel-1.2.2}/blobmodel.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: blobmodel
-Version: 1.1.2
+Version: 1.2.2
 Summary: Two dimensional model of propagating blobs
 Author-email: gregordecristoforo <gregor.decristoforo@gmail.com>
 License: MIT License

{blobmodel-1.1.2 → blobmodel-1.2.2}/blobmodel.egg-info/SOURCES.txt

@@ -59,6 +59,7 @@ examples/blob_tilting.py
 examples/changing_t_drain.py
 examples/compare_to_analytical_sol.py
 examples/custom_blobfactory.py
+examples/point_process.py
 examples/show_labels.py
 examples/single_blob.py
 paper/paper.bib

{blobmodel-1.1.2 → blobmodel-1.2.2}/docs/changing_t_drain_plot.py

@@ -2,7 +2,7 @@ from blobmodel import Model, DefaultBlobFactory
 import matplotlib.pyplot as plt
 import numpy as np
 
-bf = DefaultBlobFactory(A_dist="deg", wx_dist="deg", vx_dist="deg", vy_dist="zeros")
+bf = DefaultBlobFactory(A_dist="deg", wp_dist="deg", vx_dist="deg", vy_dist="zeros")
 
 t_drain = np.linspace(2, 1, 100)
 

{blobmodel-1.1.2 → blobmodel-1.2.2}/docs/create_logo.py

@@ -41,12 +41,12 @@ class CustomBlobFactory(BlobFactory):
                 blob_id=i,
                 blob_shape=blob_shape,
                 amplitude=amp[i],
-                width_prop=width[i],
-                width_perp=width[i],
+                width_p=width[i],
+                width_s=width[i],
                 v_x=vx[i],
                 v_y=vy[i],
-                pos_x=posx[i],
-                pos_y=posy[i],
+                pos_x0=posx[i],
+                pos_y0=posy[i],
                 t_init=t_init[i],
                 t_drain=t_drain,
             )

{blobmodel-1.1.2 → blobmodel-1.2.2}/examples/2_sided_exp_pulse.py

@@ -10,8 +10,8 @@ import matplotlib.pyplot as plt
 # Example of use of extra blob shape parameters with a double exponential blob shape.
 
 bf = DefaultBlobFactory(
-    shape_param_x_parameter=0.5,
-    shape_param_y_parameter=0.5,
+    shape_param_p_parameter=0.5,
+    shape_param_s_parameter=0.5,
     blob_alignment=True,
 )
 

{blobmodel-1.1.2 → blobmodel-1.2.2}/examples/blob_tilting.py

@@ -23,8 +23,8 @@ bf = DefaultBlobFactory(
     A_dist=DistributionEnum.deg,
     vy_parameter=vy,
     vx_parameter=vx,
-    wx_parameter=wx,
-    wy_parameter=wy,
+    wp_parameter=wx,
+    ws_parameter=wy,
     blob_alignment=True,  # Blobs will be aligned with their velocities
 )
 
@@ -55,8 +55,8 @@ bf = DefaultBlobFactory(
     A_dist=DistributionEnum.deg,
     vy_parameter=vy,
     vx_parameter=vx,
-    wx_parameter=wx,
-    wy_parameter=wy,
+    wp_parameter=wx,
+    ws_parameter=wy,
     blob_alignment=False,
 )
 # Blobs will NOT be aligned with their velocities, instead they will be tilted by an angle given by theta.