fullwave25 1.4.2.dev0__py3-none-any.whl → 1.4.2.dev1__py3-none-any.whl

fullwave/__init__.py

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

fullwave/medium.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 import logging
 from collections import OrderedDict
-from concurrent.futures import ThreadPoolExecutor
+from concurrent.futures import ThreadPoolExecutor, as_completed
 from dataclasses import dataclass
 from pathlib import Path
 from typing import TYPE_CHECKING
@@ -93,8 +93,6 @@ def _upload_arrays_multi_gpu(
     dict mapping name -> CuPy array on *target_device*.
 
     """
-    from concurrent.futures import as_completed  # noqa: PLC0415
-
     import cupy as cp  # noqa: PLC0415
 
     n_gpus = cp.cuda.runtime.getDeviceCount()

fullwave/solver/binary_manager.py

@@ -21,6 +21,8 @@ import urllib.error
 import urllib.request
 from pathlib import Path
 
+from tqdm import tqdm
+
 logger = logging.getLogger("__main__." + __name__)
 
 GITHUB_REPO = "pinton-lab/fullwave25"
@@ -28,7 +30,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.6"
+BINARY_RELEASE_TAG = "fullwave_bin_v1.7"
 
 
 def _download_url(filename: str, tag: str) -> str:
@@ -36,39 +38,34 @@ def _download_url(filename: str, tag: str) -> str:
 
 
 def _download_binary(url: str, dest: Path) -> None:
-    """Download *url* to *dest*, showing a tqdm progress bar when available."""
+    """Download *url* to *dest*, showing a tqdm progress bar."""
     dest.parent.mkdir(parents=True, exist_ok=True)
     tmp = dest.with_suffix(".download_tmp")
     try:
+
+        class _Hook:
+            def __init__(self) -> None:
+                self._bar: tqdm | None = None
+
+            def __call__(self, block: int, block_size: int, total: int) -> None:  # noqa: ARG002
+                if self._bar is None:
+                    self._bar = tqdm(
+                        total=total if total > 0 else None,
+                        unit="B",
+                        unit_scale=True,
+                        desc=dest.name,
+                    )
+                self._bar.update(block_size)
+
+            def close(self) -> None:
+                if self._bar is not None:
+                    self._bar.close()
+
+        hook = _Hook()
         try:
-            from tqdm import tqdm  # noqa: PLC0415
-
-            class _Hook:
-                def __init__(self) -> None:
-                    self._bar: tqdm | None = None
-
-                def __call__(self, block: int, block_size: int, total: int) -> None:  # noqa: ARG002
-                    if self._bar is None:
-                        self._bar = tqdm(
-                            total=total if total > 0 else None,
-                            unit="B",
-                            unit_scale=True,
-                            desc=dest.name,
-                        )
-                    self._bar.update(block_size)
-
-                def close(self) -> None:
-                    if self._bar is not None:
-                        self._bar.close()
-
-            hook = _Hook()
-            try:
-                urllib.request.urlretrieve(url, tmp, reporthook=hook)  # noqa: S310
-            finally:
-                hook.close()
-
-        except ImportError:
-            urllib.request.urlretrieve(url, tmp)  # noqa: S310
+            urllib.request.urlretrieve(url, tmp, reporthook=hook)  # noqa: S310
+        finally:
+            hook.close()
 
         tmp.rename(dest)
         dest.chmod(dest.stat().st_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)

fullwave/solver/binary_markers.py

@@ -0,0 +1,87 @@
+"""Find out whether a solver binary reads an input file, by the file name in its bytes."""
+
+import mmap
+from functools import lru_cache
+from pathlib import Path
+from typing import NamedTuple
+
+HOLD_SOURCE_MARKER = b"hold_source.dat"
+DEFAULT_FIX = "rebuild the binary, or set FULLWAVE25_BINARY_TAG to the release that has it"
+
+
+class HoldSourceUnsupportedError(RuntimeError):
+    """Raised when the binary cannot hold the hard source after the drive ends."""
+
+
+class _FileStamp(NamedTuple):
+    """A file with the size and modification time that tell whether it changed."""
+
+    path: Path
+    size: int
+    mtime_ns: int
+
+
+@lru_cache(maxsize=64)
+def _find(stamp: _FileStamp, marker: bytes) -> bool:
+    if stamp.size == 0:
+        return False
+    with stamp.path.open("rb") as file, mmap.mmap(file.fileno(), 0, access=mmap.ACCESS_READ) as mm:
+        return mm.find(marker) != -1
+
+
+def binary_has_marker(binary: str | Path, *, marker: bytes) -> bool:
+    """Return whether the bytes of ``binary`` contain ``marker``.
+
+    Parameters
+    ----------
+    binary : str | Path
+        The solver binary.
+    marker : bytes
+        The name of the input file the binary reads.
+
+    Returns
+    -------
+    bool
+        True when the binary contains the name. The answer is cached until the file changes.
+
+    """
+    path = Path(binary).resolve()
+    stat = path.stat()
+    return _find(_FileStamp(path=path, size=stat.st_size, mtime_ns=stat.st_mtime_ns), marker)
+
+
+def check_binary_holds_source(
+    binary: str | Path,
+    *,
+    marker: bytes = HOLD_SOURCE_MARKER,
+    error_type: type[Exception] = HoldSourceUnsupportedError,
+    fix: str = DEFAULT_FIX,
+) -> None:
+    """Refuse a binary that would release the hard source cells when the drive ends.
+
+    Parameters
+    ----------
+    binary : str | Path
+        The solver binary.
+    marker : bytes, optional
+        The name of the input file that tells the binary to hold the source.
+    error_type : type[Exception], optional
+        The exception to raise.
+    fix : str, optional
+        What to do to get a binary that reads the file, worded for the message.
+
+    Raises
+    ------
+    Exception
+        ``error_type``, when the binary does not contain ``marker``.
+
+    """
+    if binary_has_marker(binary, marker=marker):
+        return
+    message = (
+        f"{Path(binary).name} does not read {marker.decode()}, so it releases the hard source "
+        "cells when the drive signal ends and source_type='hard' would not hold them. "
+        f"Use a binary that reads it: {fix}. "
+        "source_type='hard_released_after' needs no such binary."
+    )
+    raise error_type(message)

fullwave/solver/input_file_writer.py

@@ -5,6 +5,7 @@ import logging
 import os
 import time
 from collections.abc import Sequence
+from concurrent.futures import ThreadPoolExecutor, as_completed
 from pathlib import Path
 
 import numpy as np
@@ -64,6 +65,7 @@ class InputFileWriter:
         exponential_attenuation_pml_interior_offset_px: int = 0,
         use_gpu: bool = False,
         write_maps_the_solver_does_not_read: bool = False,
+        hold_hard_source: bool = False,
     ) -> None:
         """Initialize the InputGeneratorBase instance.
 
@@ -124,6 +126,11 @@ class InputFileWriter:
             which an older solver binary needs. The record the skipped maps
             replace is impedance_constraint.dat, and this writer always writes it
             on the relaxation path.
+        hold_hard_source : bool, optional
+            Whether the hard source cells stay at zero pressure after the drive ends.
+            True writes the flag file ``hold_source.dat``, which the solver reads to keep
+            the cells at zero for the rest of the run; the signals are written as given.
+            False, the default, lets the solver release the cells when the signal ends.
 
         """
         logger.debug("Initializing InputFileWriter instance.")
@@ -139,6 +146,7 @@ class InputFileWriter:
         self.use_isotropic_relaxation = use_isotropic_relaxation
         self.write_maps_the_solver_does_not_read = write_maps_the_solver_does_not_read
         self.use_gpu = use_gpu
+        self.hold_hard_source = hold_hard_source
 
         if validate_input:
             check_functions.check_path_exists(self.path_fullwave_simulation_bin)
@@ -347,10 +355,21 @@ class InputFileWriter:
 
         """
         if members is None:
-            return getattr(self.source, name, None)
-        if getattr(self.source, name, None) is None:
+            signal = getattr(self.source, name, None)
+        elif getattr(self.source, name, None) is None:
             return None
-        return np.concatenate([getattr(member, name) for member in members], axis=0)
+        else:
+            signal = np.concatenate([getattr(member, name) for member in members], axis=0)
+        return signal
+
+    @property
+    def _holds_the_source(self) -> bool:
+        """Whether the solver keeps the hard source cells at zero after the drive ends."""
+        return (
+            self.hold_hard_source
+            and self.source.n_sources > 0
+            and self.source.icmat.shape[1] < self.grid.nt
+        )
 
     # --- constructor utils ---
 
@@ -909,8 +928,6 @@ class InputFileWriter:
             (c_min_val, c_max_val) of the sound speed.
 
         """
-        from concurrent.futures import ThreadPoolExecutor, as_completed  # noqa: PLC0415
-
         import cupy as cp  # noqa: PLC0415
 
         sound_speed_np = self.medium.sound_speed
@@ -1259,6 +1276,7 @@ class InputFileWriter:
             "ncoordsout",
             "ncoordszero",
             "nTic",
+            "hold_source",
             "modT",
             "modX",
             "modY",
@@ -1357,7 +1375,6 @@ class InputFileWriter:
             self._queue_v_abs_write(np.float32, save_path, var)
 
     def _save_coords_params(self, simulation_dir: Path) -> None:
-        nt_ic = self.source.icmat.shape[1]
         var_list = [
             ("nX", self.grid.nx),
             ("nY", self.grid.ny),
@@ -1365,9 +1382,11 @@ class InputFileWriter:
             ("ncoords", self.source.n_sources),
             ("ncoordsout", self.sensor.n_sensors),
             ("ncoordszero", self.medium.n_air),
-            ("nTic", nt_ic),
+            ("nTic", self.source.icmat.shape[1]),
             ("modT", self.sensor.sampling_modulus_time),
         ]
+        if self._holds_the_source:
+            var_list.append(("hold_source", 1))
         n_sources_add = getattr(self.source, "n_sources_add", 0)
         if n_sources_add > 0:
             var_list.append(("ncoords_add", n_sources_add))

fullwave/solver/launcher.py

@@ -13,6 +13,7 @@ from time import time
 import numpy as np
 from numpy.typing import NDArray
 
+from .cuda_utils import find_consecutive_gpus_without_peer_access
 from .utils import load_dat_data
 
 logger = logging.getLogger("__main__." + __name__)
@@ -211,8 +212,6 @@ class Launcher:
             )
             return
         try:
-            from .cuda_utils import find_consecutive_gpus_without_peer_access  # noqa: PLC0415
-
             pairs = find_consecutive_gpus_without_peer_access(device_ids)
         except (AttributeError, NameError, OSError, RuntimeError, ctypes.ArgumentError) as error:
             logger.debug("Peer access check skipped: %s", error)

fullwave/solver/solver.py

@@ -7,6 +7,7 @@ import os
 import shutil
 import subprocess
 import time
+import warnings
 from collections.abc import Iterator, Sequence
 from pathlib import Path
 
@@ -18,18 +19,21 @@ from fullwave.solver.input_file_writer import InputFileWriter
 from fullwave.solver.launcher import Launcher
 from fullwave.solver.pml_builder import PMLBuilder, PMLBuilderExponentialAttenuation
 from fullwave.solver.source_type import (
-    HARD,
+    HARD_RELEASED_AFTER,
     SOURCE_TYPES,
     as_additive_source,
+    is_hard_held,
     is_soft,
 )
+from fullwave.ultra import backend, binary, factory
 from fullwave.utils import (
-    MemoryTempfile,
     check_functions,
+    run_directory_in_memory,
 )
 from fullwave.utils.signal_filter import apply_filter
 
 from .binary_manager import ensure_binary
+from .binary_markers import check_binary_holds_source
 from .cuda_utils import get_cuda_architecture, retrieve_cuda_version
 from .utils import load_dat_data
 
@@ -40,6 +44,9 @@ logger = logging.getLogger("__main__." + __name__)
 # that, so a larger run only costs memory.
 DEFAULT_MAX_MEMBERS_PER_RUN = 32
 
+# The smallest points per wavelength (ppw) the relaxation attenuation model is validated for.
+MIN_VALIDATED_PPW_RELAXATION = 8
+
 
 def _split_evenly(members: list, largest: int) -> list[list]:
     """Split the transmits into the fewest runs of at most ``largest``, of nearly equal size.
@@ -476,6 +483,9 @@ class Solver:
     generates the required input files, and runs the simulation executable.
     """
 
+    #: The experimental fullwave2-ultra backend; set only by ``use_ultra=True``.
+    ultra = None
+
     def __init__(  # noqa: PLR0912
         self,
         work_dir: Path,
@@ -500,8 +510,9 @@ class Solver:
         verify_gpu: bool = True,
         use_gpu_pml: bool = False,
         pml_alpha_entrance: float | None = None,
-        source_type: str = HARD,
+        source_type: str = HARD_RELEASED_AFTER,
         write_maps_the_solver_does_not_read: bool = False,
+        use_ultra: bool = False,
     ) -> None:
         """Initialize a Solver instance for the fullwave simulation.
 
@@ -627,6 +638,21 @@ class Solver:
             relaxation path. Set it to True for a solver binary that predates
             that record. Such a binary stops with an error on kappax.dat rather
             than returning a wrong answer.
+        source_type : str, optional
+            How the source drives the field. "hard_released_after", the default,
+            assigns the source pressure while the drive signal plays, then lets the
+            source cells evolve freely. "hard" assigns it for the whole run, so the
+            cells stay at zero pressure after the signal ends. "soft" adds the signal
+            to the field. ``use_ultra`` follows the same three values.
+        use_ultra : bool, optional
+            Experimental. Run a user-supplied fullwave2-ultra binary (not shipped; pass it
+            as ``path_fullwave_simulation_bin`` or set ``FW2U_BATCH_BIN``): ``bench_2d_batch``
+            for a 2D grid, ``bench_3d_opt`` for a 3D grid.
+            ``exponential_attenuation_pml_thickness_px`` sets the sponge width in cells.
+            A source with ``p0_additive`` and ``source_type="soft"`` are added to the pressure
+            through the binary's additive channel, which needs a binary that reads
+            ``ncoords_add.dat`` (and ``icmat_add.dat`` on a 3D grid). Unsupported options raise
+            ``UltraUnsupportedError``.
 
         Raises
         ------
@@ -637,6 +663,34 @@ class Solver:
             and transducer) are defined simultaneously.
 
         """
+        self.ultra = None
+        if use_ultra:
+            self._init_ultra(
+                work_dir=work_dir,
+                grid=grid,
+                medium=medium,
+                source=source,
+                sensor=sensor,
+                transducer=transducer,
+                path_fullwave_simulation_bin=path_fullwave_simulation_bin,
+                run_on_memory=run_on_memory,
+                cuda_device_id=cuda_device_id,
+                verify_gpu=verify_gpu,
+                nbdy=exponential_attenuation_pml_thickness_px,
+                options={
+                    "use_pml": use_pml,
+                    "m_spatial_order": m_spatial_order,
+                    "pml_layer_thickness_px": pml_layer_thickness_px,
+                    "n_transition_layer": n_transition_layer,
+                    "use_gpu": use_gpu,
+                    "use_gpu_pml": use_gpu_pml,
+                    "pml_alpha_entrance": pml_alpha_entrance,
+                    "source_type": source_type,
+                    "save_gpu_memory": save_gpu_memory,
+                    "write_maps_the_solver_does_not_read": write_maps_the_solver_does_not_read,
+                },
+            )
+            return
         if exponential_attenuation_pml_thickness_px is not None and not use_exponential_attenuation:
             error_msg = (
                 "exponential_attenuation_pml_thickness_px belongs to the exponential "
@@ -646,6 +700,14 @@ class Solver:
             )
             raise ValueError(error_msg)
 
+        if not use_exponential_attenuation and grid.ppw < MIN_VALIDATED_PPW_RELAXATION:
+            warnings.warn(
+                f"ppw={grid.ppw} is below {MIN_VALIDATED_PPW_RELAXATION}. "
+                f"The relaxation model is validated for ppw >= {MIN_VALIDATED_PPW_RELAXATION}.",
+                UserWarning,
+                stacklevel=2,
+            )
+
         # type hints
         self.source: fullwave.Source
         self.sensor: fullwave.Sensor
@@ -680,14 +742,7 @@ class Solver:
                 "\n"
             )
             logger.info(message)
-            self.tempfile = MemoryTempfile(
-                preferred_paths=["/run/user/{uid}"],
-                remove_paths=["/dev/shm", "/run/shm"],  # noqa: S108
-                additional_paths=["/var/run"],
-                filesystem_types=["tmpfs"],
-                fallback=True,
-            )
-            self.tempdir = self.tempfile.TemporaryDirectory()
+            self.tempdir = run_directory_in_memory()
             self.work_dir = Path(self.tempdir.name)
         else:
             self.work_dir = work_dir
@@ -799,6 +854,7 @@ class Solver:
                 use_exponential_attenuation=use_exponential_attenuation,
             )
             logger.info("source_type=%s, the source is driven by addition", source_type)
+        self._check_binary_holds_source(path_fullwave_simulation_bin)
 
         if sensor is not None:
             self.sensor = sensor
@@ -849,6 +905,49 @@ class Solver:
                 pml_alpha_entrance=pml_alpha_entrance,
             )
 
+    def _init_ultra(
+        self,
+        *,
+        work_dir: Path,
+        grid: fullwave.Grid,
+        medium: fullwave.Medium,
+        source: fullwave.Source | None,
+        sensor: fullwave.Sensor | None,
+        transducer: fullwave.Transducer | None,
+        path_fullwave_simulation_bin: Path | None,
+        run_on_memory: bool | None,
+        cuda_device_id: str | int | list | None,
+        verify_gpu: bool,
+        nbdy: int | None,
+        options: dict,
+    ) -> None:
+        """Set up the experimental fullwave2-ultra backend (see ``fullwave.ultra``)."""
+        backend.warn_experimental()
+        backend.warn_ppw_above_speed_optimum(ppw=grid.ppw)
+        backend.check_solver_options(**options)
+        binary_name = binary.BINARY_NAME_3D if grid.is_3d else binary.BINARY_NAME_2D
+        ultra_binary = binary.resolve_binary(path_fullwave_simulation_bin, name=binary_name)
+        self._check_input(grid, medium, source, sensor, transducer, ultra_binary)
+        if source is None:
+            source = transducer.source
+        if sensor is None:
+            sensor = transducer.sensor
+        self.grid, self.medium, self.source, self.sensor = grid, medium, source, sensor
+        self.is_3d = grid.is_3d
+        self.ultra = factory.make_backend(
+            work_dir=Path(work_dir),
+            grid=grid,
+            medium=medium,
+            source=source,
+            sensor=sensor,
+            binary=ultra_binary,
+            run_on_memory=run_on_memory,
+            nbdy=nbdy,
+            cuda_device_id=cuda_device_id,
+            verify_gpu=verify_gpu,
+            source_type=options["source_type"],
+        )
+
     def _warn_if_the_additive_signal_was_not_scaled(self) -> None:
         """Say so when an additive signal was built by hand and may carry no scale.
 
