feature(initial): Initial commit

README.md

@@ -12,3 +12,8 @@ short_description: Surfdisp2k25 simulator for dispersion curve generation
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+## Running locally
+
+- Install dependencies with `pip install -r requirements.txt`.
+- Launch the interface via `python app.py` and open the local URL printed by Gradio.

app.py

@@ -1,7 +1,307 @@
-import gradio as gr
+from __future__ import annotations
 
-def greet(name):
-    return "Hello " + name + "!!"
+from typing import Sequence
 
-demo = gr.Interface(fn=greet, inputs="text", outputs="text")
-demo.launch()
+import matplotlib.pyplot as plt
+import numpy as np
+import torch
+
+try:
+    import gradio as gr
+except ModuleNotFoundError:  # pragma: no cover - optional dependency for tests
+    gr = None  # type: ignore[assignment]
+
+from surfdisp2k25 import dispsurf2k25_simulator
+
+MODEL_SIZE = 60
+CUSTOM_MODEL_LABEL = "Custom (enter values below)"
+
+# Preset shear-wave velocity profiles (km/s) sampled over 60 layers.
+PRESET_MODELS: dict[str, np.ndarray] = {
+    "Soft Sedimentary Basin": np.concatenate(
+        [
+            np.linspace(0.8, 1.6, 20, dtype=np.float32),
+            np.linspace(1.6, 2.4, 20, dtype=np.float32),
+            np.linspace(2.4, 3.2, 20, dtype=np.float32),
+        ]
+    ),
+    "Continental Crust": np.concatenate(
+        [
+            np.linspace(2.6, 3.2, 15, dtype=np.float32),
+            np.linspace(3.2, 3.8, 25, dtype=np.float32),
+            np.linspace(3.8, 4.5, 20, dtype=np.float32),
+        ]
+    ),
+    "Oceanic Lithosphere": np.concatenate(
+        [
+            np.linspace(1.8, 2.4, 15, dtype=np.float32),
+            np.linspace(2.4, 3.4, 25, dtype=np.float32),
+            np.linspace(3.4, 4.2, 20, dtype=np.float32),
+        ]
+    ),
+}
+
+DEFAULT_CUSTOM_PROFILE = PRESET_MODELS["Continental Crust"]
+DEFAULT_TABLE = [[float(v)] for v in DEFAULT_CUSTOM_PROFILE]
+
+EARTH_MODEL_OPTIONS = {
+    "Flat Earth (iflsph=0)": 0,
+    "Spherical Earth (iflsph=1)": 1,
+}
+
+WAVE_TYPE_OPTIONS = {
+    "Rayleigh waves (iwave=2)": 2,
+    "Love waves (iwave=1)": 1,
+}
+
+GROUP_VELOCITY_OPTIONS = {
+    "Phase velocity only (igr=0)": 0,
+    "Phase & group velocity (igr=1)": 1,
+}
+
+
+class ValidationError(ValueError):
+    """Raised when user input is invalid."""
+
+
+def _fail(message: str) -> None:
+    if gr is not None:
+        raise gr.Error(message)
+    raise ValidationError(message)
+
+
+def _extract_model_values(
+    model_label: str, table_values: Sequence[Sequence[float]]
+) -> np.ndarray:
+    if model_label != CUSTOM_MODEL_LABEL:
+        return PRESET_MODELS[model_label]
+
+    flattened: list[float] = []
+    for row in table_values:
+        if isinstance(row, (list, tuple)):
+            value = row[0] if row else None
+        else:
+            value = row
+
+        if value in (None, ""):
+            _fail("All 60 custom model rows must contain a value.")
+        try:
+            flattened.append(float(value))
+        except (TypeError, ValueError) as exc:
+            _fail("Custom model values must be numeric.")
+
+    values = np.asarray(flattened, dtype=np.float32)
+    if values.size != MODEL_SIZE:
+        _fail(
+            f"Custom model must contain exactly {MODEL_SIZE} values "
+            f"(received {values.size})."
+        )
+    if np.any((values < 0.0) | (values > 8.0)):
+        _fail("Custom model values must stay between 0 and 8 km/s.")
+    return values
+
+
+def _build_theta(
+    vs_values: np.ndarray, vp_vs_ratio: float, min_depth: float, max_depth: float
+) -> torch.Tensor:
+    if vp_vs_ratio <= 1.0:
+        _fail("Vp/Vs ratio must be greater than 1.0.")
+    if max_depth <= min_depth:
+        _fail("Max depth must be greater than min depth.")
+
+    n_layers = vs_values.size
+    if n_layers == 0:
+        _fail("Model must contain at least one layer.")
+    if n_layers > 100:
+        _fail("Models cannot exceed 100 layers.")
+
+    if n_layers == 1:
+        layer_thickness = 0.0
+    else:
+        layer_thickness = (max_depth - min_depth) / (n_layers - 1)
+
+    thickness = np.full(n_layers, layer_thickness, dtype=np.float32)
+    thickness[-1] = 0.0  # Half-space
+
+    theta = np.concatenate(
+        [
+            np.array([float(n_layers), float(vp_vs_ratio)], dtype=np.float32),
+            thickness,
+            vs_values.astype(np.float32),
+        ]
+    )
+    return torch.from_numpy(theta).unsqueeze(0)
+
+
+def _make_plot(periods: np.ndarray, velocities: np.ndarray):
+    fig, ax = plt.subplots(figsize=(7, 4))
+    ax.plot(periods, velocities, marker="o", markersize=3, linewidth=1.5)
+    ax.set_xlabel("Period (s)")
+    ax.set_ylabel("Phase velocity (km/s)")
+    ax.set_title("SurfDisp2k25 Dispersion Curve")
+    ax.grid(True, linestyle="--", linewidth=0.6, alpha=0.5)
+    fig.tight_layout()
+    return fig
+
+
+def run_simulation(
+    model_label: str,
+    custom_values: Sequence[Sequence[float]],
+    min_depth: float,
+    max_depth: float,
+    vp_vs_ratio: float,
+    p_min: float,
+    p_max: float,
+    earth_model_label: str,
+    wave_type_label: str,
+    mode: int,
+    group_label: str,
+):
+    vs_values = _extract_model_values(model_label, custom_values)
+
+    if p_min <= 0.0 or p_max <= 0.0:
+        _fail("Periods must be positive numbers.")
+    if p_max <= p_min:
+        _fail("Maximum period must be greater than minimum period.")
+    if mode < 1:
+        _fail("Mode number must be at least 1.")
+
+    theta = _build_theta(vs_values, vp_vs_ratio, min_depth, max_depth)
+    iflsph = EARTH_MODEL_OPTIONS[earth_model_label]
+    iwave = WAVE_TYPE_OPTIONS[wave_type_label]
+    igr = GROUP_VELOCITY_OPTIONS[group_label]
+
+    try:
+        disp = dispsurf2k25_simulator(
+            theta=theta,
+            p_min=float(p_min),
+            p_max=float(p_max),
+            kmax=MODEL_SIZE,
+            iflsph=iflsph,
+            iwave=iwave,
+            mode=int(mode),
+            igr=igr,
+            dtype=torch.float32,
+        )
+    except RuntimeError as exc:
+        _fail(f"Simulation failed: {exc}")
+
+    velocities = disp.squeeze(0).detach().cpu().numpy()
+    periods = np.linspace(p_min, p_max, velocities.size)
+    plot = _make_plot(periods, velocities)
+
+    table = [[float(p), float(v)] for p, v in zip(periods, velocities)]
+
+    layer_thickness = 0.0 if vs_values.size <= 1 else (max_depth - min_depth) / (
+        vs_values.size - 1
+    )
+    summary = "\n".join(
+        [
+            f"**Model**: {model_label}",
+            f"**Layers**: {vs_values.size} (Δz ≈ {layer_thickness:.2f} km)",
+            f"**Vs range**: {vs_values.min():.2f} – {vs_values.max():.2f} km/s",
+            f"**Periods**: {p_min:.2f} – {p_max:.2f} s ({velocities.size} samples)",
+            f"**Wave type**: {wave_type_label}; mode = {int(mode)}",
+            f"**Phase velocity range**: {velocities.min():.2f} – {velocities.max():.2f} km/s",
+        ]
+    )
+
+    return plot, table, summary
+
+
+if gr is not None:
+    with gr.Blocks(title="SurfDisp2k25 Simulator") as demo:
+        gr.Markdown(
+            "### SurfDisp2k25 dispersion simulator\n"
+            "Select a preset velocity profile or switch to custom mode to edit the "
+            "60 Vs values (km/s) sampled between the minimum and maximum depth."
+        )
+
+        with gr.Row():
+            with gr.Column():
+                model_selector = gr.Dropdown(
+                    choices=[*PRESET_MODELS.keys(), CUSTOM_MODEL_LABEL],
+                    value="Continental Crust",
+                    label="Shear-wave velocity model",
+                )
+                custom_model = gr.Dataframe(
+                    headers=["Vs (km/s)"],
+                    value=DEFAULT_TABLE,
+                    row_count=(MODEL_SIZE, "fixed"),
+                    col_count=(1, "fixed"),
+                    datatype="float",
+                    label="Custom Vs profile (used when Custom is selected)",
+                )
+                min_depth_input = gr.Number(value=0.0, label="Minimum depth (km)")
+                max_depth_input = gr.Number(value=30.0, label="Maximum depth (km)")
+                vpvs_input = gr.Slider(
+                    minimum=1.5,
+                    maximum=2.2,
+                    value=1.75,
+                    step=0.01,
+                    label="Vp/Vs ratio",
+                )
+            with gr.Column():
+                p_min_input = gr.Number(value=1.0, label="Minimum period (s)")
+                p_max_input = gr.Number(value=30.0, label="Maximum period (s)")
+                earth_model_input = gr.Radio(
+                    choices=list(EARTH_MODEL_OPTIONS.keys()),
+                    value="Flat Earth (iflsph=0)",
+                    label="Earth model",
+                )
+                wave_type_input = gr.Radio(
+                    choices=list(WAVE_TYPE_OPTIONS.keys()),
+                    value="Rayleigh waves (iwave=2)",
+                    label="Wave type",
+                )
+                mode_input = gr.Slider(
+                    minimum=1,
+                    maximum=5,
+                    value=1,
+                    step=1,
+                    label="Mode number",
+                )
+                group_mode_input = gr.Radio(
+                    choices=list(GROUP_VELOCITY_OPTIONS.keys()),
+                    value="Phase velocity only (igr=0)",
+                    label="Velocity output",
+                )
+                run_button = gr.Button("Run simulation", variant="primary")
+
+        with gr.Row():
+            plot_output = gr.Plot(label="Dispersion curve")
+            table_output = gr.Dataframe(
+                headers=["Period (s)", "Phase velocity (km/s)"],
+                datatype="float",
+                col_count=(2, "fixed"),
+                row_count=(MODEL_SIZE, "dynamic"),
+                label="Sampled dispersion values",
+            )
+
+        summary_output = gr.Markdown()
+
+        run_button.click(
+            fn=run_simulation,
+            inputs=[
+                model_selector,
+                custom_model,
+                min_depth_input,
+                max_depth_input,
+                vpvs_input,
+                p_min_input,
+                p_max_input,
+                earth_model_input,
+                wave_type_input,
+                mode_input,
+                group_mode_input,
+            ],
+            outputs=[plot_output, table_output, summary_output],
+        )
+else:  # pragma: no cover - allows importing without gradio installed
+    demo = None
+
+
+if __name__ == "__main__":
+    if demo is None:
+        raise ImportError("gradio must be installed to launch the interface.")
+    demo.launch()

