fullwave25 1.3.0.dev0__tar.gz → 1.3.2__tar.gz

{fullwave25-1.3.0.dev0 → fullwave25-1.3.2}/.bumpversion.toml

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

{fullwave25-1.3.0.dev0 → fullwave25-1.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: fullwave25
-Version: 1.3.0.dev0
+Version: 1.3.2
 Summary: Fullwave 2.5: Ultrasound wave propagation simulation with heterogeneous power law attenuation modelling capabilities
 Author: Masashi Sode, Gianmarco Pinton
 Maintainer: Masashi Sode
@@ -13,6 +13,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Scientific/Engineering :: Physics
 Requires-Python: >=3.10
+Requires-Dist: cupy-cuda12x>=13.6.0
 Requires-Dist: matplotlib>=3.10.7
 Requires-Dist: numba>=0.63.1
 Requires-Dist: numexpr>=2.14.1

{fullwave25-1.3.0.dev0 → fullwave25-1.3.2}/fullwave/__init__.py

@@ -1,10 +1,13 @@
 """fullwave module."""
 
 import logging
+import os
 import platform
 import time
 from importlib.metadata import PackageNotFoundError, version
 
+import numexpr
+
 from .grid import Grid
 from .medium import Medium, MediumExponentialAttenuation, MediumRelaxationMaps
 from .sensor import Sensor
@@ -63,7 +66,17 @@ try:
     __version__ = version("fullwave")
 except PackageNotFoundError:
     # Update via bump-my-version, not manually
-    __version__ = "1.3.0-dev0"
+    __version__ = "1.3.2"
 
 VERSION = __version__  # for convenience
 logger.info("Fullwave version: %s", __version__)
+
+# numexpr keeps 16 threads unless told otherwise, and the medium, the absorbing
+# layer and the coefficients run through it on grids of hundreds of millions of
+# cells. A thread count set in the environment is left alone.
+if not any(
+    os.environ.get(name)
+    for name in ("NUMEXPR_MAX_THREADS", "NUMEXPR_NUM_THREADS", "OMP_NUM_THREADS")
+):
+    numexpr.set_num_threads(min(numexpr.detect_number_of_cores(), numexpr.MAX_THREADS))
+logger.info("numexpr threads: %d", numexpr.get_num_threads())

{fullwave25-1.3.0.dev0 → fullwave25-1.3.2}/fullwave/medium.py

@@ -19,6 +19,7 @@ from fullwave.solver.utils import initialize_relaxation_param_dict
 from fullwave.utils import check_functions, plot_utils
 from fullwave.utils.coordinates import coords_to_map, map_to_coords
 from fullwave.utils.relaxation_parameters import (
+    _array_module,
     band_scaled_sound_speed,
     generate_relaxation_params,
 )
@@ -200,7 +201,8 @@ def _make_the_lossless_voxels_lossless(
     """
     if not relaxation_param_dict:
         return
-    coefficient = np.asarray(alpha_coeff)
+    xp = np if np.ndim(alpha_coeff) == 0 else _array_module(alpha_coeff)
+    coefficient = xp.asarray(alpha_coeff)
     if coefficient.ndim == 0:
         if float(coefficient) != 0.0:
             return
@@ -273,6 +275,7 @@ class MediumRelaxationMaps:
         n_jobs: int = -1,
         dtype: type = np.float64,
         use_gpu: bool = False,
+        compute_coefficients: bool = True,
     ) -> None:
         """Medium class for Fullwave.
 
@@ -330,6 +333,10 @@ class MediumRelaxationMaps:
         use_gpu : bool, optional
             If True, use CuPy for GPU-accelerated computation (default is False).
             Requires CuPy to be installed. Falls back to CPU if CuPy is unavailable.
+        compute_coefficients : bool, optional
+            If True (the default), compute ``relaxation_param_dict_for_fw2``
+            here. False leaves it empty for a caller that writes every entry
+            itself, as the PML builder does.
 
         """
         check_functions.check_compatible_value(
@@ -354,7 +361,6 @@ class MediumRelaxationMaps:
         try:
             self.relaxation_param_dict = initialize_relaxation_param_dict(
                 n_relaxation_mechanisms=n_relaxation_mechanisms,
-                value=xp.zeros_like(xp.asarray(sound_speed), dtype=self.dtype),
             )
             self.grid = grid
             self.is_3d = grid.is_3d
@@ -379,7 +385,6 @@ class MediumRelaxationMaps:
             xp = np
             self.relaxation_param_dict = initialize_relaxation_param_dict(
                 n_relaxation_mechanisms=n_relaxation_mechanisms,
-                value=np.zeros_like(np.asarray(sound_speed), dtype=self.dtype),
             )
             self.grid = grid
             self.is_3d = grid.is_3d
@@ -404,12 +409,23 @@ class MediumRelaxationMaps:
             relaxation_param_updates=relaxation_param_dict,
         )
         self.use_isotropic_relaxation = use_isotropic_relaxation
-        self.relaxation_param_dict_for_fw2 = self._calc_relaxation_param_dict_for_fw2(
-            use_isotropic_relaxation=self.use_isotropic_relaxation,
+        self.relaxation_param_dict_for_fw2 = (
+            self._calc_relaxation_param_dict_for_fw2(
+                use_isotropic_relaxation=self.use_isotropic_relaxation,
+            )
+            if compute_coefficients
+            else {}
         )
         self.check_fields()
         logger.debug("MediumRelaxationMaps instance created.")
 
+    def build_coefficients(self) -> None:
+        """Compute ``relaxation_param_dict_for_fw2`` if the constructor was told to skip it."""
+        if not self.relaxation_param_dict_for_fw2:
+            self.relaxation_param_dict_for_fw2 = self._calc_relaxation_param_dict_for_fw2(
+                use_isotropic_relaxation=self.use_isotropic_relaxation,
+            )
+
     def _update_relaxation_param_dict(
         self,
         relaxation_param_updates: dict[str, NDArray[np.float64]],
@@ -1627,12 +1643,18 @@ class Medium:
         parameters = self._relaxation_parameters_of(sound_speed, alpha_coeff, alpha_power)
         return parameters, sound_speed
 
-    def build(self) -> MediumRelaxationMaps:
+    def build(self, *, compute_coefficients: bool = True) -> MediumRelaxationMaps:
         """Retrieve the relaxation parameters from alpha and power maps.
 
         it uses the relaxation parameters look up table
         to generate the relaxation parameters.
 
+        Parameters
+        ----------
+        compute_coefficients : bool, optional
+            Passed to `MediumRelaxationMaps`. False skips the solver
+            coefficients, which a caller that extends the maps first does not use.
+
         Returns
         -------
             MediumRelaxationMaps: An instance of MediumRelaxationMaps
@@ -1670,6 +1692,7 @@ class Medium:
             n_jobs=self.n_jobs,
             dtype=self.dtype,
             use_gpu=self.use_gpu,
+            compute_coefficients=compute_coefficients,
         )
 
     def _db_mhz_cm_to_a_exp(

{fullwave25-1.3.0.dev0 → fullwave25-1.3.2}/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.4.1"
+BINARY_RELEASE_TAG = "fullwave_bin_v1.4.4"
 
 
 def _download_url(filename: str, tag: str) -> str:

{fullwave25-1.3.0.dev0 → fullwave25-1.3.2}/fullwave/solver/input_file_writer.py

@@ -56,7 +56,7 @@ class InputFileWriter:
         path_fullwave_simulation_bin: Path = Path(__file__).parent / "bins" / "fullwave_solver_gpu",
         validate_input: bool = True,
         use_exponential_attenuation: bool = False,
-        use_isotropic_relaxation: bool = False,
+        use_isotropic_relaxation: bool = True,
         release_after_write: bool = False,
         pml_thickness: int = 0,
         exponential_attenuation_pml_thickness_px: int = 0,
@@ -94,6 +94,7 @@ class InputFileWriter:
             to reduce memory usage while retaining accuracy.
             For 2D it will reduce the memory usage by approximately 15%.
             For 3D it will reduce the memory usage by approximately 25%.
+            Only True is supported, and False raises NotImplementedError.
             This option omits the anisotropic relaxation mechanisms to model the attenuation.
             We usually recommend using isotropic relaxation mechanisms
             unless the anisotropic attenuation is required for the simulation.
@@ -126,6 +127,12 @@ class InputFileWriter:
         """
         logger.debug("Initializing InputFileWriter instance.")
 
+        if use_isotropic_relaxation is False:
+            error_msg = (
+                "Currently, only isotropic relaxation is supported. "
+                "Please set use_isotropic_relaxation to True for the simulation."
+            )
+            raise NotImplementedError(error_msg)
         self._work_dir = Path(work_dir)
         self.path_fullwave_simulation_bin = path_fullwave_simulation_bin
         self.use_isotropic_relaxation = use_isotropic_relaxation
@@ -1228,16 +1235,8 @@ class InputFileWriter:
         mechanisms = range(1, self.medium.n_relaxation_mechanisms + 1)
         for nu in mechanisms:
             var_name_list.extend([f"apmlu{nu}", f"bpmlu{nu}", f"apmlx{nu}", f"bpmlx{nu}"])
-        if not self.use_isotropic_relaxation:
-            var_name_list.extend(["kappay", "kappaw"])
-            for nu in mechanisms:
-                var_name_list.extend([f"apmlw{nu}", f"apmly{nu}", f"bpmlw{nu}", f"bpmly{nu}"])
         if self.is_3d:
-            var_name_list.append("modZ")
-        if self.is_3d and not self.use_isotropic_relaxation:
-            var_name_list.extend(["nZ", "dZ", "kappaz", "kappav"])
-            for nu in mechanisms:
-                var_name_list.extend([f"apmlz{nu}", f"apmlv{nu}", f"bpmlz{nu}", f"bpmlv{nu}"])
+            var_name_list.extend(["modZ", "nZ", "dZ"])
         for var_name in var_name_list:
             src_data = src_dir / f"{var_name}.dat"
             dst_data = dst_dir / f"{var_name}.dat"
@@ -1409,6 +1408,29 @@ class InputFileWriter:
             dst.unlink()
         dst.symlink_to(self.path_fullwave_simulation_bin.resolve())
 
+    @staticmethod
+    def _write_in_slabs(
+        variable_mat: np.ndarray,
+        dtype: DTypeLike,
+        save_path: str | Path,
+        slab_bytes: int = 256 * 1024**2,
+    ) -> None:
+        """Write an array in C order, cast one slab of its first axis at a time.
+
+        The bytes are those of one whole cast buffer, and the largest buffer
+        held is one slab, so many maps can be written at once.
+        """
+        dtype = np.dtype(dtype)
+        if variable_mat.ndim == 0:
+            np.ascontiguousarray(variable_mat, dtype=dtype).tofile(save_path)
+            return
+        row_bytes = max(1, dtype.itemsize * (variable_mat.size // max(variable_mat.shape[0], 1)))
+        rows_per_slab = max(1, slab_bytes // row_bytes)
+        with Path(save_path).open("wb") as handle:
+            for start in range(0, variable_mat.shape[0], rows_per_slab):
+                slab = variable_mat[start : start + rows_per_slab]
+                np.ascontiguousarray(slab, dtype=dtype).tofile(handle)
+
     @staticmethod
     def _write_ic(
         fname: str | Path,
@@ -1418,11 +1440,7 @@ class InputFileWriter:
         logger.debug("Writing initial condition matrix to %s", fname, stacklevel=2)
 
         t0 = time.perf_counter()
-        out = np.ascontiguousarray(
-            icmat.T,
-            dtype=np.float32,
-        )  # does transpose+cast into one new buffer
-        out.tofile(fname)
+        InputFileWriter._write_in_slabs(icmat.T, np.float32, fname)
         t1 = time.perf_counter()
 
         logger.debug("Initial condition matrix written in %.2e seconds", t1 - t0, stacklevel=2)
@@ -1486,8 +1504,7 @@ class InputFileWriter:
         if variable_mat.dtype == dtype and variable_mat.flags.c_contiguous:
             variable_mat.tofile(save_path)  # writes in C order
         else:
-            out = np.ascontiguousarray(variable_mat, dtype=dtype)  # at most one new buffer
-            out.tofile(save_path)
+            InputFileWriter._write_in_slabs(variable_mat, dtype, save_path)
 
         t1 = time.perf_counter()
         logger.debug("Matrix written in %.2e seconds", t1 - t0, stacklevel=2)

{fullwave25-1.3.0.dev0 → fullwave25-1.3.2}/fullwave/solver/pml_builder.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import concurrent.futures
 import gc
 import logging
+import os
 from collections import OrderedDict
 from dataclasses import dataclass, field
 from functools import cached_property
@@ -312,12 +313,20 @@ class PMLBuilder:
         logger.debug("building extended medium for pml...")
         medium_as_given = self.medium_org
         if not isinstance(self.medium_org, fullwave.MediumRelaxationMaps):
-            self.medium_org = self.medium_org.build()
+            logger.info(
+                "Building the relaxation maps of %d cells...", int(self.medium_org.sound_speed.size)
+            )
+            self.medium_org = self.medium_org.build(compute_coefficients=False)
         base_attrs = ["sound_speed", "density", "beta"]
         original_alpha_coeff = getattr(self.medium_org, "alpha_coeff", None)
         if original_alpha_coeff is not None and np.ndim(original_alpha_coeff) != 0:
             base_attrs.append("alpha_coeff")
         relax_attrs = list(self.medium_org.relaxation_param_dict.keys())
+        logger.info(
+            "Extending %d maps by %d cells on each side...",
+            len(base_attrs) + len(relax_attrs),
+            self.num_boundary_points,
+        )
 
         if self.xp is not np:
             # Pass CuPy arrays directly — multi-GPU extension uses D2D copy (NVLink)
@@ -366,7 +375,11 @@ class PMLBuilder:
             n_jobs=self.medium_org.n_jobs,
             dtype=getattr(self.medium_org, "dtype", np.float64),
             use_gpu=False,
+            compute_coefficients=False,
         )
+        # The extended maps carry everything the absorbing layer reads, so the
+        # interior maps are released here rather than held through the run.
+        self.medium_org = medium_as_given
         logger.debug("building extended medium for pml...done")
 
         logger.debug("building extended source for pml...")
@@ -861,10 +874,16 @@ class PMLBuilder:
 
         eps = xp.finfo(xp.float64).eps
 
-        rate = d_x / kappa_x + alpha_x
         two_over_dt = 2.0 / dt
-        b = (two_over_dt - rate) / (two_over_dt + rate)
-        a = -(d_x / (kappa_x**2 + eps)) / (rate + two_over_dt)
+        if xp is np:
+            rate = ne.evaluate("d_x / kappa_x + alpha_x")
+            b = ne.evaluate("(two_over_dt - rate) / (two_over_dt + rate)")
+            a = ne.evaluate("-(d_x / (kappa_x ** 2 + eps)) / (rate + two_over_dt)")
+        else:
+            rate = d_x / kappa_x + alpha_x
+            b = (two_over_dt - rate) / (two_over_dt + rate)
+            a = -(d_x / (kappa_x**2 + eps)) / (rate + two_over_dt)
+        del rate
 
         if output_dtype is not None and output_dtype != xp.float64:
             a = a.astype(output_dtype, copy=False)
@@ -886,6 +905,10 @@ class PMLBuilder:
         """
         logger.debug("Running PML builder...")
         if use_pml:
+            logger.info(
+                "Building the absorbing layer on %d cells...",
+                int(self.extended_medium.sound_speed.size),
+            )
             extended_medium: fullwave.MediumRelaxationMaps = self.extended_medium.build()
             if self.is_3d:
                 return self._apply_pml_3d(
@@ -901,30 +924,54 @@ class PMLBuilder:
             )
 
         extended_medium: fullwave.MediumRelaxationMaps = self.extended_medium.build()
+        extended_medium.build_coefficients()
         return extended_medium
 
     def _medium_copy(self, relaxation_param_dict: dict, key: str) -> NDArray[np.float64]:
-        """Return a fresh float64 copy of one medium map."""
-        return self.xp.array(relaxation_param_dict[key], dtype=self.xp.float64, copy=True)
+        """Return a fresh float64 copy of one medium map.
+
+        On the host the copy is split along the first axis across threads,
+        because one thread copying a map of the whole padded grid is the slowest
+        step of the absorbing layer.
+        """
+        source = relaxation_param_dict[key]
+        if self.xp is not np or np.ndim(source) == 0:
+            return self.xp.array(source, dtype=self.xp.float64, copy=True)
+        copied = np.empty(np.shape(source), dtype=np.float64)
+        n_rows = copied.shape[0]
+        n_slabs = max(1, min(n_rows, os.cpu_count() or 1, ne.MAX_THREADS))
+        edges = np.linspace(0, n_rows, n_slabs + 1).astype(int)
+
+        def copy_slab(start: int, stop: int) -> None:
+            np.copyto(copied[start:stop], source[start:stop], casting="unsafe")
+
+        with concurrent.futures.ThreadPoolExecutor(max_workers=n_slabs) as pool:
+            list(pool.map(copy_slab, edges[:-1], edges[1:]))
+        return copied
 
     def _ramp_on_every_axis(
-        self, field: NDArray[np.float64], **kwargs: object
+        self, field: NDArray[np.float64], *, in_place: bool = False, **kwargs: object
     ) -> NDArray[np.float64]:
-        """Apply one ramp along each grid axis in turn, in two dimensions or three."""
+        """Apply one ramp along each grid axis in turn, in two dimensions or three.
+
+        The ramp writes only the layers at both ends of each axis. With
+        `in_place` the field is written itself, otherwise one copy is written.
+        """
         is_3d = field.ndim == self.three_dimensions
-        out = field
+        out = field if in_place else self.xp.array(field, copy=True)
         for axis_index in range(field.ndim):
             out = self._apply_transition_and_pml(
-                out, array_shape=field.shape, axis=axis_index, is_3d=is_3d, **kwargs
+                out, array_shape=field.shape, axis=axis_index, is_3d=is_3d, in_place=True, **kwargs
             )
         return out
 
     def _empty_damping_in_transition_layer(
-        self, damping: NDArray[np.float64]
+        self, damping: NDArray[np.float64], *, in_place: bool = False
     ) -> NDArray[np.float64]:
         """Return the damping strength taken to zero across the transition layer."""
         return self._ramp_on_every_axis(
             damping,
+            in_place=in_place,
             value_target=0.0,
             transition_type="cosine",
             transit_within_transition_layer=True,
@@ -935,10 +982,13 @@ class PMLBuilder:
         damping: NDArray[np.float64],
         n_polynomial: float,
         d_target_pml: float,
+        *,
+        in_place: bool = False,
     ) -> NDArray[np.float64]:
         """Return the damping strength raised to the PML target across the PML layer."""
         return self._ramp_on_every_axis(
             damping,
+            in_place=in_place,
             value_target=d_target_pml,
             n_polynomial=n_polynomial,
             transition_type="polynomial",
@@ -949,27 +999,36 @@ class PMLBuilder:
         self,
         relaxation_frequency: NDArray[np.float64],
         entrance: float,
+        *,
+        in_place: bool = False,
     ) -> NDArray[np.float64]:
         """Return the relaxation frequency replaced by the CFS ramp inside the PML layer.
 
         Replaced rather than ramped into, because ramping a relaxation frequency
         through the evaluation frequency is what confines the damping to the
-        outer edge.
+        outer edge. The PML layer is the slab of `edge` cells at both ends of
+        each axis, so only those slabs are copied from the ramp.
         """
         xp = self.xp
         edge = self.m_spatial_order + self.n_pml_layer
         ramp = self._ramp_on_every_axis(
             xp.full_like(relaxation_frequency, entrance),
+            in_place=True,
             value_target=0.0,
             transition_type="linear",
             transit_within_pml_layer=True,
         )
-        inside_pml_layer = xp.zeros(relaxation_frequency.shape, dtype=bool)
-        for axis_index in range(relaxation_frequency.ndim):
-            view = xp.moveaxis(inside_pml_layer, axis_index, 0)
-            view[:edge] = True
-            view[view.shape[0] - edge :] = True
-        return xp.where(inside_pml_layer, xp.asarray(ramp), xp.asarray(relaxation_frequency))
+        spliced = (
+            xp.asarray(relaxation_frequency)
+            if in_place
+            else xp.array(relaxation_frequency, copy=True)
+        )
+        for axis_index in range(spliced.ndim):
+            target = xp.moveaxis(spliced, axis_index, 0)
+            source = xp.moveaxis(ramp, axis_index, 0)
+            target[:edge] = source[:edge]
+            target[target.shape[0] - edge :] = source[source.shape[0] - edge :]
+        return spliced
 
     def _build_decoupled(
         self,
@@ -1002,16 +1061,16 @@ class PMLBuilder:
                 relaxation_frequency = self._medium_copy(
                     relaxation_param_dict, rename_dict[f"alpha_{letter}_nu{nu}"]
                 )
-                emptied = self._empty_damping_in_transition_layer(damping)
+                emptied = self._empty_damping_in_transition_layer(damping, in_place=True)
                 if nu > 1:
                     out_dict[f"d_{letter}_nu{nu}"] = emptied
                     out_dict[f"alpha_{letter}_nu{nu}"] = relaxation_frequency
                     continue
                 out_dict[f"d_{letter}_nu{nu}"] = self._raise_damping_in_pml_layer(
-                    emptied, n_polynomial, d_target_pml
+                    emptied, n_polynomial, d_target_pml, in_place=True
                 )
                 out_dict[f"alpha_{letter}_nu{nu}"] = self._splice_entrance_frequency_into_pml_layer(
-                    relaxation_frequency, entrance
+                    relaxation_frequency, entrance, in_place=True
                 )
         return out_dict
 
@@ -1124,9 +1183,11 @@ class PMLBuilder:
             found = np.asarray(relaxation_param_dict[key], dtype=np.float64)
             if found.ndim == 0 or np.allclose(found, 1.0):
                 continue
+            found = self.xp.array(found, copy=True)
             for axis in range(3 if is_3d else 2):
                 found = self._apply_transition_and_pml(
                     found,
+                    in_place=True,
                     value_target=1.0,
                     array_shape=found.shape,
                     axis=axis,
@@ -1213,13 +1274,9 @@ class PMLBuilder:
             # Return keys + values so parent can update dict safely
             return (f"a_pml_{axis}{nu}", a, f"b_pml_{axis}{nu}", b)
 
-        if self.xp is not np:
-            # GPU path: run sequentially
-            results = [_worker(nu, axis) for nu, axis in tasks]
-        else:
-            with concurrent.futures.ThreadPoolExecutor() as executor:
-                futures = [executor.submit(_worker, nu, axis) for nu, axis in tasks]
-                results = [f.result() for f in futures]
+        # One task at a time. numexpr threads each expression, and a pool of
+        # tasks held every task's temporaries of the whole grid at once.
+        results = [_worker(nu, axis) for nu, axis in tasks]
 
         for a_key, a_val, b_key, b_val in results:
             out_dict[a_key] = a_val
@@ -1312,13 +1369,9 @@ class PMLBuilder:
             # Return keys + values so parent can update dict safely
             return (f"a_pml_{axis}{nu}", a, f"b_pml_{axis}{nu}", b)
 
-        if self.xp is not np:
-            # GPU path: run sequentially
-            results = [_worker(nu, axis) for nu, axis in tasks]
-        else:
-            with concurrent.futures.ThreadPoolExecutor() as executor:
-                futures = [executor.submit(_worker, nu, axis) for nu, axis in tasks]
-                results = [f.result() for f in futures]
+        # One task at a time. numexpr threads each expression, and a pool of
+        # tasks held every task's temporaries of the whole grid at once.
+        results = [_worker(nu, axis) for nu, axis in tasks]
 
         for a_key, a_val, b_key, b_val in results:
             out_dict[a_key] = a_val
@@ -1347,6 +1400,7 @@ class PMLBuilder:
         transit_within_pml_layer: bool = False,
         disable_the_transition_and_pml: bool = False,
         is_3d: bool = False,
+        in_place: bool = False,
     ) -> NDArray[np.float64]:
         if transit_within_transition_layer and transit_within_pml_layer:
             error_msg = (
@@ -1428,8 +1482,11 @@ class PMLBuilder:
         if use_gpu:
             input_array = xp.asarray(input_array)
 
-        # Move axis to 0 for uniform processing
-        working_array = xp.moveaxis(input_array, axis, 0).copy()
+        # Move axis to 0 for uniform processing. Only the layers at both ends
+        # are written, so an array the caller owns needs no copy.
+        working_array = xp.moveaxis(input_array, axis, 0)
+        if not in_place:
+            working_array = working_array.copy()
 
         # Apply boundary conditions
         working_array[: m_offset + layer_thickness] = value_target