@@ -1170,6 +1269,16 @@ class Solver:
             or if either filter option is set but ``load_results=False``.
 
         """
+        if self.ultra is not None:
+            return self.ultra.run(
+                simulation_dir_name,
+                is_static_map=is_static_map,
+                record_whole_domain=record_whole_domain,
+                load_results=load_results,
+                generate_input_only=generate_input_only,
+                highpass_cutoff_mhz=highpass_cutoff_mhz,
+                bandpass_cutoff_mhz=bandpass_cutoff_mhz,
+            )
         return self._run_one(
             simulation_dir_name,
             members=None,
@@ -1288,6 +1397,7 @@ class Solver:
             exponential_attenuation_pml_interior_offset_px=interior_offset,
             use_gpu=self.use_gpu_pml,
             write_maps_the_solver_does_not_read=self.write_maps_the_solver_does_not_read,
+            hold_hard_source=is_hard_held(self.source_type),
         )
         simulation_dir = input_file_writer.run(
             simulation_dir_name,
@@ -1529,6 +1639,18 @@ class Solver:
             transmit in one simulation.
 
         """
+        if self.ultra is not None:
+            return self.ultra.run_batch(
+                sources,
+                simulation_dir_name,
+                max_members_per_run=max_members_per_run,
+                is_static_map=is_static_map,
+                record_whole_domain=record_whole_domain,
+                load_results=load_results,
+                generate_input_only=generate_input_only,
+                highpass_cutoff_mhz=highpass_cutoff_mhz,
+                bandpass_cutoff_mhz=bandpass_cutoff_mhz,
+            )
         members = self._batch_members(sources)
         # The sensor and the sizing below need the extended grid and medium.
         self.pml_builder.run(use_pml=self.use_pml)