surfdisp2k25/README.md

@@ -0,0 +1,113 @@
+# surfdisp2k25 Extension
+
+This package provides a Python implementation of the surfdisp96 Fortran code, which is used for calculating dispersion curves for surface waves in layered media.
+
+## Overview
+
+The `surfdisp2k25` package includes Python implementations of several key functions from the original Fortran code:
+
+- `dltar`: Computes the period equation for Love or Rayleigh waves
+- `dltar1`: Computes the period equation for Love waves
+- `dltar4`: Computes the period equation for Rayleigh waves
+- `nevill`: Hybrid method for refining a root once it has been bracketed
+- `half`: Interval halving method for refining a root
+- `getsol`: Brackets a dispersion curve and then refines it
+
+## Using the `getsol` Function
+
+The `getsol` function is used to find phase velocities for surface waves at a given period. It first brackets the solution by finding values with opposite signs of the period equation, then refines the solution using the `nevill` function.
+
+### Function Signature
+
+```python
+def getsol(t1, c1, clow, dc, cm, betmx, ifunc, ifirst, d, a, b, rho):
+    """
+    Bracket dispersion curve and then refine it.
+    
+    Parameters
+    ----------
+    t1 : float
+        Period in seconds.
+    c1 : float
+        Initial phase velocity estimate in km/s.
+    clow : float
+        Lower bound for phase velocity in km/s.
+    dc : float
+        Phase velocity increment for search in km/s.
+    cm : float
+        Minimum phase velocity to consider in km/s.
+    betmx : float
+        Maximum phase velocity to consider in km/s.
+    ifunc : int
+        Wave type: 1 for Love waves, 2 for Rayleigh waves.
+    ifirst : int
+        First call flag: 1 for first call, 0 otherwise.
+    d : array_like
+        Layer thicknesses in km.
+    a : array_like
+        P-wave velocities in km/s.
+    b : array_like
+        S-wave velocities in km/s.
+    rho : array_like
+        Densities in g/cm^3.
+    
+    Returns
+    -------
+    tuple
+        A tuple containing:
+        - c1: float, the refined phase velocity in km/s.
+        - iret: int, return code (1 for success, -1 for failure).
+    """
+```
+
+### Example Usage
+
+```python
+import numpy as np
+from migrate.extensions.surfdisp2k25 import getsol
+
+# Define a three-layer model
+d = np.array([2.0, 5.0, 10.0])  # Layer thicknesses in km
+a = np.array([5.8, 6.8, 8.0])   # P-wave velocities in km/s
+b = np.array([3.2, 3.9, 4.5])   # S-wave velocities in km/s
+rho = np.array([2.7, 3.0, 3.3]) # Densities in g/cm^3
+
+# Parameters for getsol
+t1 = 10.0        # Period in seconds
+c1 = 3.0         # Initial phase velocity estimate in km/s
+clow = 2.0       # Lower bound for phase velocity
+dc = 0.01        # Phase velocity increment
+cm = 2.0         # Minimum phase velocity
+betmx = 5.0      # Maximum phase velocity
+ifunc = 2        # 2 for Rayleigh waves, 1 for Love waves
+ifirst = 1       # 1 for first call, 0 otherwise
+
+# Call getsol to find the phase velocity
+c_refined, iret = getsol(t1, c1, clow, dc, cm, betmx, ifunc, ifirst, d, a, b, rho)
+
+if iret == 1:
+    print(f"Found phase velocity: {c_refined} km/s")
+else:
+    print("Failed to find a solution")
+```
+
+## Differences from the Original Fortran Code
+
+The Python implementation differs from the original Fortran code in several ways:
+
+1. **Return Values**: Instead of using output arguments, the Python functions return values directly. For example, `getsol` returns a tuple containing the refined phase velocity and a return code.
+
+2. **Error Handling**: The Python implementation includes proper error handling with descriptive error messages.
+
+3. **Array Handling**: The Python implementation uses NumPy arrays instead of Fortran arrays, which provides more flexibility and better performance.
+
+4. **Static Variables**: The Fortran code uses static variables to save state between calls. The Python implementation simulates this using function attributes.
+
+5. **Control Flow**: The Python implementation replaces goto statements with more structured control flow constructs like loops and conditional statements.
+
+## Implementation Notes
+
+- The `dltar`, `dltar1`, and `dltar4` functions are different methods for calculating the period equation for different wave types.
+- The `nevill` function uses a combination of Neville's algorithm and interval halving to refine a root.
+- The `half` function implements a simple interval halving method for root finding.
+- The `getsol` function combines these methods to find phase velocities for dispersion curves.

surfdisp2k25/README_dispsurf2k25.md

@@ -0,0 +1,129 @@
+# dispsurf2k25 Function
+
+## Overview
+
+The `dispsurf2k25` function is a Python implementation of the Fortran subroutine `surfdisp96` from the `surfdisp96.f90` file. It calculates surface wave dispersion curves for either Love waves or Rayleigh waves.
+
+## Implementation Details
+
+The implementation follows these key principles:
+
+1. **Pure Python Implementation**: The function is implemented in pure Python using NumPy for array operations.
+2. **Return Values Instead of Output Arguments**: Unlike the Fortran subroutine which uses output arguments, the Python implementation returns values as a tuple.
+3. **Python Implementations of Dependencies**: The function uses the Python implementations of `sphere`, `getsol`, and `getsolh` from the `surfdisp2k25` module.
+4. **Input Validation**: The function includes validation of input parameters to ensure they are valid.
+
+## Function Signature
+
+```python
+def dispsurf2k25(thkm, vpm, vsm, rhom, iflsph, iwave, mode, igr, kmax, t):
+    """
+    Calculate surface wave dispersion curves.
+    
+    Parameters
+    ----------
+    thkm : array_like
+        Layer thicknesses in km.
+    vpm : array_like
+        P-wave velocities in km/s.
+    vsm : array_like
+        S-wave velocities in km/s.
+    rhom : array_like
+        Densities in g/cm^3.
+    iflsph : int
+        Flag for spherical earth model: 0 for flat earth, 1 for spherical earth.
+    iwave : int
+        Wave type: 1 for Love waves, 2 for Rayleigh waves.
+    mode : int
+        Mode number to calculate.
+    igr : int
+        Flag for group velocity calculation: 0 for phase velocity only, 1 for phase and group velocity.
+    kmax : int
+        Number of periods to calculate.
+    t : array_like
+        Periods in seconds.
+    
+    Returns
+    -------
+    tuple
+        A tuple containing:
+        - cg: array_like, calculated phase or group velocities in km/s.
+        - err: int, error code (0 for success, 1 for error).
+    """
+```
+
+## Usage Examples
+
+### Basic Usage with Love Waves
+
+```python
+import numpy as np
+from migrate.extensions.surfdisp2k25 import dispsurf2k25
+
+# Create a simple model
+# 3 layers: 2 layers + half-space
+thkm = np.array([10.0, 20.0, 0.0])  # Layer thicknesses in km
+vpm = np.array([5.0, 6.0, 7.0])     # P-wave velocities in km/s
+vsm = np.array([3.0, 3.5, 4.0])     # S-wave velocities in km/s
+rhom = np.array([2.7, 2.9, 3.1])    # Densities in g/cm^3
+
+# Parameters for dispsurf2k25
+iflsph = 0                          # Flat earth model
+iwave = 1                           # Love waves
+mode = 1                            # Fundamental mode
+igr = 0                             # Phase velocity only
+kmax = 5                            # Number of periods
+t = np.array([5.0, 10.0, 15.0, 20.0, 25.0])  # Periods in seconds
+
+# Call the function
+cg, err = dispsurf2k25(thkm, vpm, vsm, rhom, iflsph, iwave, mode, igr, kmax, t)
+print(f"Phase velocities: {cg}")
+print(f"Error code: {err}")
+```
+
+### Usage with Rayleigh Waves
+
+```python
+# Same model as above, but with Rayleigh waves
+iwave = 2  # Rayleigh waves
+
+# Call the function
+cg, err = dispsurf2k25(thkm, vpm, vsm, rhom, iflsph, iwave, mode, igr, kmax, t)
+print(f"Phase velocities: {cg}")
+print(f"Error code: {err}")
+```
+
+### Usage with Group Velocity Calculation
+
+```python
+# Same model as above, but with group velocity calculation
+iwave = 1  # Love waves
+igr = 1    # Group velocity calculation
+
+# Call the function
+cg, err = dispsurf2k25(thkm, vpm, vsm, rhom, iflsph, iwave, mode, igr, kmax, t)
+print(f"Group velocities: {cg}")
+print(f"Error code: {err}")
+```
+
+### Usage with Spherical Earth Model
+
+```python
+# Same model as above, but with spherical earth model
+iflsph = 1  # Spherical earth model
+iwave = 1   # Love waves
+igr = 0     # Phase velocity only
+
+# Call the function
+cg, err = dispsurf2k25(thkm, vpm, vsm, rhom, iflsph, iwave, mode, igr, kmax, t)
+print(f"Phase velocities: {cg}")
+print(f"Error code: {err}")
+```
+
+## Notes
+
+- The function returns an error code of 1 if it encounters an error during the calculation, such as not finding a root for a particular period.
+- For periods where a root is not found, the corresponding velocity in the output array is set to 0.0.
+- The function handles both Love waves (iwave=1) and Rayleigh waves (iwave=2).
+- The function can calculate either phase velocities only (igr=0) or both phase and group velocities (igr=1).
+- The function can handle both flat earth models (iflsph=0) and spherical earth models (iflsph=1).

