fullwave25 1.2.5.dev0__tar.gz → 1.2.6.dev0__tar.gz

{fullwave25-1.2.5.dev0 → fullwave25-1.2.6.dev0}/.bumpversion.toml

@@ -1,5 +1,5 @@
 [tool.bumpversion]
-current_version = "1.2.5-dev0"
+current_version = "1.2.6-dev0"
 parse = """(?x)
     (?P<major>0|[1-9]\\d*)\\.
     (?P<minor>0|[1-9]\\d*)\\.

{fullwave25-1.2.5.dev0 → fullwave25-1.2.6.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fullwave25
-Version: 1.2.5.dev0
+Version: 1.2.6.dev0
 Summary: Fullwave 2.5: Ultrasound wave propagation simulation with heterogeneous power law attenuation modelling capabilities
 Author: Masashi Sode, Gianmarco Pinton
 Maintainer: Masashi Sode

{fullwave25-1.2.5.dev0 → fullwave25-1.2.6.dev0}/fullwave/__init__.py

@@ -60,7 +60,7 @@ try:
     __version__ = version("fullwave")
 except PackageNotFoundError:
     # Update via bump-my-version, not manually
-    __version__ = "1.2.5-dev0"
+    __version__ = "1.2.6-dev0"
 
 VERSION = __version__  # for convenience
 logger.info("Fullwave version: %s", __version__)

{fullwave25-1.2.5.dev0 → fullwave25-1.2.6.dev0}/fullwave/solver/binary_manager.py

@@ -28,7 +28,7 @@ CACHE_DIR = Path.home() / ".cache" / "fullwave25" / "bins"
 
 # Pinned release tag for the solver binaries.
 # Update this only when new binaries are uploaded to a GitHub release.
-BINARY_RELEASE_TAG = "fullwave_bin_v1.1"
+BINARY_RELEASE_TAG = "fullwave_bin_v1.2"
 
 
 def _download_url(filename: str, tag: str) -> str:

{fullwave25-1.2.5.dev0 → fullwave25-1.2.6.dev0}/fullwave/solver/input_file_writer.py

@@ -169,6 +169,19 @@ class InputFileWriter:
             )
         if incoords_add is not None:
             self._queue_coords_write(simulation_dir / "icc_add.dat", incoords_add)
+        for _vel_suffix, _vel_attr in (("u", "u0"), ("v", "v0"), ("w", "w0")):
+            _signal_vel = getattr(self.source, _vel_attr, None)
+            _incoords_vel = getattr(self.source, f"incoords_{_vel_suffix}", None)
+            if _signal_vel is not None:
+                self._queue_ic_write(
+                    simulation_dir / f"icmat_{_vel_suffix}.dat",
+                    np.transpose(_signal_vel),
+                )
+            if _incoords_vel is not None:
+                self._queue_coords_write(
+                    simulation_dir / f"icc_{_vel_suffix}.dat",
+                    _incoords_vel,
+                )
         self._queue_coords_write(simulation_dir / "icc.dat", self.source.incoords)
         self._copy_simulation_bin_file(simulation_dir)
 
@@ -1047,6 +1060,10 @@ class InputFileWriter:
         n_sources_add = getattr(self.source, "n_sources_add", 0)
         if n_sources_add > 0:
             var_list.append(("ncoords_add", n_sources_add))
+        for _vel_suffix in ("u", "v", "w"):
+            _n_vel = getattr(self.source, f"n_sources_{_vel_suffix}", 0)
+            if _n_vel > 0:
+                var_list.append((f"ncoords_{_vel_suffix}", _n_vel))
         if self.is_3d:
             var_list.extend(
                 [

{fullwave25-1.2.5.dev0 → fullwave25-1.2.6.dev0}/fullwave/solver/pml_builder.py

@@ -322,12 +322,33 @@ class PMLBuilder:
             if getattr(self.source_org, "incoords_add", None) is not None
             else None
         )
+        incoords_u_ext = (
+            self.source_org.incoords_u + self.num_boundary_points
+            if getattr(self.source_org, "incoords_u", None) is not None
+            else None
+        )
+        incoords_v_ext = (
+            self.source_org.incoords_v + self.num_boundary_points
+            if getattr(self.source_org, "incoords_v", None) is not None
+            else None
+        )
+        incoords_w_ext = (
+            self.source_org.incoords_w + self.num_boundary_points
+            if getattr(self.source_org, "incoords_w", None) is not None
+            else None
+        )
         self.extended_source = fullwave.Source(
             p0=self.source_org.p0,
             coords=self.source_org.incoords + self.num_boundary_points,
             grid_shape=extended_grid_shape,
             p0_additive=self.source_org.p0_additive,
             coords_additive=incoords_add_ext,
+            u0=getattr(self.source_org, "u0", None),
+            coords_u=incoords_u_ext,
+            v0=getattr(self.source_org, "v0", None),
+            coords_v=incoords_v_ext,
+            w0=getattr(self.source_org, "w0", None),
+            coords_w=incoords_w_ext,
         )
         logger.debug("building extended source for pml...done")
 
@@ -1434,7 +1455,7 @@ class PMLBuilder:
 class PMLBuilderExponentialAttenuation(PMLBuilder):
     """A class to set up PML for exponential attenuation media."""
 
-    def __init__(
+    def __init__(  # noqa: PLR0915
         self,
         grid: fullwave.Grid,
         medium: fullwave.Medium,
@@ -1594,12 +1615,33 @@ class PMLBuilderExponentialAttenuation(PMLBuilder):
             if getattr(self.source_org, "incoords_add", None) is not None
             else None
         )
+        incoords_u_ext = (
+            self.source_org.incoords_u + self.num_boundary_points
+            if getattr(self.source_org, "incoords_u", None) is not None
+            else None
+        )
+        incoords_v_ext = (
+            self.source_org.incoords_v + self.num_boundary_points
+            if getattr(self.source_org, "incoords_v", None) is not None
+            else None
+        )
+        incoords_w_ext = (
+            self.source_org.incoords_w + self.num_boundary_points
+            if getattr(self.source_org, "incoords_w", None) is not None
+            else None
+        )
         self.extended_source = fullwave.Source(
             p0=self.source_org.p0,
             coords=self.source_org.incoords + self.num_boundary_points,
             grid_shape=extended_grid_shape,
             p0_additive=self.source_org.p0_additive,
             coords_additive=incoords_add_ext,
+            u0=getattr(self.source_org, "u0", None),
+            coords_u=incoords_u_ext,
+            v0=getattr(self.source_org, "v0", None),
+            coords_v=incoords_v_ext,
+            w0=getattr(self.source_org, "w0", None),
+            coords_w=incoords_w_ext,
         )
         extended_sensor_grid_shape = tuple(
             s + 2 * self.num_boundary_points for s in self.sensor_org.grid_shape

{fullwave25-1.2.5.dev0 → fullwave25-1.2.6.dev0}/fullwave/source.py

@@ -23,6 +23,12 @@ class Source:
     grid_shape: tuple[int, ...]
     p0_additive: NDArray[np.float64] | None = None
     incoords_add: NDArray[np.int64] | None = None
+    u0: NDArray[np.float64] | None = None
+    incoords_u: NDArray[np.int64] | None = None
+    v0: NDArray[np.float64] | None = None
+    incoords_v: NDArray[np.int64] | None = None
+    w0: NDArray[np.float64] | None = None
+    incoords_w: NDArray[np.int64] | None = None
 
     def __init__(  # noqa: C901 PLR0912 PLR0915
         self,
@@ -37,6 +43,16 @@ class Source:
         coords_additive: NDArray[np.int64] | None = None,
         # ---
         grid_shape: tuple[int, ...] | None = None,
+        # --- velocity source components ---
+        u0: NDArray[np.float64] | None = None,
+        coords_u: NDArray[np.int64] | None = None,
+        mask_u: NDArray[np.bool] | None = None,
+        v0: NDArray[np.float64] | None = None,
+        coords_v: NDArray[np.int64] | None = None,
+        mask_v: NDArray[np.bool] | None = None,
+        w0: NDArray[np.float64] | None = None,
+        coords_w: NDArray[np.int64] | None = None,
+        mask_w: NDArray[np.bool] | None = None,
     ) -> None:
         """Source class for Fullwave.
 
