fullwave25 1.2.3.dev1__tar.gz → 1.2.3rc1__tar.gz

{fullwave25-1.2.3.dev1 → fullwave25-1.2.3rc1}/.bumpversion.toml

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

{fullwave25-1.2.3.dev1 → fullwave25-1.2.3rc1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fullwave25
-Version: 1.2.3.dev1
+Version: 1.2.3rc1
 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.3.dev1 → fullwave25-1.2.3rc1}/fullwave/__init__.py

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

{fullwave25-1.2.3.dev1 → fullwave25-1.2.3rc1}/fullwave/grid.py

@@ -183,9 +183,9 @@ class Grid:
             else "  Grid spacing (grid.dx, grid.dy): "
         )
         grid_spacing_str = (
-            f"({self.dx * 1e3:.2e} m, {self.dy * 1e3:.2e} m, {self.dz * 1e3:.2e} m)"
+            f"({self.dx * 1e3:.2e} mm, {self.dy * 1e3:.2e} mm, {self.dz * 1e3:.2e} mm)"
             if self.is_3d
-            else f"({self.dx * 1e3:.2e} m, {self.dy * 1e3:.2e} m)"
+            else f"({self.dx * 1e3:.2e} mm, {self.dy * 1e3:.2e} mm)"
         )
 
         num_grid_points_str_desc = (
@@ -203,7 +203,7 @@ class Grid:
             f"  Speed of sound (grid.c0): {self.c0} m/s\n"
             f"  Points per wavelength (PPW) (grid.ppw): {self.ppw}\n"
             f"  Courant-Friedrichs-Lewy (CFL) number (grid.cfl): {self.cfl}\n"
-            f"  Wavelength (grid.wavelength): {self.wavelength * 1e3:.2e} m\n"
+            f"  Wavelength (grid.wavelength): {self.wavelength * 1e3:.2e} mm\n"
             + grid_spacing_str_desc
             + grid_spacing_str
             + "\n"

{fullwave25-1.2.3.dev1 → fullwave25-1.2.3rc1}/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 = "v1.2.2"
+BINARY_RELEASE_TAG = "fullwave_bin_v1.1"
 
 
 def _download_url(filename: str, tag: str) -> str:

{fullwave25-1.2.3.dev1 → fullwave25-1.2.3rc1}/fullwave/solver/input_file_writer.py

@@ -160,6 +160,15 @@ class InputFileWriter:
             simulation_dir / "icmat.dat",
             np.transpose(self.source.icmat),
         )
+        p0_additive = getattr(self.source, "p0_additive", None)
+        incoords_add = getattr(self.source, "incoords_add", None)
+        if p0_additive is not None:
+            self._queue_ic_write(
+                simulation_dir / "icmat_add.dat",
+                np.transpose(p0_additive),
+            )
+        if incoords_add is not None:
+            self._queue_coords_write(simulation_dir / "icc_add.dat", incoords_add)
         self._queue_coords_write(simulation_dir / "icc.dat", self.source.incoords)
         self._copy_simulation_bin_file(simulation_dir)
 
@@ -1035,6 +1044,9 @@ class InputFileWriter:
             ("nTic", nt_ic),
             ("modT", self.sensor.sampling_modulus_time),
         ]