surfdisp2k25/__init__.py

@@ -0,0 +1,37 @@
+"""
+Python implementation of the surfdisp96 extension.
+
+This module provides functions for calculating dispersion curves for surface waves
+in layered media. It is a pure Python implementation of the surfdisp96 Fortran code.
+"""
+
+import numpy as np
+
+# Import functions from their respective modules
+from .getsol import getsol
+from .getsolh import getsolh
+from .dispsurf2k25 import dispsurf2k25, dispsurf2k25_simulator
+from .normc import normc
+from .var import var
+from .dnka import dnka
+from .dltar import dltar, dltar1, dltar4
+from .half import half
+from .nevill import nevill
+from .sphere import sphere
+
+# Define the public API
+__all__ = [
+    'getsol',
+    'getsolh',
+    'dispsurf2k25_simulator',
+    'dispsurf2k25',
+    'normc',
+    'var',
+    'dnka',
+    'dltar',
+    'dltar1',
+    'dltar4',
+    'half',
+    'nevill',
+    'sphere'
+]

surfdisp2k25/dispsurf2k25.py

@@ -0,0 +1,477 @@
+"""
+Python implementation of the surfdisp96 subroutine from surfdisp96.f90.
+
+This module provides a Python implementation of the surfdisp96 subroutine
+from the surfdisp96 Fortran code, which is responsible for calculating
+surface wave dispersion curves.
+"""
+
+import numpy as np
+import torch
+from typing import Tuple, List, Union, Optional, Any
+from types import SimpleNamespace
+
+try:
+    import migrate.extensions.surfdisp2k25 as sd2k25  # type: ignore
+except ModuleNotFoundError:  # pragma: no cover - fallback for pure Python envs
+    from .sphere import sphere as _sphere
+    from .getsol import getsol as _getsol
+    from .getsolh import getsolh as _getsolh
+    from .dltar import dltar as _dltar
+    from .nevill import nevill as _nevill
+
+    sd2k25 = SimpleNamespace(
+        sphere=_sphere,
+        getsol=_getsol,
+        getsolh=_getsolh,
+        dltar=_dltar,
+        nevill=_nevill,
+    )
+
+
+def dispsurf2k25_simulator(
+        theta: torch.Tensor,
+        p_min: float,
+        p_max: float,
+        kmax: int,
+        iflsph: int = 0,
+        iwave: int = 2,
+        mode: int = 1,
+        igr: int = 1,
+        dtype: torch.dtype = torch.float32,
+) -> torch.Tensor:
+    """
+    surfdisp2k25_simulator
+    """
+    bs = theta.shape[0]
+
+    # To numpy
+    theta = theta.numpy()
+
+    # Output dispersion curves
+    output_disp = np.zeros((bs, kmax))
+
+    # Prepare periods
+    t = np.linspace(p_min, p_max, kmax)
+
+    for b_i in range(bs):
+        # Prepare inputs
+        thkm = np.zeros(100)
+        vpm = np.zeros(100)
+        vsm = np.zeros(100)
+        rhom = np.zeros(100)
+
+        # Compute max. layer
+        max_layer = (theta.shape[1] - 2) // 2
+
+        # Number of layers
+        n = int(theta[b_i, 0])
+        vpvs = theta[b_i, 1]
+
+        # Get parameters
+        h = theta[b_i, 2:max_layer+2]
+        vs = theta[b_i, max_layer+2:]
+
+        # Get Vp
+        vp = vs * vpvs
+
+        # Get rho (simple linear law)
+        rho = 0.32 + 0.77 * vp
+
+        # Prepare inputs
+        thkm[:n] = h[:n]
+        vpm[:n] = vp[:n]
+        vsm[:n] = vs[:n]
+        rhom[:n] = rho[:n]
+
+        # Run simulation
+        disp_y, err = dispsurf2k25(
+            thkm=thkm,
+            vsm=vsm,
+            vpm=vpm,
+            rhom=rhom,
+            nlayer=n,
+            iflsph=iflsph,
+            iwave=iwave,
+            mode=mode,
+            igr=igr,
+            kmax=60,
+            t=t,
+        )
+
+        if err != 0:
+            raise RuntimeError(f"Simulation {b_i} failed with error: {err}")
+        # end if
+
+        output_disp[b_i, :] = disp_y
+    # end for
+
+    return torch.from_numpy(output_disp).to(dtype)
+# end dispsurf2k25_simulator
+
+
+def dispsurf2k25(
+        thkm: np.ndarray,
+        vpm: np.ndarray,
+        vsm: np.ndarray,
+        rhom: np.ndarray,
+        nlayer: int,
+        iflsph: int,
+        iwave: int,
+        mode: int,
+        igr: int,
+        kmax: int,
+        t: np.ndarray
+) -> Tuple[np.ndarray, int]:
+    """
+    Calculate surface wave dispersion curves.
+    
+    This is a pure Python implementation of the surfdisp96 Fortran subroutine.
+    
+    Parameters
+    ----------
+    thkm : array_like
+        Layer thicknesses in km.
+    vpm : array_like
+        P-wave velocities in km/s.
+    vsm : array_like
+        S-wave velocities in km/s.
+    rhom : array_like
+        Densities in g/cm^3.
+    iflsph : int
+        Flag for spherical earth model: 0 for flat earth, 1 for spherical earth.
+    iwave : int
+        Wave type: 1 for Love waves, 2 for Rayleigh waves.
+    mode : int
+        Mode number to calculate.
+    igr : int
+        Flag for group velocity calculation: 0 for phase velocity only, 1 for phase and group velocity.
+    kmax : int
+        Number of periods to calculate.
+    t : array_like
+        Periods in seconds.
+    
+    Returns
+    -------
+    tuple
+        A tuple containing:
+        - cg: array_like, calculated phase or group velocities in km/s.
+        - err: int, error code (0 for success, 1 for error).
+    """
+    # Parameters
+    LER = 0
+    LIN = 5
+    LOT = 6
+    NL = 100
+    NLAY = 100
+    NL2 = NL + NL
+    NP = 60
+
+    # Check sizes
+    assert thkm.ndim == 1 and thkm.shape[0] == NLAY, f"thkm must be 1dim (but is {thkm.ndim}), and shape {NLAY} (but is {thkm.shape})."
+    assert vpm.ndim == 1 and vpm.shape[0] == NLAY, f"vpm must be 1dim (but is {vpm.ndim}), and shape {NLAY} (but is {vpm.shape})."
+    assert vsm.ndim == 1 and vsm.shape[0] == NLAY, f"vsm must be 1dim (but is {vsm.ndim}), and shape {NLAY} (but is {vsm.shape})."
+    assert rhom.ndim == 1 and rhom.shape[0] == NLAY, f"rhom must be 1dim (but is {rhom.ndim}), and shape {NLAY} (but is {rhom.shape})."
+    assert t.ndim == 1 and t.shape[0] == NP, f"t must be 1dim (but is {t.ndim}), and shape {NP} (but is {t.shape})."
+
+    # Arguments
+    cg = np.zeros(NP, dtype=np.float64)
+
+    # Local variables
+    c = np.zeros(NP, dtype=np.float64)
+    cb = np.zeros(NP, dtype=np.float64)
+    d = np.zeros(NL, dtype=np.float64)
+    a = np.zeros(NL, dtype=np.float64)
+    b = np.zeros(NL, dtype=np.float64)
+    rho = np.zeros(NL, dtype=np.float64)
+    rtp = np.zeros(NL, dtype=np.float64)
+    dtp = np.zeros(NL, dtype=np.float64)
+    btp = np.zeros(NL, dtype=np.float64)
+    iverb = np.zeros(3, dtype=np.int32)
+
+    mmax = nlayer
+    nsph = iflsph
+    err = 0
+
+    # Save current values
+    b[:mmax] = vsm[:mmax]
+    a[:mmax] = vpm[:mmax]
+    d[:mmax] = thkm[:mmax]
+    rho[:mmax] = rhom[:mmax]
+    
+    # Check if iwave is valid
+    if iwave not in [1, 2]:
+        raise ValueError(
+            "iwave must be 1 (Love waves) or 2 (Rayleigh waves)"
+        )
+    # end if
+    
+    # Set up wave type
+    if iwave == 1:
+        idispl = kmax
+        idispr = 0
+    elif iwave == 2:
+        idispl = 0
+        idispr = kmax
+    else:
+        raise ValueError("iwave must be 1 or 2")
+    # end if
+
+    iverb[1] = 0
+    iverb[2] = 0
+    
+    # Constants
+    sone0 = 1.500
+    ddc0 = 0.005
+    h0 = 0.005
+
+    # Check for water layer
+    llw = 1
+    if b[0] <= 0.0:
+        llw = 2
+    # end if
+    twopi = 2.0 * np.pi
+    one = 1.0e-2
+    # Apply spherical earth transformation if needed
+    if nsph == 1:
+        d, a, b, rho, rtp, dtp, btp = sd2k25.sphere(
+            ifunc=0,
+            iflag=0,
+            d=d,
+            a=a,
+            b=b,
+            rho=rho,
+            rtp=rtp,
+            dtp=dtp,
+            btp=btp,
+            mmax=mmax,
+            llw=llw,
+            twopi=twopi
+        )
+    # end if
+    
+    JMN = 0
+    betmx = -1.0e20
+    betmn = 1.0e20
+    # Find the extremal velocities to assist in starting search
+    for i in range(nlayer):
+        if 0.01 < b[i] < betmn:
+            betmn = b[i]
+            JMN = i
+            jsol = 1
+        elif b[i] <= 0.01 and a[i] < betmn:
+            betmn = a[i]
+            JMN = i
+            jsol = 0
+        # end if
+        
+        if b[i] > betmx:
+            betmx = b[i]
+        # end if
+    # end for
+    # Loop over wave types
+    for ifunc in [1, 2]:
+        if ifunc == 1 and idispl <= 0:
+            continue
+        # end if
+
+        if ifunc == 2 and idispr <= 0:
+            continue
+        # end if
+        
+        # Apply spherical earth transformation for current wave type
+        if nsph == 1:
+            d, a, b, rho, rtp, dtp, btp = sd2k25.sphere(
+                ifunc=ifunc,
+                iflag=1,
+                d=d,
+                a=a,
+                b=b,
+                rho=rho,
+                rtp=rtp,
+                dtp=dtp,
+                btp=btp,
+                mmax=mmax,
+                llw=llw,
+                twopi=twopi
+            )
+        # end if
+        ddc = ddc0
+        sone = sone0
+        h = h0
+        
+        if sone < 0.01:
+            sone = 2.0
+        # end if
+        
+        onea = sone
+        
+        # Get starting value for phase velocity
+        if jsol == 0:
+            # Water layer
+            cc1 = betmn
+        else:
+            # Solid layer solves halfspace period equation
+            cc1 = sd2k25.getsolh(
+                a=float(a[JMN]),
+                b=float(b[JMN])
+            )
+        # end if
+        # Back off a bit to get a starting value at a lower phase velocity
+        cc1 = 0.95 * cc1
+        cc1 = 0.90 * cc1
+        cc = cc1
+        dc = ddc
+        dc = abs(dc)
+        c1 = cc
+        cm = cc
+        
+        # Initialize arrays
+        cb[:kmax] = 0.0
+        c[:kmax] = 0.0
+        
+        ift = 999
+        # Loop over modes
+        # Warning: iq is from [1...mode]
+        for iq in range(1, mode + 1):
+            is_ = 0
+            ie = kmax
+            itst = ifunc
+            
+            # Loop over periods
+            for k in range(is_, ie):
+                if k >= ift:
+                    break
+                # end if
+
+                # Get the period
+                t1 = t[k]
+
+                if igr > 0:
+                    t1a = t1 / (1.0 + h)
+                    t1b = t1 / (1.0 - h)
+                    t1 = t1a
+                else:
+                    t1a = t1
+                # end if igr > 0
+                
+                # Get initial phase velocity estimate to begin search
+                if k == is_ and iq == 1:
+                    c1 = cc
+                    clow = cc
+                    ifirst = 1
+                elif k == is_ and iq > 1:
+                    c1 = c[is_] + one * dc
+                    clow = c1
+                    ifirst = 1
+                elif k > is_ and iq > 1:
+                    ifirst = 0
+                    clow = c[k] + one * dc
+                    c1 = c[k-1]
+                    if c1 < clow:
+                        c1 = clow
+                    # end if
+                elif k > is_ and iq == 1:
+                    ifirst = 0
+                    c1 = c[k-1] - onea * dc
+                    clow = cm
+                else:
+                    raise ValueError(f"Impossible to get initial phase velocity")
+                # end if
+                
+                # Bracket root and refine it
+                c1, iret = sd2k25.getsol(
+                    t1=t1,
+                    c1=c1,
+                    clow=clow,
+                    dc=dc,
+                    cm=cm,
+                    betmx=betmx,
+                    ifunc=ifunc,
+                    ifirst=ifirst,
+                    d=d,
+                    a=a,
+                    b=b,
+                    rho=rho,
+                    rtp=rtp,
+                    dtp=dtp,
+                    btp=btp,
+                    mmax=mmax,
+                    llw=llw
+                )
+                
+                if iret == -1:
+                    break
+                # end if
+                
+                c[k] = c1
+                
+                # For group velocities compute near above solution
+                if igr > 0:
+                    t1 = t1b
+                    ifirst = 0
+                    clow = cb[k] + one * dc
+                    c1 = c1 - onea * dc
+                    c1, iret = sd2k25.getsol(
+                        t1=t1,
+                        c1=c1,
+                        clow=clow,
+                        dc=dc,
+                        cm=cm,
+                        betmx=betmx,
+                        ifunc=ifunc,
+                        ifirst=ifirst,
+                        d=d,
+                        a=a,
+                        b=b,
+                        rho=rho,
+                        rtp=rtp,
+                        dtp=dtp,
+                        btp=btp,
+                        mmax=mmax,
+                        llw=llw
+                    )
+                    
+                    # Test if root not found at slightly larger period
+                    if iret == -1:
+                        c1 = c[k]
+                    # end if
+                    
+                    cb[k] = c1
+                else:
+                    c1 = 0.0
+                # end if igr
+                
+                cc0 = c[k]
+                cc1 = c1
+                
+                if igr == 0:
+                    # Output only phase velocity
+                    cg[k] = cc0
+                else:
+                    # Calculate group velocity and output phase and group velocities
+                    gvel = (1.0 / t1a - 1.0 / t1b) / (1.0 / (t1a*cc0) - 1.0 / (t1b*cc1))
+                    cg[k] = gvel
+                # end if igr
+            # end for k is_..ie
+
+            # If we broke out of the loop early
+            if iverb[ifunc] == 0 and iq <= 1:
+                # raise RuntimeError(f"Error, loop finished to early")
+                pass
+            # end if
+            
+            ift = k
+            itst = 0
+            
+            # Set the remaining values to 0
+            # for i in range(k, ie):
+            #     t1a = t[i]
+            #     cg[i] = 0.0
+            # # end for k...ie
+
+        # end for iq 1...mode
+    # end for ifunc
+    
+    return cg, err
+# end def dispsurf2k25