@@ -44,8 +60,9 @@ class Source:
         ----------
         p0 : NDArray[np.float64] | None
             Time-varying pressure at each source position; shape [n_sources, nt].
-            If None, p0_additive must be provided (additive-only / soft initial condition):
-            icmat is written as zeros and only the additive term drives the source.
+            If None, either p0_additive or a velocity component (u0/v0/w0) must be provided.
+            When omitted with a velocity-only source, the pressure node list is empty
+            and icmat is written as a zero-row matrix.
         mask : NDArray[np.bool] | None
             binary matrix specifying the positions of the time varying pressure source distribution
             shape: [nx, ny] for 2D, [nx, ny, nz] for 3D.
@@ -54,7 +71,7 @@ class Source:
             Coordinate array of source positions (hard source); shape [n_sources, ndim].
             Must be provided together with grid_shape.
         grid_shape : tuple[int, ...] | None
-            Shape of the computational grid. Required when using coords input.
+            Shape of the computational grid. Required when using coords or velocity-only input.
         p0_additive : NDArray[np.float64] | None
             Optional additive (soft) source term; shape [n_sources_add, nt].
             When provided, positions come from coords_additive or mask_additive,
@@ -66,15 +83,36 @@ class Source:
             Coordinates for the additive source; shape [n_sources_add, ndim].
             If None and p0_additive is provided, defaults to primary incoords.
             Mutually exclusive with mask_additive.