+        n_sources_add = getattr(self.source, "n_sources_add", 0)
+        if n_sources_add > 0:
+            var_list.append(("ncoords_add", n_sources_add))
         if self.is_3d:
             var_list.extend(
                 [

{fullwave25-1.2.3.dev1 → fullwave25-1.2.3rc1}/fullwave/solver/launcher.py

@@ -30,6 +30,7 @@ class Launcher:
         is_3d: bool = False,
         use_gpu: bool = True,
         cuda_device_id: str | int | list | None = None,
+        save_gpu_memory: bool = False,
     ) -> None:
         """Initialize a FullwaveLauncher instance.
 
@@ -50,6 +51,17 @@ class Launcher:
             for multiple GPUs, provide a list of device IDs.
             example 1: [0, 1] for using GPU 0 and GPU 1. or "0,1" as a string.
             example 2: 2 for using GPU 2 or "2" as a string.
+        save_gpu_memory : bool, optional
+            Whether to save GPU memory by using ICMAT_MEMORY_SAVING flag in the simulation.
+            The simulation does not load initial conditions into GPU memory and
+            it loads the slice of the wavefield needed for the current time step
+            from CPU memory at each time step.
+            Defaults to False. If True, it may significantly reduce GPU memory usage,
+            but it may also increase the simulation time
+            due to the overhead of data transfer between CPU and GPU
+            depending on the hardware and the simulation settings.
+            useful in 3D simulations with large grid sizes
+            where GPU memory is a limiting factor.
 
         """
         self._path_fullwave_simulation_bin = path_fullwave_simulation_bin
@@ -58,6 +70,7 @@ class Launcher:
         self.is_3d = is_3d
         self.use_gpu = use_gpu
         self.cuda_device_id = self._configure_cuda_device_id(cuda_device_id)
+        self.save_gpu_memory = save_gpu_memory
         logger.debug("Launcher instance created.")
 
     @staticmethod
@@ -203,7 +216,12 @@ class Launcher:
             logger.info("Running simulation...")
             with (simulation_dir / "fw2_execution.log").open("w", encoding="utf-8") as file:
                 time_start = time()
-                os.environ["CUDA_VISIBLE_DEVICES"] = self.cuda_device_id
+                env = os.environ.copy()
+                env["CUDA_VISIBLE_DEVICES"] = self.cuda_device_id
+                if self.save_gpu_memory:
+                    env["ICMAT_MEMORY_SAVING"] = "1"
+                else:
+                    env["ICMAT_MEMORY_SAVING"] = "0"
                 subprocess.run(  # noqa: S603
                     command,
                     check=True,
@@ -211,6 +229,7 @@ class Launcher:
                     stdout=file,
                     stderr=file,
                     text=True,
+                    env=env,
                     # check=False,
                 )
                 time_passed = time() - time_start

{fullwave25-1.2.3.dev1 → fullwave25-1.2.3rc1}/fullwave/solver/pml_builder.py

@@ -317,10 +317,17 @@ class PMLBuilder:
         extended_grid_shape = tuple(
             s + 2 * self.num_boundary_points for s in self.source_org.grid_shape
         )
+        incoords_add_ext = (
+            self.source_org.incoords_add + self.num_boundary_points
+            if getattr(self.source_org, "incoords_add", 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,
         )
         logger.debug("building extended source for pml...done")
 
@@ -1582,10 +1589,17 @@ class PMLBuilderExponentialAttenuation(PMLBuilder):
         extended_grid_shape = tuple(
             s + 2 * self.num_boundary_points for s in self.source_org.grid_shape
         )
+        incoords_add_ext = (
+            self.source_org.incoords_add + self.num_boundary_points
+            if getattr(self.source_org, "incoords_add", 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,
         )
         extended_sensor_grid_shape = tuple(
             s + 2 * self.num_boundary_points for s in self.sensor_org.grid_shape

{fullwave25-1.2.3.dev1 → fullwave25-1.2.3rc1}/fullwave/solver/solver.py

@@ -327,6 +327,7 @@ class Solver:
         use_exponential_attenuation: bool = False,
         use_isotropic_relaxation: bool = True,
         cuda_device_id: str | int | list | None = None,
+        save_gpu_memory: bool = False,
     ) -> None:
         """Initialize a Solver instance for the fullwave simulation.
 
@@ -402,6 +403,17 @@ class Solver:
             for multiple GPUs, provide a list of device IDs.
             example 1: [0, 1] for using GPU 0 and GPU 1. or "0,1" as a string.
             example 2: 2 for using GPU 2 or "2" as a string.
+        save_gpu_memory : bool, optional
+            Whether to save GPU memory by using ICMAT_MEMORY_SAVING flag in the simulation.
+            The simulation does not load initial conditions into GPU memory and
+            it loads the slice of the wavefield needed for the current time step
+            from CPU memory at each time step.
+            Defaults to False. If True, it may significantly reduce GPU memory usage,
+            but it may also increase the simulation time
+            due to the overhead of data transfer between CPU and GPU
+            depending on the hardware and the simulation settings.
+            useful in 3D simulations with large grid sizes
+            where GPU memory is a limiting factor.
 
         Raises
         ------
@@ -418,6 +430,7 @@ class Solver:
         self.medium: fullwave.Medium
         self.grid: fullwave.Grid
         self.input_file_writer: InputFileWriter
+        self.save_gpu_memory = save_gpu_memory
 
         self.run_on_memory = run_on_memory
         if run_on_memory:
@@ -540,6 +553,7 @@ class Solver:
             is_3d=self.is_3d,
             use_gpu=self.use_gpu,
             cuda_device_id=self.cuda_device_id,
+            save_gpu_memory=self.save_gpu_memory,
         )
 
         if use_exponential_attenuation:

fullwave25-1.2.3rc1/fullwave/source.py

@@ -0,0 +1,326 @@
+"""Source class for Fullwave."""
+
+import logging
+from dataclasses import dataclass
+from pathlib import Path
+
+import numpy as np
+from matplotlib import pyplot as plt
+from numpy.typing import NDArray
+
+from fullwave.utils import plot_utils
+from fullwave.utils.coordinates import coords_to_map, map_to_coords
+
+logger = logging.getLogger("__main__." + __name__)
+
+
+@dataclass
+class Source:
+    """Source class for Fullwave."""
+
+    p0: NDArray[np.float64]
+    incoords: NDArray[np.int64]
+    grid_shape: tuple[int, ...]
+    p0_additive: NDArray[np.float64] | None = None
+    incoords_add: NDArray[np.int64] | None = None
+
+    def __init__(  # noqa: C901 PLR0912 PLR0915
+        self,
+        p0: NDArray[np.float64] | None = None,
+        mask: NDArray[np.bool] | None = None,
+        *,
+        # ---
+        p0_additive: NDArray[np.float64] | None = None,
+        mask_additive: NDArray[np.bool] | None = None,
+        # ---
+        coords: NDArray[np.int64] | None = None,
+        coords_additive: NDArray[np.int64] | None = None,
+        # ---
+        grid_shape: tuple[int, ...] | None = None,
+    ) -> None:
+        """Source class for Fullwave.
+
+        Parameters
+        ----------
+        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.
+        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.
+            Mutually exclusive with coords/grid_shape.
+        coords : NDArray[np.int64] | None
+            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.
+        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,
+            or default to primary coords.
+        mask_additive : NDArray[np.bool] | None
+            Mask for additive source positions; shape matches grid_shape.
+            Mutually exclusive with coords_additive.
+        coords_additive : NDArray[np.int64] | None
+            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.
+
+        Raises
+        ------
+        ValueError
+            If grid_shape is missing when using coords or additive-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 p0 / p0_additive row counts do not match their coordinate arrays.
+
+        """
+        # --- Resolve primary source positions and grid_shape ---
+        if coords is not None:
+            if grid_shape is None:
+                error_msg = "grid_shape is required when using coords"
+                raise ValueError(error_msg)
+            if mask is not None:
+                error_msg = "mask and coords are mutually exclusive"
+                raise ValueError(error_msg)
+            self.incoords = np.atleast_2d(coords).astype(np.int64, copy=False)
+            self.grid_shape = tuple(grid_shape)
+        elif mask is not None:
+            mask = np.atleast_2d(mask)
+            self.grid_shape = mask.shape
+            self.incoords = map_to_coords(mask)
+        elif p0_additive is not None and (coords_additive is not None or mask_additive is not None):
+            # Additive-only: no primary mask/coords; use additive positions as primary
+            if coords_additive is not None:
+                if grid_shape is None:
+                    error_msg = "grid_shape is required for additive-only with coords_additive"
+                    raise ValueError(
+                        error_msg,
+                    )
+                self.incoords = np.atleast_2d(coords_additive).astype(
+                    np.int64,
+                    copy=False,
+                )
+                self.grid_shape = tuple(grid_shape)
+            else:
+                assert mask_additive is not None
+                mask_add = np.atleast_2d(mask_additive)
+                self.grid_shape = mask_add.shape
+                self.incoords = map_to_coords(mask_add)
+        else:
+            error_msg = (
+                "Provide (coords + grid_shape), or mask, or"
+                " (p0_additive + (coords_additive or mask_additive))"
+            )
+            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"
+            raise ValueError(error_msg)
+
+        # --- Resolve additive coords (for later use) ---
+        if coords_additive is not None and mask_additive is not None:
+            error_msg = "coords_additive and mask_additive are mutually exclusive"
+            raise ValueError(error_msg)
+        if coords_additive is not None:
+            _coords_add = np.atleast_2d(coords_additive).astype(np.int64, copy=False)
+        elif mask_additive is not None:
+            mask_add = np.atleast_2d(mask_additive)
+            if mask_add.shape != self.grid_shape:
+                error_msg = "mask_additive shape must match grid_shape"
+                raise ValueError(error_msg)
+            _coords_add = map_to_coords(mask_add)
+        else:
+            _coords_add = None
+
+        # --- Set p0 and p0_additive ---
+        if p0 is not None:
+            self.p0 = np.atleast_2d(p0)
+            if self.p0.shape[0] != self.incoords.shape[0]:
+                error_msg = (
+                    f"p0 has {self.p0.shape[0]} rows but "
+                    f"incoords has {self.incoords.shape[0]} (must match)"
+                )
+                raise ValueError(error_msg)
+            self.p0_additive = np.atleast_2d(p0_additive) if p0_additive is not None else None
+        else:
+            # 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]
+            if p0_add.shape[0] != n_add:
+                error_msg = (
+                    f"p0_additive shape {p0_add.shape} must have {n_add} rows "
+                    f"(coords_additive/mask_additive or primary coords)"
+                )
+                raise ValueError(error_msg)
+            if _coords_add is None:
+                self.p0 = np.zeros_like(p0_add, dtype=np.float64)
+            else:
+                self.p0 = np.zeros(
+                    (self.incoords.shape[0], p0_add.shape[1]),
+                    dtype=np.float64,
+                )
+            self.p0_additive = p0_add
+
+        # --- Set incoords_add for writer/binary ---
+        if self.p0_additive is not None:
+            self.incoords_add = _coords_add if _coords_add is not None else self.incoords
+        else:
+            self.incoords_add = None
+
+        self.is_3d = len(self.grid_shape) == 3
+        super().__init__()
+        self.__post_init__()
+        logger.debug("Source instance created.")
+
+    def __post_init__(self) -> None:
+        """Post-initialization processing for Source.
+
+        Raises
+        ------
+        ValueError
+            If the number of sources in the input signal
+            does not match the number of source coordinates.
+            If p0_additive length does not match incoords_add.
+
+        """
+        self.p0 = np.atleast_2d(self.p0)
+        if self.p0.shape[0] != self.incoords.shape[0]:
+            error_msg = "Input signal has the wrong number of elements"
+            raise ValueError(error_msg)
+        if self.p0_additive is not None and self.incoords_add is not None:
+            self.p0_additive = np.atleast_2d(self.p0_additive)
+            if self.p0_additive.shape[0] != self.incoords_add.shape[0]:
+                error_msg = (
+                    f"p0_additive shape {self.p0_additive.shape} must have "
+                    f"{self.incoords_add.shape[0]} rows (incoords_add)"
+                )
+                raise ValueError(error_msg)
+
+    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."
+        logger.debug("Source validated against grid shape.")
+
+    @property
+    def icmat(self) -> NDArray[np.float64]:
+        """Returns icmat for the compatibility with the fullwave code."""
+        return self.p0
+
+    @property
+    def mask(self) -> NDArray[np.int64]:
+        """Returns the source mask.
+
+        it calculates the source mask from the source coordinates to reduce the memory usage.
+        """
+        return coords_to_map(
+            self.incoords,
+            grid_shape=self.grid_shape,
+            is_3d=self.is_3d,
+        )
+
+    @property
+    def ncoords(self) -> int:
+        """Return the number of sources.
+
+        ailiased to n_sensors for the compatibility with matlab version
+        """
+        return self.n_sources
+
+    @property
+    def n_sources(self) -> int:
+        """Return the number of sources (hard / primary)."""
+        return self.incoords.shape[0]
+
+    @property
+    def n_sources_add(self) -> int:
+        """Return the number of additive (soft) source positions."""
+        if self.incoords_add is None:
+            return 0
+        return self.incoords_add.shape[0]
+
+    def plot(
+        self,
+        export_path: Path | str | None = Path("./temp/temp.png"),
+        *,
+        show: bool = False,
+        dpi: int = 3000,
+    ) -> None:
+        """Plot the transducer mask, optionally exporting and displaying the figure.
+
+        Raises
+        ------
+        ValueError
+            If 3D plotting is requested but not supported.
+
+        """
+        if self.is_3d:
+            error_msg = "3D plotting is not supported yet."
+            raise ValueError(error_msg)
+        plt.close("all")
+        fig, _ = plt.subplots()
+        fig = plot_utils.plot_array(
+            self.mask,
+            xlim=[-10, self.mask.shape[1] + 10],
+            ylim=[-10, self.mask.shape[0] + 10],
+            reverse_y_axis=True,
+            save=False,
+            clear_all=False,
+            fig=fig,
+            colorbar=True,
+        )
+
+        if export_path is not None:
+            plt.savefig(export_path, dpi=dpi)
+        if show:
+            plt.show()
+
+        plt.close("all")
+
+    def print_info(self) -> None:
+        """Print source information to the logger."""
+        print(str(self))
+
+    def summary(self) -> None:
+        """Alias for print_info."""
+        self.print_info()
+
+    def __str__(self) -> str:
+        """Show source information.
+
+        Returns
+        -------
+        str
+            Formatted string containing source information.
+
+        """
+        lines = [
+            "Source:",
+            f"  Number of sources: {self.n_sources}",
+            f"  Grid shape: {self.grid_shape}",
+            f"  Is 3D: {self.is_3d}",
+            f"  p0 shape: {self.p0.shape}",
+        ]
+        if self.p0_additive is not None:
+            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")
+        return "\n".join(lines) + "\n"
+
+    def __repr__(self) -> str:
+        """Show source information.
+
+        Returns
+        -------
+        str
+            Formatted string containing source information.
+
+        """
+        return self.__str__()

{fullwave25-1.2.3.dev1 → fullwave25-1.2.3rc1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fullwave25"
-version = "1.2.3-dev1" # Update via bump-my-version, not manually
+version = "1.2.3-rc1" # 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.3.dev1 → fullwave25-1.2.3rc1}/uv.lock

@@ -735,7 +735,7 @@ wheels = [
 
 [[package]]
 name = "fullwave25"
-version = "1.2.3.dev1"
+version = "1.2.3rc1"
 source = { editable = "." }
 dependencies = [
     { name = "joblib" },

fullwave25-1.2.3.dev1/fullwave/source.py

@@ -1,206 +0,0 @@
-"""Source class for Fullwave."""
-
-import logging
-from dataclasses import dataclass
-from pathlib import Path
-
-import numpy as np
-from matplotlib import pyplot as plt
-from numpy.typing import NDArray
-
-from fullwave.utils import plot_utils
-from fullwave.utils.coordinates import coords_to_map, map_to_coords
-
-logger = logging.getLogger("__main__." + __name__)
-
-
-@dataclass
-class Source:
-    """Source class for Fullwave."""
-
-    p0: NDArray[np.float64]
-    incoords: NDArray[np.int64]
-    grid_shape: tuple[int, ...]
-
-    def __init__(
-        self,
-        p0: NDArray[np.float64],
-        mask: NDArray[np.bool] | None = None,
-        *,
-        coords: NDArray[np.int64] | None = None,
-        grid_shape: tuple[int, ...] | None = None,
-    ) -> None:
-        """Source class for Fullwave.
-
-        Parameters
-        ----------
-        p0 : NDArray[np.float64]
-            time varying pressure at each of the source positions given by source.p_mask
-            shape: [n_sources, nt]
-        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.
-            Mutually exclusive with coords/grid_shape.
-        coords : NDArray[np.int64] | None
-            Coordinate array of source positions, 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.
-
-        Raises
-        ------
-        ValueError
-            If grid_shape is not provided when using coords input.
-            If both mask and coords are provided (mutually exclusive).
-            If neither mask nor coords (with grid_shape) are provided.
-
-        """
-        self.p0 = np.atleast_2d(p0)
-
-        if coords is not None:
-            if grid_shape is None:
-                msg = "grid_shape is required when using coords input"
-                raise ValueError(msg)
-            if mask is not None:
-                msg = "mask and coords are mutually exclusive"
-                raise ValueError(msg)
-            self.incoords = np.atleast_2d(coords).astype(np.int64, copy=False)
-            self.grid_shape = tuple(grid_shape)
-        elif mask is not None:
-            mask = np.atleast_2d(mask)
-            self.grid_shape = mask.shape
-            self.incoords = map_to_coords(mask)
-        else:
-            msg = "Either mask or coords (with grid_shape) must be provided"
-            raise ValueError(msg)
-
-        self.is_3d = len(self.grid_shape) == 3
-        super().__init__()
-        self.__post_init__()
-        logger.debug("Source instance created.")
-
-    def __post_init__(self) -> None:
-        """Post-initialization processing for Source.
-
-        Raises
-        ------
-        ValueError
-            If the number of sources in the input signal
-            does not match the number of source coordinates.
-
-        """
-        self.p0 = np.atleast_2d(self.p0)
-        if self.p0.shape[0] != self.incoords.shape[0]:
-            error_msg = "Input signal has the wrong number of elements"
-            raise ValueError(error_msg)
-
-    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, "No active source found."
-        logger.debug("Source validated against grid shape.")
-
-    @property
-    def icmat(self) -> NDArray[np.float64]:
-        """Returns icmat for the compatibility with the fullwave code."""
-        return self.p0
-
-    @property
-    def mask(self) -> NDArray[np.int64]:
-        """Returns the source mask.
-
-        it calculates the source mask from the source coordinates to reduce the memory usage.
-        """
-        return coords_to_map(
-            self.incoords,
-            grid_shape=self.grid_shape,
-            is_3d=self.is_3d,
-        )
-
-    @property
-    def ncoords(self) -> int:
-        """Return the number of sources.
-
-        ailiased to n_sensors for the compatibility with matlab version
-        """
-        return self.n_sources
-
-    @property
-    def n_sources(self) -> int:
-        """Return the number of sources."""
-        return self.incoords.shape[0]
-
-    def plot(
-        self,
-        export_path: Path | str | None = Path("./temp/temp.png"),
-        *,
-        show: bool = False,
-        dpi: int = 3000,
-    ) -> None:
-        """Plot the transducer mask, optionally exporting and displaying the figure.
-
-        Raises
-        ------
-        ValueError
-            If 3D plotting is requested but not supported.
-
-        """
-        if self.is_3d:
-            error_msg = "3D plotting is not supported yet."
-            raise ValueError(error_msg)
-        plt.close("all")
-        fig, _ = plt.subplots()
-        fig = plot_utils.plot_array(
-            self.mask,
-            xlim=[-10, self.mask.shape[1] + 10],
-            ylim=[-10, self.mask.shape[0] + 10],
-            reverse_y_axis=True,
-            save=False,
-            clear_all=False,
-            fig=fig,
-            colorbar=True,
-        )
-
-        if export_path is not None:
-            plt.savefig(export_path, dpi=dpi)
-        if show:
-            plt.show()
-
-        plt.close("all")
-
-    def print_info(self) -> None:
-        """Print source information to the logger."""
-        print(str(self))
-
-    def summary(self) -> None:
-        """Alias for print_info."""
-        self.print_info()
-
-    def __str__(self) -> str:
-        """Show source information.
-
-        Returns
-        -------
-        str
-            Formatted string containing source information.
-
-        """
-        return (
-            f"Source: \n"
-            f"  Number of sources: {self.n_sources}\n"
-            f"  Grid shape: {self.grid_shape}\n"
-            f"  Is 3D: {self.is_3d}\n"
-            f"  p0 shape: {self.p0.shape}\n"
-        )
-
-    def __repr__(self) -> str:
-        """Show source information.
-
-        Returns
-        -------
-        str
-            Formatted string containing source information.
-
-        """
-        return self.__str__()