surfdisp2k25/dltar.py

@@ -0,0 +1,454 @@
+"""
+Compute the period equation for Love and Rayleigh waves.
+
+This module contains the dltar, dltar1, and dltar4 functions, which are pure Python
+implementations of the dltar_, dltar1_, and dltar4_ Fortran functions.
+"""
+
+# Imports
+import numpy as np
+from typing import List, Union, Tuple
+from .var import var
+from .dnka import dnka
+from .normc import normc
+
+
+def dltar1(
+        wvno: float,
+        omega: float,
+        d: np.ndarray,
+        a: np.ndarray,
+        b: np.ndarray,
+        rho: np.ndarray,
+        rtp: np.ndarray,
+        dtp: np.ndarray,
+        btp: np.ndarray,
+        mmax: int,
+        llw: int,
+        twopi: int
+) -> float:
+    """
+    Compute the period equation for Love waves.
+    
+    This is a pure Python implementation of the dltar1_ Fortran function.
+    
+    Parameters
+    ----------
+    wvno : float
+        Wave number in rad/km.
+    omega : float
+        Angular frequency in rad/s.
+    d : array_like
+        Layer thicknesses in km.
+    a : array_like
+        P-wave velocities in km/s.
+    b : array_like
+        S-wave velocities in km/s.
+    rho : array_like
+        Densities in g/cm^3.
+    
+    Returns
+    -------
+    float
+        Value of the period equation for Love waves.
+    """
+    # print(">>>>>>>>>>>>>>>>>>>>>>")
+    # print("Calling dltar1 ...")
+    # print(f"wvno={wvno}")
+    # print(f"omega={omega}")
+    # print(f"d={d}")
+    # print(f"a={a}")
+    # print(f"b={b}")
+    # print(f"rho={rho}")
+    # print(f"rtp={rtp}")
+    # print(f"dtp={dtp}")
+    # print(f"btp={btp}")
+    # print(f"mmax={mmax}")
+    # print(f"llw={llw}")
+    # print(f"twopi={twopi}")
+    # Determine if there's a water layer
+    llw = 1
+    if b[0] <= 0.0:
+        llw = 2
+    # end if
+    
+    # Haskell-Thompson love wave formulation from halfspace to surface
+    # Using the exact same variable names and calculations as the Fortran code
+    beta1 = float(b[mmax-1])
+    rho1 = float(rho[mmax-1])
+    xkb = omega / beta1
+    wvnop = wvno + xkb
+    wvnom = abs(wvno - xkb)
+    rb = np.sqrt(wvnop * wvnom)
+    e1 = rho1 * rb
+    e2 = 1.0 / (beta1 * beta1)
+    mmm1 = mmax - 1
+    
+    # Loop from bottom layer to top (or water layer)
+    for m in range(mmm1, llw-1, -1):
+        beta1 = float(b[m])
+        rho1 = float(rho[m])
+        xmu = rho1 * beta1 * beta1
+        xkb = omega / beta1
+        wvnop = wvno + xkb
+        wvnom = abs(wvno - xkb)
+        rb = np.sqrt(wvnop * wvnom)
+        q = float(d[m]) * rb
+        
+        # Calculate sinq, y, z, cosq based on the relationship between wvno and xkb
+        if wvno < xkb:
+            # Propagating case
+            sinq = np.sin(q)
+            y = sinq / rb
+            z = -rb * sinq
+            cosq = np.cos(q)
+        elif wvno == xkb:
+            # Special case: wvno equals xkb
+            cosq = 1.0
+            y = float(d[m])
+            z = 0.0
+        else:
+            # Evanescent case
+            fac = 0.0
+            if q < 16:
+                fac = np.exp(-2.0 * q)
+            cosq = (1.0 + fac) * 0.5
+            sinq = (1.0 - fac) * 0.5
+            y = sinq / rb
+            z = rb * sinq
+        # end if wvno
+        
+        # Calculate the new values of e1 and e2
+        e10 = e1 * cosq + e2 * xmu * z
+        e20 = e1 * y / xmu + e2 * cosq
+        
+        # Normalize to prevent overflow
+        xnor = abs(e10)
+        ynor = abs(e20)
+        
+        if ynor > xnor:
+            xnor = ynor
+        # end if
+
+        if xnor < 1.0e-40:
+            xnor = 1.0
+        # end if
+        
+        e1 = e10 / xnor
+        e2 = e20 / xnor
+    # end for m
+    
+    # Return the final value of e1
+    # This is the value of the period equation for Love waves
+    # The sign is determined by the calculations above and must match the expected values
+    # print(f"e1={e1}")
+    # print(">>>>>>>>>>>>>>>>>>>>>>")
+    return e1
+# end def dltar1
+
+
+def dltar4(
+        wvno: float,
+        omega: float,
+        d: np.ndarray,
+        a: np.ndarray,
+        b: np.ndarray,
+        rho: np.ndarray,
+        rtp: np.ndarray,
+        dtp: np.ndarray,
+        btp: np.ndarray,
+        mmax: int,
+        llw: int,
+        twopi: int
+) -> float:
+    """
+    Compute the period equation for Rayleigh waves.
+    
+    This is a pure Python implementation of the dltar4_ Fortran function.
+    
+    Parameters
+    ----------
+    wvno : float
+        Wave number in rad/km.
+    omega : float
+        Angular frequency in rad/s.
+    d : array_like
+        Layer thicknesses in km.
+    a : array_like
+        P-wave velocities in km/s.
+    b : array_like
+        S-wave velocities in km/s.
+    rho : array_like
+        Densities in g/cm^3.
+    
+    Returns
+    -------
+    float
+        Value of the period equation for Rayleigh waves.
+    """
+    # print("$$$$$$$$$$$$$$$$$$$$$$$$$$")
+    # print("Entering dltar4")
+    # Make sure omega is not too small
+    if omega < 1.0e-4:
+        omega = 1.0e-4
+    # end if
+    
+    # Calculate wave number squared
+    wvno2 = wvno * wvno
+    
+    # Calculate parameters for the bottom half-space
+    xka = omega / a[mmax-1]
+    xkb = omega / b[mmax-1]
+    wvnop = wvno + xka
+    wvnom = abs(wvno - xka)
+    ra = np.sqrt(wvnop * wvnom)
+    wvnop = wvno + xkb
+    wvnom = abs(wvno - xkb)
+    rb = np.sqrt(wvnop * wvnom)
+    t = b[mmax-1] / omega
+    
+    # E matrix for the bottom half-space
+    gammk = 2.0 * t * t
+    gam = gammk * wvno2
+    gamm1 = gam - 1.0
+    rho1 = rho[mmax-1]
+    
+    e = np.zeros(5)
+    e[0] = rho1 * rho1 * (gamm1 * gamm1 - gam * gammk * ra * rb)
+    e[1] = -rho1 * ra
+    e[2] = rho1 * (gamm1 - gammk * ra * rb)
+    e[3] = rho1 * rb
+    e[4] = wvno2 - ra * rb
+    # print(f"wvno2 = {wvno2}")
+    # print(f"xka = {xka}")
+    # print(f"xkb = {xkb}")
+    # print(f"wvnop = {wvnop}")
+    # print(f"wvnom = {wvnom}")
+    # print(f"ra = {ra}")
+    # print(f"rb = {rb}")
+    # print(f"t = {t}")
+    # print(f"gammk = {gammk}")
+    # print(f"gam = {gam}")
+    # print(f"gamm1 = {gamm1}")
+    # print(f"rho1 = {rho1}")
+    # print(f"e = {e}")
+    # print("--")
+    # Matrix multiplication from bottom layer upward
+    mmm1 = mmax - 2
+    # print(f"mmm1-1 = {mmm1}")
+    # print(f"llw = {llw-1}")
+    for m in range(mmm1, llw-2, -1):
+        xka = omega / a[m]
+        xkb = omega / b[m]
+        t = b[m] / omega
+        gammk = 2.0 * t * t
+        gam = gammk * wvno2
+        wvnop = wvno + xka
+        wvnom = abs(wvno - xka)
+        ra = np.sqrt(wvnop * wvnom)
+        wvnop = wvno + xkb
+        wvnom = abs(wvno - xkb)
+        rb = np.sqrt(wvnop * wvnom)
+        dpth = d[m]
+        rho1 = rho[m]
+        p = ra * dpth
+        q = rb * dpth
+        beta = b[m]
+        # print(f"xka = {xka}")
+        # print(f"xkb = {xkb}")
+        # print(f"t = {t}")
+        # print(f"gammk = {gammk}")
+        # print(f"gam = {gam}")
+        # print(f"wvnop = {wvnop}")
+        # print(f"wvnom = {wvnom}")
+        # print(f"ra = {ra}")
+        # print(f"rb = {rb}")
+        # print(f"dpth = {dpth}")
+        # print(f"rho1 = {rho1}")
+        # print(f"p = {p}")
+        # print(f"q = {q}")
+        # Evaluate variables for the compound matrix
+        w, cosp, exa, a0, cpcq, cpy, cpz, cqw, cqx, xy, xz, wy, wz = var(
+            p=p,
+            q=q,
+            ra=ra,
+            rb=rb,
+            wvno=wvno,
+            xka=xka,
+            xkb=xkb,
+            dpth=dpth
+        )
+        
+        # Evaluate Dunkin's matrix
+        ca = dnka(
+            wvno2=wvno2,
+            gam=gam,
+            gammk=gammk,
+            rho=rho1,
+            a0=a0,
+            cpcq=cpcq,
+            cpy=cpy,
+            cpz=cpz,
+            cqw=cqw,
+            cqx=cqx,
+            xy=xy,
+            xz=xz,
+            wy=wy,
+            wz=wz
+        )
+        
+        # Matrix multiplication
+        ee = np.zeros(5)
+        for i in range(5):
+            cr = 0.0
+            for j in range(5):
+                cr += e[j] * ca[j, i]
+            # end for
+            ee[i] = cr
+        # end for
+        
+        # Normalize to prevent overflow
+        ee, _ = normc(
+            ee=ee
+        )
+        
+        # Update e matrix
+        e = ee.copy()
+    # end for m
+    
+    # Include water layer if present
+    if llw != 1:
+        # Water layer at the top
+        xka = omega / a[0]
+        wvnop = wvno + xka
+        wvnom = abs(wvno - xka)
+        ra = np.sqrt(wvnop * wvnom)
+        dpth = d[0]
+        rho1 = rho[0]
+        p = ra * dpth
+        beta = b[0]
+        
+        # Calculate variables for water layer
+        znul = 1.0e-5
+        w, cosp, exa, a0, cpcq, cpy, cpz, cqw, cqx, xy, xz, wy, wz = var(
+            p=p,
+            q=znul,
+            ra=ra,
+            rb=znul,
+            wvno=wvno,
+            xka=xka,
+            xkb=znul,
+            dpth=dpth
+        )
+        
+        w0 = -rho1 * w
+        # print(f"out = {cosp * e[0] + w0 * e[1]}")
+        # print("$$$$$$$$$$$$$$$$$$$$$$$$$$")
+        return cosp * e[0] + w0 * e[1]
+    else:
+        # print(f"out = {e[0]}")
+        # print("$$$$$$$$$$$$$$$$$$$$$$$$$$")
+        return e[0]
+    # end if llw
+
+# end def dltar4
+
+
+def dltar(
+        wvno: float,
+        omega: float,
+        kk: int,
+        d: np.ndarray,
+        a: np.ndarray,
+        b: np.ndarray,
+        rho: np.ndarray,
+        rtp: np.ndarray,
+        dtp: np.ndarray,
+        btp: np.ndarray,
+        mmax: int,
+        llw: int,
+        twopi: int
+) -> float:
+    """
+    Compute the period equation for Love or Rayleigh waves.
+    
+    This is a pure Python implementation of the dltar_ Fortran function.
+    
+    Parameters
+    ----------
+    wvno : float
+        Wave number in rad/km.
+    omega : float
+        Angular frequency in rad/s.
+    kk : int
+        Wave type: 1 for Love waves, 2 for Rayleigh waves.
+    d : array_like
+        Layer thicknesses in km.
+    a : array_like
+        P-wave velocities in km/s.
+    b : array_like
+        S-wave velocities in km/s.
+    rho : array_like
+        Densities in g/cm^3.
+    
+    Returns
+    -------
+    float
+        Value of the period equation for the specified wave type.
+    """
+    # print(">>>>>>>>>>>>>>>>>>>>>>")
+    # print("Calling dltar ...")
+    # print(f"wvno={wvno}")
+    # print(f"omega={omega}")
+    # print(f"d={d}")
+    # print(f"a={a}")
+    # print(f"b={b}")
+    # print(f"rho={rho}")
+    # print(f"rtp={rtp}")
+    # print(f"dtp={dtp}")
+    # print(f"btp={btp}")
+    # print(f"mmax={mmax}")
+    # print(f"llw={llw}")
+    # print(f"twopi={twopi}")
+    # Check if kk is valid
+    if kk not in [1, 2]:
+        raise ValueError("kk must be 1 (Love waves) or 2 (Rayleigh waves)")
+    # end if
+    
+    # Dispatch to the appropriate function
+    if kk == 1:
+        # print("Love wave period equation")
+        # Love wave period equation
+        return dltar1(
+            wvno=wvno,
+            omega=omega,
+            d=d,
+            a=a,
+            b=b,
+            rho=rho,
+            rtp=rtp,
+            dtp=dtp,
+            btp=btp,
+            mmax=mmax,
+            llw=llw,
+            twopi=twopi
+        )
+    else:  # kk == 2
+        # print("Rayleigh wave period equation")
+        # Rayleigh wave period equation
+        return dltar4(
+            wvno=wvno,
+            omega=omega,
+            d=d,
+            a=a,
+            b=b,
+            rho=rho,
+            rtp=rtp,
+            dtp=dtp,
+            btp=btp,
+            mmax=mmax,
+            llw=llw,
+            twopi=twopi
+        )
+    # end if kk
+# end def dltar