+        u0 : NDArray[np.float64] | None
+            Time-varying velocity in the depth (x) direction; shape [n_sources_u, nt].
+        coords_u : NDArray[np.int64] | None
+            Coordinates for the u-velocity source; shape [n_sources_u, ndim].
+            Mutually exclusive with mask_u.
+        mask_u : NDArray[np.bool] | None
+            Boolean mask for u-velocity source positions. Mutually exclusive with coords_u.
+        v0 : NDArray[np.float64] | None
+            Time-varying velocity in the lateral (y) direction; shape [n_sources_v, nt].
+        coords_v : NDArray[np.int64] | None
+            Coordinates for the v-velocity source; shape [n_sources_v, ndim].
+            Mutually exclusive with mask_v.
+        mask_v : NDArray[np.bool] | None
+            Boolean mask for v-velocity source positions. Mutually exclusive with coords_v.
+        w0 : NDArray[np.float64] | None
+            Time-varying velocity in the elevational (z) direction; shape [n_sources_w, nt].
+        coords_w : NDArray[np.int64] | None
+            Coordinates for the w-velocity source; shape [n_sources_w, ndim].
+            Mutually exclusive with mask_w.
+        mask_w : NDArray[np.bool] | None
+            Boolean mask for w-velocity source positions. Mutually exclusive with coords_w.
 
         Raises
         ------
         ValueError
-            If grid_shape is missing when using coords or additive-only.
+            If grid_shape is missing when using coords, additive-only, or velocity-only.
             If both mask and coords, or both coords_additive and mask_additive, are provided.
