Fix critical row bug, lint violations, and style consistency

SimulationCorrected: fix undefined 'row' variable in arrival time
extraction loop (would crash at runtime). Add voxel_to_row lookup
before accessing sensor_data. Remove redundant to_dict override
(base class handles it). Replace importlib.find_spec for k-wave
availability check. Fix .values -> .to_numpy() for xarray compat.

Style: convert all docstrings to Sphinx :param:/:returns: format
matching the existing codebase. Add noqa comments for deliberate
lazy imports. Fix import sort order in threshold_mri.py skull
refinement block.

kwave_if: remove unused kWaveGrid and kWaveMedium imports from
run_point_source_simulation.

Author: Brandon Kirkland

src/openlifu/bf/delay_methods/simulation_corrected.py

@@ -77,16 +77,16 @@ def calc_delays(self, arr: Transducer, target: Point, params: xa.Dataset, transf
         if the simulation fails for any reason.
 
         Args:
-            arr: The transducer array.
-            target: The focal target point.
-            params: Simulation grid dataset with sound_speed, density, attenuation fields.
-            transform: Optional 4x4 affine transform for element positions.
-
-        Returns:
-            delays: 1D numpy array of per-element delays in seconds.
+        :param arr: The transducer array.
+        :param target: The focal target point.
+        :param params: Simulation grid dataset with sound_speed, density, attenuation fields.
+        :param transform: Optional 4x4 affine transform for element positions.
+        :returns: 1D numpy array of per-element delays in seconds.
         """
         try:
-            from openlifu.sim.kwave_if import run_point_source_simulation
+            import importlib  # noqa: PLC0415
+            if importlib.util.find_spec("kwave") is None:
+                raise ImportError("k-wave not installed")
         except ImportError:
             logger.warning("k-wave not available. Falling back to Direct delay method.")
             return self._fallback_delays(arr, target, params, transform)
@@ -117,9 +117,9 @@ def _run_reciprocal_simulation(
         Returns:
             arrival_times: 1D array of arrival times (seconds) per element.
         """
-        from scipy.signal import hilbert
+        from scipy.signal import hilbert  # noqa: PLC0415
 
-        from openlifu.sim.kwave_if import run_point_source_simulation
+        from openlifu.sim.kwave_if import run_point_source_simulation  # noqa: PLC0415
 
         # Get the reference sound speed from params if available
         if 'sound_speed' in params and 'ref_value' in params['sound_speed'].attrs:
@@ -151,7 +151,7 @@ def _run_reciprocal_simulation(
         target_pos_grid = target.get_position(units=coord_units)
 
         # Build the sensor mask: find nearest grid indices for each element
-        coord_arrays = [params.coords[dim].values for dim in coord_dims]
+        coord_arrays = [params.coords[dim].to_numpy() for dim in coord_dims]
         grid_shape = tuple(len(c) for c in coord_arrays)
 
         sensor_indices = []
@@ -241,6 +241,7 @@ def fortran_linear_index(idx, shape):
                 arrival_times[el_i] = dist / self.c0
                 continue
 
+            row = voxel_to_row[sensor_idx]
             time_series = sensor_data[row, :]
             # Compute the analytic signal envelope via the Hilbert transform
             analytic = hilbert(time_series)
@@ -253,25 +254,15 @@ def fortran_linear_index(idx, shape):
 
     def _fallback_delays(self, arr: Transducer, target: Point, params: xa.Dataset, transform: np.ndarray | None = None) -> np.ndarray:
         """Compute delays using the Direct (geometric) method as a fallback."""
-        from openlifu.bf.delay_methods.direct import Direct
+        from openlifu.bf.delay_methods.direct import Direct  # noqa: PLC0415
         direct = Direct(c0=self.c0)
         return direct.calc_delays(arr, target, params, transform)
 
-    def to_dict(self):
-        d = {
-            'class': self.__class__.__name__,
-            'c0': self.c0,
-            'cfl': self.cfl,
-            'n_cycles': self.n_cycles,
-            'gpu': self.gpu,
-        }
-        return d
-
     def to_table(self) -> pd.DataFrame:
-        """Get a table of the delay method parameters.
+        """
+        Get a table of the delay method parameters
 
-        Returns:
-            Pandas DataFrame of the delay method parameters.
+        :returns: Pandas DataFrame of the delay method parameters
         """
         records = [
             {"Name": "Type", "Value": "SimulationCorrected", "Unit": ""},

src/openlifu/seg/seg_methods/threshold_mri.py

@@ -402,8 +402,9 @@ def _segment(self, volume: xa.DataArray) -> xa.DataArray:
             shell_mask = foreground & ~brain_mask
             shell_intensities = data[shell_mask]
             if shell_intensities.size > 100:
+                from scipy.ndimage import binary_closing  # noqa: PLC0415
+                from scipy.ndimage import label as ndlabel  # noqa: PLC0415
                 from skimage.filters import threshold_otsu  # noqa: PLC0415
-                from scipy.ndimage import binary_closing, label as ndlabel  # noqa: PLC0415
 
                 # Only refine if the shell has meaningful intensity variation.
                 # On uniform/synthetic data (CV < 0.1), Otsu cannot distinguish

src/openlifu/sim/kwave_if.py

@@ -94,23 +94,18 @@ def run_point_source_simulation(
     approach: a single point source is placed at the target and pressure time
     series are recorded at transducer element positions.
 
-    Args:
-        params: Simulation grid dataset with sound_speed, density, attenuation.
-        source_mask: 3D binary array with 1 at the source (target) voxel.
-        sensor_mask: 3D binary array with 1s at sensor (element) voxels.
-        freq: Source frequency in Hz.
-        n_cycles: Number of cycles in the source pulse.
-        sound_speed_ref: Reference speed of sound (m/s) for time stepping.
-        cfl: Courant-Friedrichs-Lewy number for time stepping.
-        gpu: Whether to use GPU acceleration.
-        ref_values_only: If True, use reference (homogeneous) medium values.
-
-    Returns:
-        sensor_data: 2D array (n_sensor_points, n_timesteps) of recorded pressure.
-        dt: The simulation time step in seconds.
+    :param params: Simulation grid dataset with sound_speed, density, attenuation.
+    :param source_mask: 3D binary array with 1 at the source (target) voxel.
+    :param sensor_mask: 3D binary array with 1s at sensor (element) voxels.
+    :param freq: Source frequency in Hz.
+    :param n_cycles: Number of cycles in the source pulse.
+    :param sound_speed_ref: Reference speed of sound (m/s) for time stepping.
+    :param cfl: Courant-Friedrichs-Lewy number for time stepping.
+    :param gpu: Whether to use GPU acceleration.
+    :param ref_values_only: If True, use reference (homogeneous) medium values.
+    :returns: Tuple of (sensor_data, dt) where sensor_data is a 2D array
+        (n_sensor_points, n_timesteps) and dt is the time step in seconds.
     """
-    from kwave.kgrid import kWaveGrid
-    from kwave.kmedium import kWaveMedium
     from kwave.ksensor import kSensor
     from kwave.ksource import kSource
     from kwave.kspaceFirstOrder3D import kspaceFirstOrder3D