surfdisp2k25/dnka.py

@@ -0,0 +1,119 @@
+"""
+Calculate Dunkin's matrix for layered media.
+
+This module contains the dnka function, which is a pure Python implementation
+of the dnka_ Fortran subroutine.
+"""
+
+# Imports
+import numpy as np
+from typing import List, Union, Tuple
+
+
+def dnka(
+        wvno2: float,
+        gam: float,
+        gammk: float,
+        rho: float,
+        a0: float,
+        cpcq: float,
+        cpy: float,
+        cpz: float,
+        cqw: float,
+        cqx: float,
+        xy: float,
+        xz: float,
+        wy: float,
+        wz: float
+) -> np.ndarray:
+    """
+    Calculate Dunkin's matrix for layered media.
+    
+    This is a pure Python implementation of the dnka_ Fortran subroutine.
+    
+    Parameters
+    ----------
+    wvno2 : float
+        Square of horizontal wavenumber in (rad/km)^2.
+    gam : float
+        Parameter gamma.
+    gammk : float
+        Parameter gamma_k.
+    rho : float
+        Density in g/cm^3.
+    a0 : float
+        Parameter a0 from var function.
+    cpcq : float
+        Parameter cpcq from var function.
+    cpy : float
+        Parameter cpy from var function.
+    cpz : float
+        Parameter cpz from var function.
+    cqw : float
+        Parameter cqw from var function.
+    cqx : float
+        Parameter cqx from var function.
+    xy : float
+        Parameter xy from var function.
+    xz : float
+        Parameter xz from var function.
+    wy : float
+        Parameter wy from var function.
+    wz : float
+        Parameter wz from var function.
+    
+    Returns
+    -------
+    numpy.ndarray
+        5x5 Dunkin's matrix used in the calculation of dispersion curves for Rayleigh waves.
+    """
+    # Constants
+    one = 1.0
+    two = 2.0
+    
+    # Calculate intermediate values
+    gamm1 = gam - one
+    twgm1 = gam + gamm1
+    gmgmk = gam * gammk
+    gmgm1 = gam * gamm1
+    gm1sq = gamm1 * gamm1
+    rho2 = rho * rho
+    a0pq = a0 - cpcq
+    
+    # Initialize the output matrix
+    ca = np.zeros((5, 5))
+    
+    # Calculate Dunkin's matrix elements
+    ca[0, 0] = cpcq - two * gmgm1 * a0pq - gmgmk * xz - wvno2 * gm1sq * wy
+    ca[0, 1] = (wvno2 * cpy - cqx) / rho
+    ca[0, 2] = -(twgm1 * a0pq + gammk * xz + wvno2 * gamm1 * wy) / rho
+    ca[0, 3] = (cpz - wvno2 * cqw) / rho
+    ca[0, 4] = -(two * wvno2 * a0pq + xz + wvno2 * wvno2 * wy) / rho2
+    
+    ca[1, 0] = (gmgmk * cpz - gm1sq * cqw) * rho
+    ca[1, 1] = cpcq
+    ca[1, 2] = gammk * cpz - gamm1 * cqw
+    ca[1, 3] = -wz
+    ca[1, 4] = ca[0, 3]
+    
+    ca[3, 0] = (gm1sq * cpy - gmgmk * cqx) * rho
+    ca[3, 1] = -xy
+    ca[3, 2] = gamm1 * cpy - gammk * cqx
+    ca[3, 3] = ca[1, 1]
+    ca[3, 4] = ca[0, 1]
+    
+    ca[4, 0] = -(two * gmgmk * gm1sq * a0pq + gmgmk * gmgmk * xz + gm1sq * gm1sq * wy) * rho2
+    ca[4, 1] = ca[3, 0]
+    ca[4, 2] = -(gammk * gamm1 * twgm1 * a0pq + gam * gammk * gammk * xz + gamm1 * gm1sq * wy) * rho
+    ca[4, 3] = ca[1, 0]
+    ca[4, 4] = ca[0, 0]
+    
+    t = -two * wvno2
+    ca[2, 0] = t * ca[4, 2]
+    ca[2, 1] = t * ca[3, 2]
+    ca[2, 2] = a0 + two * (cpcq - ca[0, 0])
+    ca[2, 3] = t * ca[1, 2]
+    ca[2, 4] = t * ca[0, 2]
+    
+    return ca
+# end def dnka