-            If primary source positions cannot be resolved (need coords+grid_shape,
-            or mask, or additive-only args).
-            If both p0 and p0_additive are None.
+            If primary source positions cannot be resolved (need coords+grid_shape, mask,
+            additive-only args, or at least one velocity component with grid_shape).
+            If all of p0, p0_additive, u0, v0, and w0 are None.
             If p0 / p0_additive row counts do not match their coordinate arrays.
 
         """
@@ -110,17 +148,28 @@ class Source:
                 mask_add = np.atleast_2d(mask_additive)
                 self.grid_shape = mask_add.shape
                 self.incoords = map_to_coords(mask_add)
+        elif u0 is not None or v0 is not None or w0 is not None:
+            # Velocity-only: no hard pressure nodes; pressure arrays will be empty
+            if grid_shape is None:
+                error_msg = "grid_shape is required for velocity-only source"
+                raise ValueError(error_msg)
+            self.grid_shape = tuple(grid_shape)
+            self.incoords = np.empty((0, len(self.grid_shape)), dtype=np.int64)
         else:
             error_msg = (
                 "Provide (coords + grid_shape), or mask, or"
-                " (p0_additive + (coords_additive or mask_additive))"
+                " (p0_additive + (coords_additive or mask_additive)), or"
+                " a velocity component (u0/v0/w0) with grid_shape"
             )
             raise ValueError(
                 error_msg,
             )
 
-        if p0 is None and p0_additive is None:
-            error_msg = "At least one of p0 or p0_additive must be provided"
+        if p0 is None and p0_additive is None and u0 is None and v0 is None and w0 is None:
+            error_msg = (
+                "At least one of p0, p0_additive, or a velocity component"
+                " (u0/v0/w0) must be provided"
+            )
             raise ValueError(error_msg)
 
         # --- Resolve additive coords (for later use) ---
@@ -148,7 +197,7 @@ class Source:
                 )
                 raise ValueError(error_msg)
             self.p0_additive = np.atleast_2d(p0_additive) if p0_additive is not None else None
-        else:
+        elif p0_additive is not None:
             # Additive-only: icmat written as zeros
             p0_add = np.atleast_2d(p0_additive)
             n_add = _coords_add.shape[0] if _coords_add is not None else self.incoords.shape[0]
@@ -166,6 +215,12 @@ class Source:
                     dtype=np.float64,
                 )
             self.p0_additive = p0_add
+        else:
+            # Velocity-only: no pressure nodes; derive nt from the first velocity signal
+            _first_vel = next(s for s in (u0, v0, w0) if s is not None)
+            nt_vel = np.atleast_2d(_first_vel).shape[1]
+            self.p0 = np.zeros((0, nt_vel), dtype=np.float64)
+            self.p0_additive = None
 
         # --- Set incoords_add for writer/binary ---
         if self.p0_additive is not None:
@@ -173,6 +228,11 @@ class Source:
         else:
             self.incoords_add = None
 
+        # --- Resolve velocity source components ---
+        self.incoords_u, self.u0 = self._resolve_velocity_component("u", u0, coords_u, mask_u)
+        self.incoords_v, self.v0 = self._resolve_velocity_component("v", v0, coords_v, mask_v)
+        self.incoords_w, self.w0 = self._resolve_velocity_component("w", w0, coords_w, mask_w)
+
         self.is_3d = len(self.grid_shape) == 3
         super().__init__()
         self.__post_init__()
@@ -202,11 +262,64 @@ class Source:
                 )
                 raise ValueError(error_msg)
 
+    @staticmethod
+    def _resolve_velocity_component(
+        name: str,
+        signal: NDArray | None,
+        coords: NDArray | None,
+        mask: NDArray | None,
+    ) -> tuple[NDArray | None, NDArray | None]:
+        """Resolve a velocity source component to (incoords, signal_arr).
+
+        Returns
+        -------
+        tuple[NDArray | None, NDArray | None]
+            (incoords, signal_arr) if the component is provided, else (None, None).
+
+        Raises
+        ------
+        ValueError
+            If coords and mask are both provided.
+            If signal is provided but neither coords nor mask are given.
+            If signal is None but coords/mask are provided.
+            If signal row count does not match the number of coordinate points.
+
+        """
+        if signal is None:
+            if coords is not None or mask is not None:
+                error_msg = f"coords_{name}/mask_{name} provided without {name}0 signal"
+                raise ValueError(error_msg)
+            return None, None
+        if coords is not None and mask is not None:
+            error_msg = f"coords_{name} and mask_{name} are mutually exclusive"
+            raise ValueError(error_msg)
+        if coords is None and mask is None:
+            error_msg = f"{name}0 signal provided but neither coords_{name} nor mask_{name} given"
+            raise ValueError(error_msg)
+        if coords is not None:
+            incoords = np.atleast_2d(coords).astype(np.int64, copy=False)
+        else:
+            incoords = map_to_coords(np.atleast_2d(mask))
+        signal_arr = np.atleast_2d(signal)
+        if signal_arr.shape[0] != incoords.shape[0]:
+            error_msg = (
+                f"{name}0 has {signal_arr.shape[0]} rows but "
+                f"coords_{name}/mask_{name} has {incoords.shape[0]} (must match)"
+            )
+            raise ValueError(error_msg)
+        return incoords, signal_arr
+
     def validate(self, grid_shape: NDArray[np.int64] | tuple) -> None:
         """Check if the source coordinates are consistent with the grid shape."""
         grid_shape = tuple(grid_shape) if isinstance(grid_shape, np.ndarray) else grid_shape
         assert self.grid_shape == grid_shape, f"{self.grid_shape} != {grid_shape}"
-        assert self.n_sources > 0 or self.n_sources_add > 0, "No active source found."
+        assert (
+            self.n_sources > 0
+            or self.n_sources_add > 0
+            or self.n_sources_u > 0
+            or self.n_sources_v > 0
+            or self.n_sources_w > 0
+        ), "No active source found."
         logger.debug("Source validated against grid shape.")
 
     @property
@@ -246,6 +359,21 @@ class Source:
             return 0
         return self.incoords_add.shape[0]
 
+    @property
+    def n_sources_u(self) -> int:
+        """Return the number of velocity-u (depth) source positions."""
+        return self.incoords_u.shape[0] if self.incoords_u is not None else 0
+
+    @property
+    def n_sources_v(self) -> int:
+        """Return the number of velocity-v (lateral) source positions."""
+        return self.incoords_v.shape[0] if self.incoords_v is not None else 0
+
+    @property
+    def n_sources_w(self) -> int:
+        """Return the number of velocity-w (elevational) source positions."""
+        return self.incoords_w.shape[0] if self.incoords_w is not None else 0
+
     def plot(
         self,
         export_path: Path | str | None = Path("./temp/temp.png"),
@@ -312,6 +440,13 @@ class Source:
             lines.append(f"  p0_additive shape: {self.p0_additive.shape}")
         if self.incoords_add is not None:
             lines.append(f"  incoords_add: {self.incoords_add.shape[0]} points")
+        for comp, sig, n in (
+            ("u", self.u0, self.n_sources_u),
+            ("v", self.v0, self.n_sources_v),
+            ("w", self.w0, self.n_sources_w),
+        ):
+            if sig is not None:
+                lines.append(f"  {comp}0 shape: {sig.shape} ({n} points)")
         return "\n".join(lines) + "\n"
 
     def __repr__(self) -> str:

{fullwave25-1.2.5.dev0 → fullwave25-1.2.6.dev0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fullwave25"
-version = "1.2.5-dev0" # Update via bump-my-version, not manually
+version = "1.2.6-dev0" # Update via bump-my-version, not manually
 description = "Fullwave 2.5: Ultrasound wave propagation simulation with heterogeneous power law attenuation modelling capabilities"
 readme = "README.md"
 requires-python = ">=3.10"

{fullwave25-1.2.5.dev0 → fullwave25-1.2.6.dev0}/uv.lock

@@ -735,7 +735,7 @@ wheels = [
 
 [[package]]
 name = "fullwave25"
-version = "1.2.5.dev0"
+version = "1.2.6.dev0"
 source = { editable = "." }
 dependencies = [
     { name = "joblib" },