@@ -1702,7 +1824,9 @@ class Solver:
                 use_isotropic_relaxation=self.use_isotropic_relaxation,
                 batch=True,
             )
-            return ensure_binary(local_path)
+            binary = ensure_binary(local_path)
+            self._check_binary_holds_source(binary)
+            return binary
         name = Path(self.path_fullwave_simulation_bin).name
         if "batch" not in name:
             error_msg = (
@@ -1714,6 +1838,23 @@ class Solver:
             raise ValueError(error_msg)
         return Path(self.path_fullwave_simulation_bin)
 
+    def _check_binary_holds_source(self, binary: Path) -> None:
+        """Refuse a binary that cannot hold the hard source, when the run needs it held.
+
+        Parameters
+        ----------
+        binary : Path
+            The binary that runs the simulation.
+
+        """
+        holds_source = (
+            is_hard_held(self.source_type)
+            and self.source.n_sources > 0
+            and self.source.icmat.shape[1] < self.grid.nt
+        )
+        if holds_source:
+            check_binary_holds_source(binary)
+
     @contextlib.contextmanager
     def _binary_in_use(self, binary: Path) -> Iterator[None]:
         """Run the simulations of the block on ``binary``, then restore the Solver's binary.

fullwave/solver/source_type.py

@@ -1,4 +1,11 @@
-"""Drive the source by addition rather than by assignment.
+"""Source types: hard, hard released after the drive, and soft.
+
+``"hard"`` assigns the source pressure for the whole run, so the source cells stay at
+zero pressure after the drive signal ends. ``"hard_released_after"`` assigns the
+pressure while the drive signal plays, then lets the cells evolve freely.
+``"soft"`` adds the signal to the field, as described below.
+
+A soft source drives the source by addition rather than by assignment.
 
 A hard source sets the pressure of one grid row on every step, while the
 staggered derivative spans `2 * m_spatial_order` pressure points. One hard source row
@@ -19,14 +26,15 @@ from typing import TYPE_CHECKING
 import numpy as np
 from numpy.typing import NDArray
 
-from fullwave.source import Source
+from fullwave.source import Source, additive_signal_scale
 
 if TYPE_CHECKING:
     import fullwave
 
 HARD = "hard"
+HARD_RELEASED_AFTER = "hard_released_after"
 SOFT = "soft"
-SOURCE_TYPES = (HARD, SOFT)
+SOURCE_TYPES = (HARD, HARD_RELEASED_AFTER, SOFT)
 
 
 def _is_on_the_device(array: object) -> bool:
@@ -62,6 +70,11 @@ def is_soft(source_type: str) -> bool:
     return source_type == SOFT
 
 
+def is_hard_held(source_type: str) -> bool:
+    """Return whether the source cells stay at zero pressure after the drive ends."""
+    return source_type == HARD
+
+
 def source_row(coords: NDArray[np.int64], grid_shape: tuple[int, ...]) -> int:
     """Return the row the source occupies, and check that it fills one whole row.
 
@@ -101,15 +114,6 @@ def source_row(coords: NDArray[np.int64], grid_shape: tuple[int, ...]) -> int:
     return int(rows[0])
 
 
-def additive_signal_scale(
-    sound_speed: NDArray[np.float64] | float,
-    dt: float,
-    dx: float,
-) -> NDArray[np.float64] | float:
-    """Return the factor that makes an additive source radiate its nominal pressure."""
-    return 2.0 * sound_speed * dt / dx
-
-
 def node_sound_speeds(
     sound_speed: NDArray[np.float64] | float,
     coords: NDArray[np.int64],

fullwave/source.py

@@ -18,6 +18,15 @@ if TYPE_CHECKING:
 logger = logging.getLogger("__main__." + __name__)
 
 
+def additive_signal_scale(
+    sound_speed: NDArray[np.float64] | float,
+    dt: float,
+    dx: float,
+) -> NDArray[np.float64] | float:
+    """Return the factor that makes an additive source radiate its nominal pressure."""
+    return 2.0 * sound_speed * dt / dx
+
+
 @dataclass
 class Source:
     """Source class for Fullwave."""
@@ -272,8 +281,6 @@ class Source:
             A source with no assigned positions and a scaled additive signal.
 
         """
-        from fullwave.solver.source_type import additive_signal_scale  # noqa: PLC0415
-
         speed = float(grid.c0) if sound_speed is None else sound_speed
         scale = additive_signal_scale(speed, float(grid.dt), float(grid.dx))
         scale = np.atleast_1d(np.asarray(scale, dtype=float))