surfdisp2k25/getsol.py

@@ -0,0 +1,205 @@
+"""
+Python implementation of the getsol subroutine from surfdisp96.
+
+This module provides a Python implementation of the getsol subroutine
+from the surfdisp96 Fortran code, which is responsible for bracketing
+dispersion curves and then refining them.
+"""
+import math
+from types import SimpleNamespace
+
+import numpy as np
+from typing import Tuple, List, Union
+
+try:
+    import migrate.extensions.surfdisp2k25 as sd2k25  # type: ignore
+except ModuleNotFoundError:  # pragma: no cover - fallback for pure Python envs
+    from .dltar import dltar as _dltar
+    from .nevill import nevill as _nevill
+
+    sd2k25 = SimpleNamespace(
+        dltar=_dltar,
+        nevill=_nevill,
+    )
+
+
+_del1st = 0.0
+
+
+def getsol(
+        t1: float,
+        c1: float,
+        clow: float,
+        dc: float,
+        cm: float,
+        betmx: float,
+        ifunc: int,
+        ifirst: int,
+        d: np.ndarray,
+        a: np.ndarray,
+        b: np.ndarray,
+        rho: np.ndarray,
+        rtp: np.ndarray,
+        dtp: np.ndarray,
+        btp: np.ndarray,
+        mmax: int,
+        llw: int
+) -> Tuple[float, int]:
+    """
+    Bracket dispersion curve and then refine it.
+    
+    This is a pure Python implementation of the getsol_ Fortran subroutine.
+    
+    Parameters
+    ----------
+    t1 : float
+        Period in seconds.
+    c1 : float
+        Initial phase velocity estimate in km/s.
+    clow : float
+        Lower bound for phase velocity in km/s.
+    dc : float
+        Phase velocity increment for search in km/s.
+    cm : float
+        Minimum phase velocity to consider in km/s.
+    betmx : float
+        Maximum phase velocity to consider in km/s.
+    ifunc : int
+        Wave type: 1 for Love waves, 2 for Rayleigh waves.
+    ifirst : int
+        First call flag: 1 for first call, 0 otherwise.
+    d : array_like
+        Layer thicknesses in km.
+    a : array_like
+        P-wave velocities in km/s.
+    b : array_like
+        S-wave velocities in km/s.
+    rho : array_like
+        Densities in g/cm^3.
+    
+    Returns
+    -------
+    tuple
+        A tuple containing:
+        - c1: float, the refined phase velocity in km/s.
+        - iret: int, return code (1 for success, -1 for failure).
+    """
+    global _del1st
+
+    # Check if ifunc is valid
+    if ifunc not in [1, 2]:
+        raise ValueError("ifunc must be 1 (Love waves) or 2 (Rayleigh waves)")
+    # end if
+    # Initialize twopi
+    twopi = 2.0 * np.pi
+
+    # Bracket solution
+    omega = twopi / t1
+    wvno = omega / c1
+    
+    # Bracket solution
+    del1 = sd2k25.dltar(
+        wvno=wvno,
+        omega=omega,
+        kk=ifunc,
+        d=d,
+        a=a,
+        b=b,
+        rho=rho,
+        rtp=rtp,
+        dtp=dtp,
+        btp=btp,
+        mmax=mmax,
+        llw=llw,
+        twopi=twopi
+    )
+
+    if ifirst == 1:
+        _del1st = del1
+    # end if
+
+    plmn = math.copysign(1.0, _del1st) * np.sign(del1)
+    
+    if ifirst == 1:
+        idir = 1
+    elif ifirst != 1 and plmn >= 0.0:
+        idir = 1
+    elif ifirst != 1 and plmn < 0.0:
+        idir = -1
+    else:
+        raise ValueError("ifirst must be 1 or 0.")
+    # end if ifirst
+    
+    # idir indicates the direction of the search for the true phase velocity from the initial estimate.
+    # Usually phase velocity increases with period and we always underestimate, so phase velocity should increase
+    # (idir = +1). For reversed dispersion, we should look downward from the present estimate. 
+    # However, we never go below the floor of clow, when the direction is reversed
+    while True:
+        if idir > 0:
+            c2 = c1 + dc
+        else:
+            c2 = c1 - dc
+        # end if
+        
+        if c2 <= clow:
+            idir = 1
+            c1 = clow
+            continue
+        # end if
+        
+        omega = twopi / t1
+        wvno = omega / c2
+        del2 = sd2k25.dltar(
+            wvno=wvno,
+            omega=omega,
+            kk=ifunc,
+            d=d,
+            a=a,
+            b=b,
+            rho=rho,
+            rtp=rtp,
+            dtp=dtp,
+            btp=btp,
+            mmax=mmax,
+            llw=llw,
+            twopi=twopi
+        )
+        # Changed sign
+        if math.copysign(1.0, del1) != math.copysign(1.0, del2):
+            # Root bracketed, refine it
+            cn = sd2k25.nevill(
+                t=t1,
+                c1=c1,
+                c2=c2,
+                del1=del1,
+                del2=del2,
+                ifunc=ifunc,
+                d=d,
+                a=a,
+                b=b,
+                rho=rho,
+                rtp=rtp,
+                dtp=dtp,
+                btp=btp,
+                mmax=mmax,
+                llw=llw,
+                twopi=twopi
+            )
+            c1 = cn
+
+            # Clamp the refined phase velocity to betmx when it exceeds betmx
+            if c1 > betmx:
+                return c1, -1
+            # end if
+            return c1, 1
+        # end if np.sign
+        
+        c1 = c2
+        del1 = del2
+        
+        # Check that c1 is in a region of solutions
+        if c1 < cm or c1 >= (betmx + dc):
+            return c1, -1
+        # end if c1
+    # end while
+# end def getsol

surfdisp2k25/getsolh.py

@@ -0,0 +1,75 @@
+"""
+Python implementation of the getsolh subroutine from surfdisp96.
+
+This module provides a Python implementation of the gtsolh subroutine
+from the surfdisp96 Fortran code, which is responsible for calculating
+a starting solution for phase velocity calculation.
+"""
+
+
+import numpy as np
+from typing import Union
+
+
+def getsolh(
+        a: float,
+        b: float
+) -> float:
+    """
+    Calculate a starting solution for phase velocity.
+    
+    This is a pure Python implementation of the gtsolh_ Fortran subroutine.
+    
+    Parameters
+    ----------
+    a : float
+        P-wave velocity in km/s.
+    b : float
+        S-wave velocity in km/s.
+    
+    Returns
+    -------
+    float
+        The starting solution for phase velocity in km/s.
+    
+    Raises
+    ------
+    TypeError
+        If a or b is not a number.
+    ValueError
+        If a or b is not positive, or if b is greater than or equal to a.
+    """
+    # Check for valid velocity values
+    if a <= 0:
+        raise ValueError("P-wave velocity (a) must be positive")
+    # end if
+
+    if b <= 0:
+        raise ValueError("S-wave velocity (b) must be positive")
+    # end if
+
+    if b > a:  # Changed from b >= a to b > a to allow the case where a = b
+        raise ValueError("S-wave velocity (b) must be less than or equal to P-wave velocity (a)")
+    # end if
+    
+    # Starting solution
+    c = 0.95 * b
+    
+    # Iterate to refine the solution
+    for i in range(5):
+        gamma = b / a
+        kappa = c / b
+        k2 = kappa**2
+        gk2 = (gamma * kappa)**2
+        fac1 = np.sqrt(1.0 - gk2)
+        fac2 = np.sqrt(1.0 - k2)
+        fr = (2.0 - k2)**2 - 4.0 * fac1 * fac2
+        frp = -4.0 * (2.0 - k2) * kappa + \
+              4.0 * fac2 * gamma * gamma * kappa / fac1 + \
+              4.0 * fac1 * kappa / fac2
+        frp = frp / b
+        c = c - fr / frp
+    # end if
+    
+    return c
+# end def getsolh

