pyafv 0.3.3__cp312-cp312-musllinux_1_2_x86_64.whl → 0.3.4__cp312-cp312-musllinux_1_2_x86_64.whl

pyafv/__init__.py

@@ -1,12 +1,30 @@
-from .physical_params import PhysicalParams, target_delta
-from .simulator import FiniteVoronoiSimulator
+"""
+PyAFV - A Python implementation of the active-finite-Voronoi (AFV) model in 2D.
+
+**Classes**
+
+.. autosummary::
+   :nosignatures:
+
+   PhysicalParams
+   FiniteVoronoiSimulator
+
+**Functions**
 
-from importlib.metadata import version, PackageNotFoundError
+.. autosummary::
+   :nosignatures:
+
+   target_delta
+"""
+
+from .physical_params import PhysicalParams, target_delta
+from .finite_voronoi import FiniteVoronoiSimulator
 
 try:
-    __version__ = version("pyafv")
-except PackageNotFoundError:
-    __version__ = "unknown"  # package is not installed
+    from ._version import __version__
+except ImportError:
+    __version__ = "unknown"
+
 
 __all__ = [
     "PhysicalParams",

pyafv/_version.py

@@ -0,0 +1,2 @@
+# pyafv/_version.py
+__version__ = "0.3.4"

pyafv/backend.py

@@ -1,16 +1,20 @@
 # chooses fast vs fallback implementation
 
 try:
-    from . import finite_voronoi_fast as _impl
+    from . import cell_geom as _impl
     _BACKEND_NAME = "cython"
-except ImportError:             # pragma: no cover
+    _IMPORT_ERROR = None
+except Exception as e:             # pragma: no cover
+    from . import cell_geom_fallback as _impl
     _BACKEND_NAME = "python"
-    from . import finite_voronoi_fallback as _impl
+    _IMPORT_ERROR = e
+
 
 # ---- for explicit API ----
-backend_simulator = _impl.FiniteVoronoiSimulator
+backend_impl = _impl
 
 __all__ = [
-    "backend_simulator",
+    "backend_impl",
     "_BACKEND_NAME",
+    "_IMPORT_ERROR"
 ]

pyafv/cell_geom_fallback.py

@@ -0,0 +1,249 @@
+"""
+These are pure-Python fallback implementations of key functions for finite Voronoi
+cell geometry and derivative calculations, used when Cython extensions are not
+available.
+"""
+
+import numpy as np
+from collections import defaultdict
+
+
+def build_vertexpair_and_vertexpoints(ridge_vertices_all, ridge_points, num_vertices, N):
+    # Build ridge incidence per vertex, and a lookup for (v1,v2) -> ridge id
+    vertex_incident_ridges = defaultdict(list)
+    # Cheaper key: store both directions as tuple -> int
+    vertexpair2ridge: dict[tuple[int, int], int] = {}
+
+    rv_full = np.asarray(ridge_vertices_all, dtype=int)
+    R = rv_full.shape[0]
+    for k in range(R):
+        v1, v2 = int(rv_full[k, 0]), int(rv_full[k, 1])
+        vertex_incident_ridges[v1].append(k)
+        vertex_incident_ridges[v2].append(k)
+        vertexpair2ridge[(v1, v2)] = k
+        vertexpair2ridge[(v2, v1)] = k
+
+    # For each finite vertex, record which input points (cells) meet there
+    vertex_points = {}
+    if N > 2:
+        for v_id in range(num_vertices):
+            s = set()
+            for ridge_id in vertex_incident_ridges[v_id]:
+                i, j = ridge_points[ridge_id]
+                s.add(i), s.add(j)
+            vertex_points[v_id] = list(s)
+
+    return vertexpair2ridge, vertex_points
+
+
+def pad_regions(regions):
+    # fake function to match cython backend interface
+    return regions
+
+
+def build_point_edges(vor_regions, point_region,
+                      vertices_all, pts,
+                      num_vertices, vertexpair2ridge,
+                      p1, p1_edges_pack, p1_verts_pack,
+                      p2, p2_edges_pack, p2_verts_pack):
+
+    N = pts.shape[0]
+
+    point_edges_type = []
+    point_vertices_f_idx = []
+
+    # --- fast vectorized per-cell processing (no inner edge loop) ---
+    for idx in range(N):
+        region_id = point_region[idx]
+        v_ids = np.asarray(vor_regions[region_id], dtype=int)
+
+        if v_ids.size == 0:
+            point_edges_type.append([])
+            point_vertices_f_idx.append([])
+            continue
+
+        # sort vertices clockwise around cell center
+        rel = vertices_all[v_ids] - pts[idx]
+        angles = np.arctan2(rel[:, 1], rel[:, 0])
+        order = np.argsort(angles)[::-1]
+        v_ids = v_ids[order]
+
+        # consecutive pairs (wrap) -> candidate edges around this cell
+        v1_ids = v_ids
+        v2_ids = np.roll(v_ids, -1)
+
+        # skip ray-ray (both >= num_vertices)
+        valid = ~((v1_ids >= num_vertices) & (v2_ids >= num_vertices))
+        if not np.any(valid):                # pragma: no cover
+            point_edges_type.append([])
+            point_vertices_f_idx.append([])
+            continue
+
+        v1_ids = v1_ids[valid]
+        v2_ids = v2_ids[valid]
+
+        # ---- vectorized ridge id lookup for all edges of this cell ----
+        # use the dict you already built with both orientations:
+        #   vertexpair2ridge[(v1, v2)] = ridge_id
+        # convert all edge pairs in one go via list comprehension (still fast, no Python loop per-edge body)
+        # NB: we keep it simple & reliable; if needed, switch to a sorted-structured-array map later.
+        keys = list(zip(v1_ids.tolist(), v2_ids.tolist()))
+        ridge_ids = np.fromiter(
+            (vertexpair2ridge[k] for k in keys), dtype=int, count=len(keys))
+
+        # decide which endpoint pack to use (p1 vs p2) for each edge
+        use_p1 = (p1[ridge_ids] == idx)
+        use_p2 = ~use_p1
+
+        # gather packs (shape (E,3)), then mask out the -1 slots
+        pack_e = np.empty((len(ridge_ids), 3), dtype=int)
+        pack_v = np.empty((len(ridge_ids), 3), dtype=int)
+
+        if np.any(use_p1):
+            pack_e[use_p1] = p1_edges_pack[ridge_ids[use_p1]]
+            pack_v[use_p1] = p1_verts_pack[ridge_ids[use_p1]]
+        if np.any(use_p2):
+            pack_e[use_p2] = p2_edges_pack[ridge_ids[use_p2]]
+            pack_v[use_p2] = p2_verts_pack[ridge_ids[use_p2]]
+
+        # flatten valid entries in pack order (keeps your exact edge ordering)
+        mask = (pack_e >= 0)
+        edges_type = pack_e[mask].tolist()
+        vertices_f_idx = pack_v[mask].tolist()
+
+        if len(vertices_f_idx) != len(edges_type):
+            raise ValueError("Vertex and edge number not equal!")
+
+        point_edges_type.append(edges_type)
+        point_vertices_f_idx.append(vertices_f_idx)
+
+    return point_edges_type, point_vertices_f_idx
+
+
+def compute_vertex_derivatives(
+            point_edges_type,            # list-of-lists / arrays of edge types
+            point_vertices_f_idx,        # list-of-lists / arrays of vertex ids
+            vertices_all,
+            pts, r, A0, P0, num_vertices_ext, num_ridges,
+            vertex_out_points):
+
+    N = pts.shape[0]
+
+    # --- helpers ---
+    def _row_cross(a, b):
+        # z-component of 2D cross, row-wise
+        return a[:, 0] * b[:, 1] - a[:, 1] * b[:, 0]
+
+    def _perp(u):
+        # rotate 90° CW: (ux,uy) -> (uy,-ux)
+        return np.column_stack((u[:, 1], -u[:, 0]))
+
+    vertex_out_da_dtheta = np.zeros((2 * num_ridges, 2))
+    vertex_out_dl_dtheta = np.zeros((2 * num_ridges, 2))
+
+    dA_poly_dh = np.zeros((num_vertices_ext + 2 * num_ridges, 2))
+    dP_poly_dh = np.zeros((num_vertices_ext + 2 * num_ridges, 2))
+
+    area_list = np.zeros(N)
+    perimeter_list = np.zeros(N)
+
+    for idx in range(N):
+        edges_type = np.asarray(point_edges_type[idx], dtype=int)
+        vertices_f_idx = np.asarray(point_vertices_f_idx[idx], dtype=int)
+        E = edges_type.size
+
+        if E < 2:
+            area_list[idx] = np.pi * (r ** 2)
+            perimeter_list[idx] = 2.0 * np.pi * r
+            continue
+
+        # ring indices
+        v1_idx = vertices_f_idx
+        v2_idx = np.roll(vertices_f_idx, -1)
+        v0_idx = np.roll(vertices_f_idx,  1)
+
+        ri = pts[idx]
+        V1 = vertices_all[v1_idx]
+        V2 = vertices_all[v2_idx]
+        V0 = vertices_all[v0_idx]
+        V1mR = V1 - ri
+        V2mR = V2 - ri
+        V0mR = V0 - ri
+
+        mask_str = (edges_type == 1)
+        mask_arc = ~mask_str
+
+        # ----- perimeter & area -----
+        seg12 = V1 - V2
+        l12 = np.linalg.norm(seg12, axis=1)
+        Pi_straight = l12[mask_str].sum()
+        Ai_straight = (-0.5 * _row_cross(V1mR[mask_str], V2mR[mask_str])).sum()
+
+        if np.any(mask_arc):
+            a1_full = np.arctan2(V1mR[:, 1], V1mR[:, 0])
+            a2_full = np.arctan2(V2mR[:, 1], V2mR[:, 0])
+            dangle_full = (a1_full - a2_full) % (2.0 * np.pi)
+            dangle_arc = dangle_full[mask_arc]
+            Pi_arc = (r * dangle_arc).sum()
+            Ai_arc = (0.5 * (r ** 2) * dangle_arc).sum()
+        else:
+            Pi_arc = 0.0
+            Ai_arc = 0.0
+
+        Pi = Pi_straight + Pi_arc
+        Ai = Ai_straight + Ai_arc
+        perimeter_list[idx] = Pi
+        area_list[idx] = Ai
+
+        # ----- dA_poly/dh, dP_poly/dh for v1 -----
+        dAi_v1 = -0.5 * _perp(V2mR) + 0.5 * _perp(V0mR)       # (E,2)
+
+        dPi_v1 = np.zeros((E, 2))
+        if np.any(mask_str):
+            dPi_v1[mask_str] += seg12[mask_str] / l12[mask_str][:, None]
+
+        mask_prev_str = np.roll(mask_str, 1)
+        seg10 = V1 - V0
+        l10 = np.linalg.norm(seg10, axis=1)
+        if np.any(mask_prev_str):
+            dPi_v1[mask_prev_str] += seg10[mask_prev_str] / l10[mask_prev_str][:, None]
+
+        np.add.at(dA_poly_dh, v1_idx, (Ai - A0) * dAi_v1)
+        np.add.at(dP_poly_dh, v1_idx, (Pi - P0) * dPi_v1)
+
+        # ----- arc endpoint sensitivities at outer vertices -----
+        if np.any(mask_arc):
+            # endpoint rows in vertex_out_* are (outer_id - num_vertices_ext)
+            v1_arc_idx = v1_idx[mask_arc]
+            v2_arc_idx = v2_idx[mask_arc]
+            k1 = v1_arc_idx - num_vertices_ext
+            k2 = v2_arc_idx - num_vertices_ext
+            valid1 = (k1 >= 0)
+            valid2 = (k2 >= 0)
+
+            if np.any(valid1) or np.any(valid2):
+                # da/dtheta for endpoints (sector - triangle)
+                da1_full = 0.5 * (r ** 2) * (1.0 - np.cos(dangle_full))   # v1 endpoint
+                da2_full = -da1_full                                      # v2 endpoint
+                da1_arc = da1_full[mask_arc]
+                da2_arc = da2_full[mask_arc]
+
+                # dl/dtheta is ±r
+                dl1 = r
+                dl2 = -r
+
+                vop = vertex_out_points  # rows are sorted [i,j]; column 1 is max(i,j)
+                if np.any(valid1):
+                    k1v = k1[valid1]
+                    # CORRECT which_point: 0 if max(i,j) > idx else 1
+                    which1 = (vop[k1v, 1] <= idx).astype(int)
+                    vertex_out_da_dtheta[k1v, which1] = da1_arc[valid1]
+                    vertex_out_dl_dtheta[k1v, which1] = dl1
+
+                if np.any(valid2):
+                    k2v = k2[valid2]
+                    which2 = (vop[k2v, 1] <= idx).astype(int)
+                    vertex_out_da_dtheta[k2v, which2] = da2_arc[valid2]
+                    vertex_out_dl_dtheta[k2v, which2] = dl2
+
+    return vertex_out_da_dtheta, vertex_out_dl_dtheta, dA_poly_dh, dP_poly_dh, area_list, perimeter_list

pyafv/{finite_voronoi_fast.py → finite_voronoi.py}

@@ -12,16 +12,14 @@ Key public entry points:
 - update_params(): update physical parameters.
 """
 
-from typing import Dict, List, Tuple, Optional
+from typing import Dict, List, Tuple, Optional, Literal
 import numpy as np
 from scipy.spatial import Voronoi
 from matplotlib import pyplot as plt
 from matplotlib.axes import Axes
 
 from .physical_params import PhysicalParams
-
-from .cell_geom import build_vertexpair_and_vertexpoints_cy
-from .cell_geom import pad_regions_cy, build_point_edges_cy, compute_vertex_derivatives_cy
+from .backend import backend_impl, _BACKEND_NAME
 
 
 # ---- tiny helpers to avoid tiny allocations in hot loops ----
@@ -31,10 +29,57 @@ def _row_dot(a: np.ndarray, b: np.ndarray) -> np.ndarray:
 
 
 class FiniteVoronoiSimulator:
-    def __init__(self, pts: np.ndarray, phys: PhysicalParams):
+    """Simulator for the active-finite-Voronoi (AFV) model.
+
+    This class provides an interface to simulate finite Voronoi models.
+    It wraps around the two backend implementations, which may be
+    either a Cython-accelerated version or a pure Python fallback.
+
+    """
+
+    def __init__(self, pts: np.ndarray, phys: PhysicalParams, backend: Optional[Literal["cython", "python"]] = None):
+        """
+        Constructor of the simulator.
+        Generates a warning if the pure Python implementation is used unless explicitly requested.
+
+        :param pts: (N,2) array of initial cell center positions.
+        :type pts: numpy.ndarray
+        
+        :param phys: Physical parameters used within this simulator.
+        :type phys: PhysicalParams
+
+        :param backend: Optional, specify "python" to force the use of the pure Python fallback implementation.
+        :type backend: str or None
+        """
+        pts = np.asarray(pts, dtype=float)
+        N, dim = pts.shape
+        if dim != 2:
+            raise ValueError("pts must have shape (N,2)")
+        if not isinstance(phys, PhysicalParams):
+            raise TypeError("phys must be an instance of PhysicalParams")
+        
         self.pts = pts.copy()            # (N,2) array of initial points
-        self.N = pts.shape[0]            # Number of points
+        self.N = N                       # Number of points
         self.phys = phys
+        
+        if backend != "python":
+            self._BACKEND = _BACKEND_NAME
+            self._impl = backend_impl
+
+            if self._BACKEND not in {"cython", "numba"}:                 # pragma: no cover
+                # raise warning to inform user about fallback
+                import warnings
+                warnings.warn(
+                    "Could not import the Cython-built extension module. "
+                    "Falling back to the pure Python implementation, which may be slower. "
+                    "To enable the accelerated version, ensure that all dependencies are installed.",
+                    RuntimeWarning,
+                    stacklevel=2,
+                )
+        else:  # force the use of the pure Python fallback implementation.
+            self._BACKEND = "python"
+            from . import cell_geom_fallback as _impl
+            self._impl = _impl
 
     # --------------------- Voronoi construction & extension ---------------------
     def _build_voronoi_with_extensions(self) -> Tuple[Voronoi, np.ndarray, List[List[int]], int, Dict[Tuple[int,int], int], Dict[int, List[int]]]:
@@ -189,8 +234,8 @@ class FiniteVoronoiSimulator:
             # number of native (finite) vertices
             num_vertices = len(vor.vertices)
 
-        # Build vertexpair2ridge and vertex_points using Cython function
-        vertexpair2ridge, vertex_points = build_vertexpair_and_vertexpoints_cy(ridge_vertices_all, vor.ridge_points, num_vertices, N)
+        # Build vertexpair2ridge and vertex_points using Cython/Python backend function
+        vertexpair2ridge, vertex_points = self._impl.build_vertexpair_and_vertexpoints(ridge_vertices_all, vor.ridge_points, num_vertices, N)
 
         return vor, vertices_all, ridge_vertices_all, num_vertices, vertexpair2ridge, vertex_points
 
@@ -339,8 +384,8 @@ class FiniteVoronoiSimulator:
         # --------------------------------------------------
         # Part 1 in Cython
         # --------------------------------------------------
-        vor_regions = pad_regions_cy(vor.regions)            # (R, Kmax) int64 with -1 padding
-        point_edges_type, point_vertices_f_idx = build_point_edges_cy(
+        vor_regions = self._impl.pad_regions(vor.regions)            # (R, Kmax) int64 with -1 padding
+        point_edges_type, point_vertices_f_idx = self._impl.build_point_edges(
             vor_regions, vor.point_region.astype(np.int64),
             vertices_all.astype(np.float64), pts.astype(np.float64),
             int(num_vertices), vertexpair2ridge, 
@@ -351,7 +396,7 @@ class FiniteVoronoiSimulator:
         # --------------------------------------------------
         # Part 2 in Cython
         # --------------------------------------------------
-        vertex_out_da_dtheta, vertex_out_dl_dtheta, dA_poly_dh, dP_poly_dh, area_list, perimeter_list = compute_vertex_derivatives_cy(
+        vertex_out_da_dtheta, vertex_out_dl_dtheta, dA_poly_dh, dP_poly_dh, area_list, perimeter_list = self._impl.compute_vertex_derivatives(
             point_edges_type,            # list-of-lists / arrays of edge types
             point_vertices_f_idx,        # list-of-lists / arrays of vertex ids
             vertices_all.astype(np.float64, copy=False),
@@ -608,14 +653,26 @@ class FiniteVoronoiSimulator:
         return F
 
     # --------------------- One integration step ---------------------
-    def build(self) -> Dict:
-        """
+    def build(self) -> dict:
+        """ Build the finite-Voronoi structure and compute forces, returning a dictionary of diagnostics.
+
         Do the following:
           - Build Voronoi (+ extensions)
           - Get cell connectivity
           - Compute per-cell quantities and derivatives
           - Assemble forces
-        Returns a dictionary of diagnostics.
+        
+
+        :return: A dictionary containing the geometric properties:
+        
+            * **forces**: (N,2) array of forces on cell centers
+            * **areas**: (N,) array of cell areas
+            * **perimeters**: (N,) array of cell perimeters
+            * **vertices**: (M,2) array of all Voronoi + extension vertices
+            * **edges_type**: list-of-lists of edge types per cell (1=straight, 0=circular arc)
+            * **regions**: list-of-lists of vertex indices per cell
+            * **connections**: (M',2) array of connected cell index pairs
+        :rtype: dict
         """
         (vor, vertices_all, ridge_vertices_all, num_vertices,
             vertexpair2ridge, vertex_points) = self._build_voronoi_with_extensions()
@@ -652,18 +709,17 @@ class FiniteVoronoiSimulator:
     # --------------------- 2D plotting utilities ---------------------
     def plot_2d(self, ax: Optional[Axes] = None, show: bool = False) -> Axes:
         """
-        Build the Voronoi(+extensions) and render a 2D snapshot.
-
-        Parameters
-        ----------
-        ax : matplotlib.axes.Axes or None
-            If provided, draw into this axes; otherwise get the current axes.
-        show : bool
-            Whether to call plt.show() at the end.
-
-        Returns
-        -------
-        ax : matplotlib.axes.Axes
+        Build the finite-Voronoi structure and render a 2D snapshot.
+
+        Basically a wrapper of :py:func:`build()` function + plot.
+
+        :param ax: If provided, draw into this axes; otherwise get the current axes.
+        :type ax: matplotlib.axes.Axes or None
+        :param show: Whether to call plt.show() at the end.
+        :type show: bool
+
+        :return: The matplotlib axes containing the plot.
+        :rtype: matplotlib.axes.Axes
         """
         (vor, vertices_all, ridge_vertices_all, num_vertices,
             vertexpair2ridge, vertex_points) = self._build_voronoi_with_extensions()
@@ -787,16 +843,27 @@ class FiniteVoronoiSimulator:
     def update_positions(self, pts: np.ndarray) -> None:
         """
         Update cell center positions.
+
+        :param pts: ndarray of shape (N,2)
+        :type pts: numpy.ndarray
         """
-        self.N, dim = pts.shape
+        pts = np.asarray(pts, dtype=float)
+        N, dim = pts.shape
         if dim != 2:
-            raise ValueError("Positions must have shape (N,2)")
+            raise ValueError("pts must have shape (N,2)")
         
         self.pts = pts
+        self.N = N
 
     # --------------------- Update physical parameters ---------------------
     def update_params(self, phys: PhysicalParams) -> None:
         """
         Update physical parameters.
+
+        :param phys: PhysicalParams object
+        :type phys: PhysicalParams
         """
+        if not isinstance(phys, PhysicalParams):
+            raise TypeError("phys must be an instance of PhysicalParams")
+        
         self.phys = phys

pyafv/physical_params.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import numpy as np
 from scipy.optimize import minimize
 from dataclasses import dataclass, replace
@@ -15,30 +16,63 @@ def sigmoid(x):
 
 @dataclass(frozen=True)
 class PhysicalParams:
-    # Radius (maximal) of the Voronoi cells
+    """Physical parameters for the active-finite-Voronoi (AFV) model.
+    
+    Caveat:
+        Frozen dataclass is used to ensure immutability of instances.
+    """
+    
     r: float = 1.0
-    A0: float = np.pi                    # Preferred area of the Voronoi cells
-    P0: float = 4.8                      # Preferred perimeter of the Voronoi cells
-    KA: float = 1.0                      # Area elasticity
-    KP: float = 1.0                      # Perimeter elasticity
-    lambda_tension: float = 0.2          # Tension difference
-    delta: float = 0.                    # Small offset to avoid singularities
-
-    def get_steady_state(self):
-        # compute steady-state (l,d) given physical params
+    """Radius (maximal) of the Voronoi cells."""
+
+    A0: float = np.pi
+    """Preferred area of the Voronoi cells."""
+    
+    P0: float = 4.8
+    """Preferred perimeter of the Voronoi cells."""
+
+    KA: float = 1.0
+    """Area elasticity constant."""
+
+    KP: float = 1.0
+    """Perimeter elasticity constant."""
+
+    lambda_tension: float = 0.2
+    """Tension difference between non-contacting edges and contacting edges."""
+
+    delta: float = 0.0
+    """Small offset to avoid singularities in computations."""
+
+    def get_steady_state(self) -> tuple[float, float]:
+        """Compute steady-state (l,d) given physical params.
+        
+        :return: Tuple of (l, d) at steady state.
+        :rtype: tuple[float, float]
+        """
         params = [self.KA, self.KP, self.A0, self.P0, self.lambda_tension]
         result = self._minimize_energy(params, restarts=10)
         l, d = result[0]
         return l, d
 
-    def with_optimal_radius(self):
-        """Returns a new instance with the radius updated to steady state."""
+    def with_optimal_radius(self) -> PhysicalParams:
+        """Returns a new instance with the radius updated to steady state.
+        
+        :return: New instance with optimal radius.
+        :rtype: PhysicalParams
+        """
         l, d = self.get_steady_state()
         new_params = replace(self, r=l)
         return new_params
 
-    def with_delta(self, delta_new: float):
-        """Returns a new instance with the specified delta."""
+    def with_delta(self, delta_new: float) -> PhysicalParams:
+        """Returns a new instance with the specified delta.
+        
+        :param delta_new: New delta value.
+        :type delta_new: float
+
+        :return: New instance with updated delta.
+        :rtype: PhysicalParams
+        """
         return replace(self, delta=delta_new)
 
     def _energy_unconstrained(self, z, params):
@@ -81,6 +115,15 @@ class PhysicalParams:
 def target_delta(params: PhysicalParams, target_force: float) -> float:
     """
     Given physical parameters and a target detachment force, compute the corresponding delta.
+
+    :param params: Physical parameters of the AFV model.
+    :type params: PhysicalParams
+
+    :param target_force: Target detachment force.
+    :type target_force: float
+
+    :return: Corresponding delta value.
+    :rtype: float
     """
     KP, A0, P0, Lambda = params.KP, params.A0, params.P0, params.lambda_tension
     l = params.r

{pyafv-0.3.3.dist-info → pyafv-0.3.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyafv
-Version: 0.3.3
+Version: 0.3.4
 Summary: Python implementation of the active-finite-Voronoi (AFV) model
 Author-email: "Wei Wang (汪巍)" <ww000721@gmail.com>
 License-Expression: MIT
@@ -48,11 +48,16 @@ The AFV framework was introduced and developed in, for example, Refs. [[1](#huan
 
 ## Installation
 
-Install **PyAFV** with:
+To install **PyAFV** with `pip`, run:
 ```bash
 pip install pyafv
 ```
-This package requires Python ≥ 3.9 and < 3.15.
+The package supports Python ≥ 3.9 and < 3.15.
+To verify that the installation was successful and that the correct version is installed, run the following in Python:
+```python
+import pyafv
+print(pyafv.__version__)
+```
 
 
 ## Usage
@@ -85,6 +90,7 @@ See important [**issues**](https://github.com/wwang721/pyafv/issues?q=is%3Aissue
 *  [Add customized plotting to examples illustrating access to vertices and edges #5](https://github.com/wwang721/pyafv/issues/5) [Completed in PR [#7](https://github.com/wwang721/pyafv/pull/7)]
 * [Time step dependence of intercellular adhesion in simulations #8](https://github.com/wwang721/pyafv/issues/8) [Closed in PR [#9](https://github.com/wwang721/pyafv/pull/9)]
 
+Full documentation on [readthedocs](https://pyafv.readthedocs.io/en/latest/)!
 
 ## References
 

pyafv-0.3.4.dist-info/RECORD

@@ -0,0 +1,12 @@
+pyafv/__init__.py,sha256=3opuTLXyu3ry_Gzxjlb4PFygGOzS-m3NOADkII9B-Mk,540
+pyafv/_version.py,sha256=oAsKh6W1X21Eok94R7mDW45wpERdFHwJKBZAJCO4paw,42
+pyafv/backend.py,sha256=O15-rtzPQvTl_fIyZu4L0LU8UG4uRnAuq4bi5HBlKy8,418
+pyafv/cell_geom.cpython-312-x86_64-linux-musl.so,sha256=6pzMkPrCjNqS2SrSrs5B1IUhPTCanBfyXcBemAyticA,1831992
+pyafv/cell_geom_fallback.py,sha256=teA-qK38eiHMdhM8ULRBCYWccNPLp17PRS_jEl1uGjU,9127
+pyafv/finite_voronoi.py,sha256=JA3o9RctDQ6l8keEeu0UcHp33DdoEdEg6fvyCUAOZdI,39148
+pyafv/physical_params.py,sha256=3Ryf2Jcm1xQuRNdR1yunTChjnG3UveyIpfXFA9gG10A,4823
+pyafv-0.3.4.dist-info/METADATA,sha256=N6cBcjMiU9eTk0E_5hS3wOrynU1FgDpymFeFgZxEd8M,5390
+pyafv-0.3.4.dist-info/WHEEL,sha256=AwHYJA1Do1jwgPIoLQR4DiHSeYY_vU6Ht9Vljq5Yt_M,112
+pyafv-0.3.4.dist-info/top_level.txt,sha256=mrKQNqc4GQxuZ7hd5UrKxbA_AJsuSqiJyMxL7Nu7va0,6
+pyafv-0.3.4.dist-info/RECORD,,
+pyafv-0.3.4.dist-info/licenses/LICENSE,sha256=TNjxBxdiOzyewn2FP7g1FjW3CJoxiGCY6ShPVFv02G8,1065