surfdisp2k25/half.py

@@ -0,0 +1,84 @@
+"""
+Interval halving method for refining root.
+
+This module contains the half function, which is a pure Python implementation
+of the half_ Fortran subroutine.
+"""
+
+import numpy as np
+from typing import List, Union, Tuple
+from .dltar import dltar
+
+def half(
+        c1: float,
+        c2: float,
+        omega: float,
+        ifunc: int,
+        d: np.ndarray,
+        a: np.ndarray,
+        b: np.ndarray,
+        rho: np.ndarray,
+        rtp: np.ndarray,
+        dtp: np.ndarray,
+        btp: np.ndarray,
+        mmax: int,
+        llw: int,
+        twopi: float
+) -> Tuple[float, float]:
+    """
+    Interval halving method for refining root.
+    
+    This is a pure Python implementation of the half_ Fortran subroutine.
+    
+    Parameters
+    ----------
+    c1 : float
+        Lower bound of the interval.
+    c2 : float
+        Upper bound of the interval.
+    omega : float
+        Angular frequency in rad/s.
+    ifunc : int
+        Wave type: 1 for Love waves, 2 for Rayleigh waves.
+    d : array_like
+        Layer thicknesses in km.
+    a : array_like
+        P-wave velocities in km/s.
+    b : array_like
+        S-wave velocities in km/s.
+    rho : array_like
+        Densities in g/cm^3.
+    
+    Returns
+    -------
+    tuple
+        A tuple containing:
+        - c3: float, the midpoint of the interval (c1 + c2) / 2.
+        - del3: float, the value of the period equation at c3.
+    """
+    # Check if ifunc is valid
+    if ifunc not in [1, 2]:
+        raise ValueError("ifunc must be 1 (Love waves) or 2 (Rayleigh waves)")
+    # end if
+
+    # Interval halving method
+    c3 = 0.5 * (c1 + c2)
+    wvno = omega / c3
+    del3 = dltar(
+        wvno=wvno,
+        omega=omega,
+        kk=ifunc,
+        d=d,
+        a=a,
+        b=b,
+        rho=rho,
+        rtp=rtp,
+        dtp=dtp,
+        btp=btp,
+        mmax=mmax,
+        llw=llw,
+        twopi=twopi,
+    )
+    
+    return c3, del3
+# end def half

surfdisp2k25/nevill.py

@@ -0,0 +1,248 @@
+"""
+Hybrid method for refining root once it has been bracketed.
+
+This module contains the nevill function, which is a pure Python implementation
+of the nevill_ Fortran subroutine.
+"""
+
+
+# Imports
+import numpy as np
+from typing import List, Union, Tuple
+from .half import half
+from .dltar import dltar
+
+
+def nevill(
+        t: float,
+        c1: float,
+        c2: float,
+        del1: float,
+        del2: float,
+        ifunc: int,
+        d: np.ndarray,
+        a: np.ndarray,
+        b: np.ndarray,
+        rho: np.ndarray,
+        rtp: np.ndarray,
+        dtp: np.ndarray,
+        btp: np.ndarray,
+        mmax: int,
+        llw: int,
+        twopi: float
+) -> float:
+    """
+    Hybrid method for refining root once it has been bracketed.
+    
+    This is a pure Python implementation of the nevill_ Fortran subroutine.
+    
+    Parameters
+    ----------
+    t : float
+        Period in seconds.
+    c1 : float
+        Lower bound of the interval.
+    c2 : float
+        Upper bound of the interval.
+    del1 : float
+        Value of the period equation at c1.
+    del2 : float
+        Value of the period equation at c2.
+    ifunc : int
+        Wave type: 1 for Love waves, 2 for Rayleigh waves.
+    d : array_like
+        Layer thicknesses in km.
+    a : array_like
+        P-wave velocities in km/s.
+    b : array_like
+        S-wave velocities in km/s.
+    rho : array_like
+        Densities in g/cm^3.
+    
+    Returns
+    -------
+    float
+        The refined phase velocity.
+    """
+    # Check if ifunc is valid
+    if ifunc not in [1, 2]:
+        raise ValueError("ifunc must be 1 (Love waves) or 2 (Rayleigh waves)")
+    # end if
+    
+    # Calculate angular frequency
+    omega = 2.0 * np.pi / t
+    
+    # Initial guess using interval halving
+    c3, del3 = half(
+        c1,
+        c2,
+        omega,
+        ifunc,
+        d,
+        a,
+        b,
+        rho,
+        rtp=rtp,
+        dtp=dtp,
+        btp=btp,
+        mmax=mmax,
+        llw=llw,
+        twopi=twopi,
+    )
+    nev = 1
+    nctrl = 1
+    
+    # Arrays for Neville iteration
+    x = np.zeros(20)
+    y = np.zeros(20)
+    
+    # Main loop
+    while True:
+        nctrl += 1
+        if nctrl >= 100:
+            break
+        # end if
+        
+        # Make sure new estimate is inside the previous values
+        # If not, perform interval halving
+        if c3 < min(c1, c2) or c3 > max(c1, c2):
+            nev = 0
+            c3, del3 = half(
+                c1=c1,
+                c2=c2,
+                omega=omega,
+                ifunc=ifunc,
+                d=d,
+                a=a,
+                b=b,
+                rho=rho,
+                rtp=rtp,
+                dtp=dtp,
+                btp=btp,
+                mmax=mmax,
+                llw=llw,
+                twopi=twopi,
+            )
+        # end if
+        
+        s13 = del1 - del3
+        s32 = del3 - del2
+        
+        # Define new bounds according to the sign of the period equation
+        if np.sign(del3) * np.sign(del1) < 0.0:
+            c2 = c3
+            del2 = del3
+        else:
+            c1 = c3
+            del1 = del3
+        # end if
+        
+        # Check for convergence using relative error criteria
+        if abs(c1 - c2) <= 1e-6 * c1:
+            break
+        # end if
+        
+        # If the slopes are not the same between c1, c3 and c3, c2
+        # do not use Neville iteration
+        if np.sign(s13) != np.sign(s32):
+            nev = 0
+        # end if
+        
+        # If the period equation differs by more than a factor of 10
+        # use interval halving to avoid poor behavior of polynomial fit
+        ss1 = abs(del1)
+        s1 = 0.01 * ss1
+        ss2 = abs(del2)
+        s2 = 0.01 * ss2
+        
+        if s1 > ss2 or s2 > ss1 or nev == 0:
+            c3, del3 = half(
+                c1=c1,
+                c2=c2,
+                omega=omega,
+                ifunc=ifunc,
+                d=d,
+                a=a,
+                b=b,
+                rho=rho,
+                rtp=rtp,
+                dtp=dtp,
+                btp=btp,
+                mmax=mmax,
+                llw=llw,
+                twopi=twopi,
+            )
+            nev = 1
+            m = 1
+        else:
+            if nev == 2:
+                x[m] = c3
+                y[m] = del3
+            else:
+                x[0] = c1
+                y[0] = del1
+                x[1] = c2
+                y[1] = del2
+                m = 1
+            # end if
+            
+            # Perform Neville iteration
+            try:
+                for kk in range(1, m + 1):
+                    j = m - kk
+                    denom = y[m] - y[j]
+                    if abs(denom) < 1.0e-10 * abs(y[m]):
+                        raise ValueError("Denominator too small in Neville iteration")
+                    # end if
+                    x[j] = (-y[j] * x[j+1] + y[m] * x[j]) / denom
+                # end for
+            except ValueError:
+                # If there's an error in Neville iteration, fall back to interval halving
+                c3, del3 = half(
+                    c1=c1,
+                    c2=c2,
+                    omega=omega,
+                    ifunc=ifunc,
+                    d=d,
+                    a=a,
+                    b=b,
+                    rho=rho,
+                    rtp=rtp,
+                    dtp=dtp,
+                    btp=btp,
+                    mmax=mmax,
+                    llw=llw,
+                    twopi=twopi,
+                )
+                nev = 1
+                m = 1
+            else:
+                c3 = x[0]
+                wvno = omega / c3
+                del3 = dltar(
+                    wvno=wvno,
+                    omega=omega,
+                    kk=ifunc,
+                    d=d,
+                    a=a,
+                    b=b,
+                    rho=rho,
+                    rtp=rtp,
+                    dtp=dtp,
+                    btp=btp,
+                    mmax=mmax,
+                    llw=llw,
+                    twopi=twopi,
+                )
+                nev = 2
+                m += 1
+                if m > 10:
+                    m = 10
+                # end if
+            # end try
+        # end if s1, s2
+    # end while True
+    
+    # Return the refined phase velocity
+    return c3
+# end def nevill

surfdisp2k25/normc.py

@@ -0,0 +1,70 @@
+"""
+Normalize vectors to control over/underflow.
+
+This module contains the normc function, which is a pure Python implementation
+of the normc_ Fortran subroutine.
+"""
+
+import numpy as np
+from typing import List, Union, Tuple
+
+
+def normc(
+        ee: np.ndarray
+) -> Tuple[np.ndarray, float]:
+    """
+    Normalize vectors to control over/underflow.
+    
+    This is a pure Python implementation of the normc_ Fortran subroutine.
+    
+    Parameters
+    ----------
+    ee : array_like
+        Input array of length 5 to be normalized.
+    
+    Returns
+    -------
+    tuple
+        A tuple containing:
+        - ee_norm: array_like, the normalized array
+        - ex: float, the natural logarithm of the normalization factor
+    """
+    # Make sure ee is a numpy array of the right type and shape
+    ee = np.asarray(ee, dtype=np.float64)
+    if ee.shape != (5,):
+        raise ValueError(f"Expected ee to be an array of shape (5,), got {ee.shape}")
+    # end if
+    
+    # Create a copy of the input array to avoid modifying the original
+    ee_copy = ee.copy()
+    
+    # Initialize the normalization factor
+    ex = 0.0
+    
+    # Find the maximum absolute value in the vector
+    t1 = 0.0
+    for i in range(5):
+        if abs(ee_copy[i]) > t1:
+            t1 = abs(ee_copy[i])
+        # end if
+    # end for
+    
+    # If the maximum is very small, set it to 1.0 to avoid division by zero
+    if t1 < 1.0e-40:
+        t1 = 1.0
+    # end if
+    
+    # Normalize the vector by the maximum value
+    for i in range(5):
+        t2 = ee_copy[i]
+        t2 = t2 / t1
+        ee_copy[i] = t2
+    # end for
+    
+    # Store the normalization factor in exponential form
+    ex = np.log(t1)
+    
+    # Return the normalized array and the normalization factor
+    return ee_copy, ex
+# end normc
+

surfdisp2k25/sphere.py

@@ -0,0 +1,147 @@
+"""
+Transform spherical earth to flat earth.
+
+This module contains the sphere function, which is a pure Python implementation
+of the sphere_ Fortran subroutine.
+"""
+import math
+
+import numpy as np
+from typing import Tuple, List, Union, Optional
+
+# Global variable to store dhalf between calls
+_dhalf = 0.0
+
+def sphere(
+        ifunc: int,
+        iflag: int,
+        d: np.ndarray,
+        a: np.ndarray,
+        b: np.ndarray,
+        rho: np.ndarray,
+        rtp: np.ndarray,
+        dtp: np.ndarray,
+        btp: np.ndarray,
+        mmax: int,
+        llw: int,
+        twopi: float
+) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
+    """
+    Transform spherical earth to flat earth
+
+    Schwab, F. A., and L. Knopoff (1972). Fast surface wave and free
+    mode computations, in Methods in Computational Physics, Volume 11,
+    Seismology: Surface Waves and Earth Oscillations, B. A. Bolt (ed),
+    Academic Press, New York
+
+    Love Wave Equations 44, 45, 41 pp 112-113
+    Rayleigh Wave Equations 102, 108, 109 pp 142, 144
+
+    Revised 28 DEC 2007 to use mid-point, assume linear variation in
+    slowness instead of using average velocity for the layer
+    Use the Biswas (1972:PAGEOPH 96, 61-74, 1972) density mapping
+    
+    This is a pure Python implementation of the sphere_ Fortran subroutine.
+    
+    Parameters
+    ----------
+    ifunc : int
+        Function type: 1 for Love waves, 2 for Rayleigh waves.
+    iflag : int
+        Flag: 0 for initialization, 1 for subsequent calls.
+    d : array_like
+        Layer thicknesses in km.
+    a : array_like
+        P-wave velocities in km/s.
+    b : array_like
+        S-wave velocities in km/s.
+    rho : array_like
+        Densities in g/cm^3.
+    rtp : array_like, optional
+        Original densities from forward transformation, used for backward transformation.
+    dtp : array_like, optional
+        Original thicknesses from forward transformation, used for backward transformation.
+    btp : array_like, optional
+        Transformation factors from forward transformation, used for backward transformation.
+    
+    Returns
+    -------
+    tuple
+        A tuple containing:
+        - d_new: array_like, transformed layer thicknesses
+        - a_new: array_like, transformed P-wave velocities
+        - b_new: array_like, transformed S-wave velocities
+        - rho_new: array_like, transformed densities
+        - rtp: array_like, original densities
+        - dtp: array_like, original thicknesses
+        - btp: array_like, transformation factors
+    """
+    global _dhalf
+    NL = 100
+    NP = 60
+
+    # Check size
+    assert d.ndim == 1 and d.shape[0] == NL, f"d! {d.shape[0]} != {NL}"
+    assert a.ndim == 1 and a.shape[0] == NL, f"a! {a.shape[0]} != {NL}"
+    assert b.ndim == 1 and b.shape[0] == NL, f"b! {b.shape[0]} != {NL}"
+    assert rho.ndim == 1 and rho.shape[0] == NL, f"rho! {rho.shape[0]} != {NL}"
+    assert rtp.ndim == 1 and rtp.shape[0] == NL, f"rtp! {rtp.shape[0]} != {NL}"
+    assert dtp.ndim == 1 and dtp.shape[0] == NL, f"dtp! {dtp.shape[0]} != {NL}"
+    assert btp.ndim == 1 and btp.shape[0] == NL, f"b! {btp.shape[0]} != {NL}"
+
+    ar = 6370.0
+    dr = 0.0
+    r0 = ar
+    d[mmax] = 1.0
+    
+    # Check array lengths
+    if len(a) != mmax or len(b) != mmax or len(rho) != mmax:
+        raise ValueError("d, a, b, and rho must have the same length")
+    
+    # Check if ifunc and iflag are valid
+    if ifunc not in [1, 2]:
+        raise ValueError("ifunc must be 1, or 2")
+    # end if
+
+    if iflag not in [0, 1]:
+        raise ValueError("iflag must be 0 or 1")
+    # end if
+    
+    # Forward transformation (spherical to flat)
+    if iflag == 0:
+        # Save original values
+        for i in range(mmax):
+            rtp[i] = rho[i]
+            dtp[i] = d[i]
+        # end for
+        
+        # Compute transformation factors
+        for i in range(mmax):
+            dr += d[i]
+            r1 = ar - dr
+            z0 = ar * math.log(ar / r0)
+            z1 = ar * math.log(ar / r1)
+            d[i] = z1 - z0
+        # end for
+        
+        # Save the half-space depth
+        _dhalf = d[mmax]
+    # Backward transformation (flat to spherical)
+    else:  # iflag == 1
+        d[mmax] = _dhalf
+        # Restore original values
+        for i in range(mmax):
+            if ifunc == 1:
+                rho[i] = rtp[i] * btp[i]**(-5)
+            elif ifunc == 2:
+                rho[i] = rtp[i] * btp[i]**(-2.275)
+            else:
+                raise ValueError("ifunc must be 1 or 2")
+            # end if
+        # end for
+    # end if
+
+    d[mmax] = 0.0
+    # Return the transformed arrays and the original values
+    return d, a, b, rho, rtp, dtp, btp
+# end def sphere

surfdisp2k25/var.py

@@ -0,0 +1,133 @@
+"""
+Evaluate variables for the compound matrix.
+
+This module contains the var function, which is a pure Python implementation
+of the var_ Fortran subroutine.
+"""
+
+import numpy as np
+
+def var(
+        p: float,
+        q: float,
+        ra: float,
+        rb: float,
+        wvno: float,
+        xka: float,
+        xkb: float,
+        dpth: float
+):
+    """
+    Evaluate variables for the compound matrix.
+    
+    This is a pure Python implementation of the var_ Fortran subroutine.
+    
+    Parameters
+    ----------
+    p : float
+        P-wave vertical slowness parameter (ra * depth).
+    q : float
+        S-wave vertical slowness parameter (rb * depth).
+    ra : float
+        P-wave vertical slowness.
+    rb : float
+        S-wave vertical slowness.
+    wvno : float
+        Horizontal wavenumber in rad/km.
+    xka : float
+        P-wave wavenumber (omega/alpha).
+    xkb : float
+        S-wave wavenumber (omega/beta).
+    dpth : float
+        Layer thickness in km.
+    
+    Returns
+    -------
+    tuple
+        A tuple containing the following variables:
+        (w, cosp, exa, a0, cpcq, cpy, cpz, cqw, cqx, xy, xz, wy, wz)
+    """
+    # Initialize variables
+    exa = 0.0
+    a0 = 1.0
+    
+    # Examine P-wave eigenfunctions
+    # checking whether c > vp, c = vp or c < vp
+    pex = 0.0
+    sex = 0.0
+    
+    if wvno < xka:
+        sinp = np.sin(p)
+        w = sinp / ra
+        x = -ra * sinp
+        cosp = np.cos(p)
+    elif wvno == xka:
+        cosp = 1.0
+        w = dpth
+        x = 0.0
+    elif wvno > xka:
+        pex = p
+        fac = 0.0
+        if p < 16:
+            fac = np.exp(-2.0 * p)
+        # end if
+        cosp = (1.0 + fac) * 0.5
+        sinp = (1.0 - fac) * 0.5
+        w = sinp / ra
+        x = ra * sinp
+    # end if
+    
+    # Examine S-wave eigenfunctions
+    # checking whether c > vs, c = vs, c < vs
+    if wvno < xkb:
+        sinq = np.sin(q)
+        y = sinq / rb
+        z = -rb * sinq
+        cosq = np.cos(q)
+    elif wvno == xkb:
+        cosq = 1.0
+        y = dpth
+        z = 0.0
+    elif wvno > xkb:
+        sex = q
+        fac = 0.0
+        if q < 16:
+            fac = np.exp(-2.0 * q)
+        # end if
+        cosq = (1.0 + fac) * 0.5
+        sinq = (1.0 - fac) * 0.5
+        y = sinq / rb
+        z = rb * sinq
+    # end if
+    
+    # Form eigenfunction products for use with compound matrices
+    exa = pex + sex
+    a0 = 0.0
+
+    if exa < 60.0:
+        a0 = np.exp(-exa)
+    # end if
+
+    cpcq = cosp * cosq
+    cpy = cosp * y
+    cpz = cosp * z
+    cqw = cosq * w
+    cqx = cosq * x
+    xy = x * y
+    xz = x * z
+    wy = w * y
+    wz = w * z
+    qmp = sex - pex
+    fac = 0.0
+
+    if qmp > -40.0:
+        fac = np.exp(qmp)
+    # end if
+
+    cosq = cosq * fac
+    y = fac * y
+    z = fac * z
+    
+    # Return all computed values as a tuple
+    return w, cosp, exa, a0, cpcq, cpy, cpz, cqw, cqx, xy, xz, wy, wz
+# end def var