seiscode-models 0.1.0__tar.gz

seiscode_models-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Damien Pageot
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

seiscode_models-0.1.0/PKG-INFO

@@ -0,0 +1,31 @@
+Metadata-Version: 2.4
+Name: seiscode-models
+Version: 0.1.0
+Summary: Synthetic subsurface velocity model generators for seismic testing
+Author-email: Damien Pageot <damien.pageot@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/PageotD/seiscode-models
+Project-URL: Repository, https://github.com/PageotD/seiscode-models
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.21.0
+Requires-Dist: matplotlib>=3.5.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Dynamic: license-file
+
+# SeisCode Models

seiscode_models-0.1.0/README.md

@@ -0,0 +1 @@
+# SeisCode Models

seiscode_models-0.1.0/pyproject.toml

@@ -0,0 +1,45 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "seiscode-models"
+version = "0.1.0"
+description = "Synthetic subsurface velocity model generators for seismic testing"
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.8"
+authors = [
+    {name = "Damien Pageot", email = "damien.pageot@gmail.com"},
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Topic :: Scientific/Engineering :: Physics",
+]
+dependencies = [
+    "numpy>=1.21.0",
+    "matplotlib>=3.5.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+    "pytest-cov",
+    "ruff",
+    "build",
+    "twine",
+#    "sphinx",
+#    "sphinx-rtd-theme",
+]
+
+
+[project.urls]
+Homepage = "https://github.com/PageotD/seiscode-models"
+Repository = "https://github.com/PageotD/seiscode-models"

seiscode_models-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

seiscode_models-0.1.0/src/seiscode_models/__init__.py

@@ -0,0 +1,42 @@
+"""SeisCode Models: Synthetic subsurface velocity model generators."""
+from .models.primitives import (
+    gradient_background,
+    add_gaussian_anomaly,
+    add_fault_offset,
+)
+from .models.geological import (
+    dipping_layers,
+    sinusoidal_interface,
+    faulted_layers,
+    checkerboard,
+    salt_dome,
+    low_velocity_layer,
+    heterogeneous_anomaly_model
+)
+from .utils.dtypes import parse_dtype
+from .utils.validation import validate_model
+from .utils.io import (
+    export_model,
+    load_model
+)
+from .utils.visualization import quick_view
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "gradient_background",
+    "add_gaussian_anomaly",
+    "add_fault_offset",
+    "parse_dtype",
+    "validate_model",
+    "dipping_layers",
+    "sinusoidal_interface",
+    "faulted_layers",
+    "checkerboard",
+    "salt_dome",
+    "low_velocity_layer",
+    "heterogeneous_anomaly_model",
+    "export_model",
+    "load_model",
+    "quick_view"
+]

seiscode_models-0.1.0/src/seiscode_models/models/__init__.py

@@ -0,0 +1,82 @@
+"""Primitive building blocks for subsurface velocity models with dtype support."""
+import numpy as np
+from ..utils.dtypes import parse_dtype
+
+def gradient_background(nx: int, nz: int, v0: float = 1500.0, v1: float = 4500.0, dtype=np.float32) -> np.ndarray:
+    """Generate a linear velocity gradient with depth.
+
+    Parameters
+    ----------
+    nx : int
+        Number of cells along x (horizontal direction).
+    nz : int
+        Number of cells along z (vertical direction, positive downward).
+    v0 : float, optional
+        Velocity at the surface, in m/s. Default is 1500.0.
+    v1 : float, optional
+        Velocity at the bottom of the model, in m/s. Default is 4500.0.
+    dtype : str or np.dtype, optional
+        Data type precision ('f32', 'f64', etc.). Default is np.float32.
+
+    Returns
+    -------
+    ndarray (nx, nz)
+        Velocity field in m/s with the requested dtype.
+    """
+    dt = parse_dtype(dtype)
+    z = np.linspace(0.0, 1.0, nz, dtype=dt)
+    v_col = v0 + (v1 - v0) * z
+    return np.broadcast_to(v_col, (nx, nz)).copy()
+
+def add_gaussian_anomaly(v: np.ndarray, cx: float, cz: float, sigma_x: float, sigma_z: float, dv: float, vmin: float = 200.0, vmax: float = 8000.0) -> np.ndarray:
+    """Add a Gaussian velocity anomaly to an existing model.
+
+    Parameters
+    ----------
+    v : ndarray (nx, nz)
+        Velocity field to modify (not modified in place).
+    cx, cz : float
+        Center position along x and z, in cells.
+    sigma_x, sigma_z : float
+        Gaussian standard deviation along x and z, in cells.
+    dv : float
+        Amplitude of the anomaly at the center, in m/s.
+    vmin, vmax : float, optional
+        Clipping velocity bounds, in m/s.
+
+    Returns
+    -------
+    ndarray (nx, nz)
+        Copy of v with the anomaly added, preserving dtype and clipped.
+    """
+    nx, nz = v.shape
+    dt = v.dtype
+    ii = np.arange(nx, dtype=dt)[:, None]
+    jj = np.arange(nz, dtype=dt)[None, :]
+    g = dv * np.exp(-((ii - cx) ** 2 / (2 * sigma_x ** 2) + (jj - cz) ** 2 / (2 * sigma_z ** 2)))
+    return np.clip(v + g, vmin, vmax).astype(dt)
+
+def add_fault_offset(v: np.ndarray, ix_fault: int, throw: int) -> np.ndarray:
+    """Shift layers on either side of a vertical fault.
+
+    Parameters
+    ----------
+    v : ndarray (nx, nz)
+        Stratified velocity field to shift.
+    ix_fault : int
+        Column index of the fault.
+    throw : int
+        Fault throw in cells along z.
+
+    Returns
+    -------
+    ndarray (nx, nz)
+        Shifted field preserving original dtype.
+    """
+    out = v.copy()
+    left, right = slice(None, ix_fault), slice(ix_fault, None)
+    if throw >= 0:
+        out[left, throw:] = v[left, :out.shape[1] - throw]
+    else:
+        out[right, :throw] = v[right, -throw:]
+    return out

seiscode_models-0.1.0/src/seiscode_models/models/geological.py

@@ -0,0 +1,92 @@
+"""Geological velocity models supporting f32/f64 precision."""
+import numpy as np
+from .primitives import gradient_background, add_gaussian_anomaly, add_fault_offset
+from ..utils.dtypes import parse_dtype
+
+def dipping_layers(nx: int = 201, nz: int = 51, dx: float = 1.0, dz: float = 1.0,
+                   v: tuple = (1800.0, 2400.0, 3200.0, 4200.0), dip_deg: float = 8.0, dtype=np.float32) -> np.ndarray:
+    """Generate dipping planar layers with the same dip angle."""
+    dt = parse_dtype(dtype)
+    v_arr = np.asarray(v, dtype=dt)
+    x = np.arange(nx, dtype=dt) * dx
+    dip = np.deg2rad(dip_deg)
+    v_out = np.full((nx, nz), v_arr[-1], dtype=dt)
+    depths = [0.0]
+    for k in range(1, len(v_arr)):
+        depths.append(depths[-1] + 10.0 * k)
+    for k in range(len(v_arr) - 2, -1, -1):
+        z_int = depths[k] + (x - x.mean()) * np.tan(dip)
+        k_int = np.clip((z_int / dz).astype(int), 0, nz - 1)
+        for i in range(nx):
+            v_out[i, :k_int[i]] = v_arr[k]
+    return v_out
+
+def sinusoidal_interface(nx: int = 201, nz: int = 51, period: float = 100.0, amplitude: float = 8.0,
+                         v_top: float = 2000.0, v_bottom: float = 3500.0, dtype=np.float32) -> np.ndarray:
+    """Generate two layers separated by a sinusoidal interface."""
+    dt = parse_dtype(dtype)
+    x = np.arange(nx, dtype=dt)
+    z_int = nz * 0.45 + amplitude * np.sin(2 * np.pi * x / period)
+    k_int = z_int.astype(int)
+    v = np.full((nx, nz), v_bottom, dtype=dt)
+    for i in range(nx):
+        v[i, :k_int[i]] = v_top
+    return v
+
+def faulted_layers(nx: int = 201, nz: int = 51, ix_fault: int = 120, throw: int = 8,
+                   v: tuple = (1800.0, 2400.0, 3200.0, 4200.0), dtype=np.float32) -> np.ndarray:
+    """Generate stratigraphic layers with a normal fault."""
+    dt = parse_dtype(dtype)
+    base = np.zeros((nx, nz), dtype=dt)
+    bounds = [0, 12, 28, 40, nz]
+    vs = np.asarray(v, dtype=dt)
+    for k in range(4):
+        base[:, bounds[k]:bounds[k + 1]] = vs[k]
+    return add_fault_offset(base, ix_fault, throw).astype(dt)
+
+def checkerboard(nx: int = 201, nz: int = 51, cell: int = 20, v0: float = 3000.0,
+                 dv: float = 600.0, dtype=np.float32) -> np.ndarray:
+    """Generate a checkerboard pattern for resolution testing."""
+    dt = parse_dtype(dtype)
+    ii = np.arange(nx, dtype=dt)[:, None]
+    jj = np.arange(nz, dtype=dt)[None, :]
+    pat = ((ii // cell) + (jj // cell)) % 2
+    return np.where(pat == 0, v0 + dv, v0 - dv).astype(dt)
+
+def salt_dome(nx: int = 201, nz: int = 51, cx: int = 140, width: float = 40.0,
+              v_salt: float = 4500.0, v_sed: float = 2500.0, dtype=np.float32) -> np.ndarray:
+    """Generate a salt dome model with semi-elliptical shape."""
+    dt = parse_dtype(dtype)
+    v = gradient_background(nx, nz, v_sed, 4000.0, dtype=dt)
+    ii = np.arange(nx, dtype=dt)[:, None]
+    jj = np.arange(nz, dtype=dt)[None, :]
+    r = ((ii - cx) / width) ** 2 + np.clip((nz * 0.9 - jj) / (nz * 0.9), 0, None) ** 2
+    v[r < 1.0] = v_salt
+    return v
+
+def low_velocity_layer(nx: int = 201, nz: int = 51, k0: int = 20, thickness: int = 8,
+                       v_slow: float = 1200.0, dtype=np.float32) -> np.ndarray:
+    """Generate a model with a buried low-velocity channel."""
+    dt = parse_dtype(dtype)
+    v = gradient_background(nx, nz, 1800.0, 4500.0, dtype=dt)
+    v[:, k0:k0 + thickness] = v_slow
+    return v
+
+def heterogeneous_anomaly_model(nx: int = 384, nz: int = 122, seed: int = 7, dtype=np.float32) -> np.ndarray:
+    """Generate a complex synthetic model."""
+    dt = parse_dtype(dtype)
+    rng = np.random.default_rng(seed)
+    v = gradient_background(nx, nz, 1500.0, 4800.0, dtype=dt)
+    v = add_gaussian_anomaly(v, nx * 0.72, nz * 0.35, 30.0, 12.0, 1200.0)
+    v = add_gaussian_anomaly(v, nx * 0.25, nz * 0.55, 25.0, 10.0, -700.0)
+    v = add_gaussian_anomaly(v, nx * 0.5, nz * 0.75, 40.0, 15.0, 900.0)
+    noise = rng.normal(0.0, 1.0, (nx, nz)).astype(dt)
+    k = 7
+    pad = k // 2
+    padded = np.pad(noise, pad, mode="edge")
+    smooth = np.zeros_like(noise)
+    for di in range(k):
+        for dj in range(k):
+            smooth += padded[di:di + nx, dj:dj + nz]
+    smooth /= (k * k)
+    return np.clip(v * (1.0 + 0.05 * smooth / smooth.std()), 500.0, 6000.0).astype(dt)

seiscode_models-0.1.0/src/seiscode_models/models/primitives.py

@@ -0,0 +1,82 @@
+"""Primitive building blocks for subsurface velocity models with dtype support."""
+import numpy as np
+from ..utils.dtypes import parse_dtype
+
+def gradient_background(nx: int, nz: int, v0: float = 1500.0, v1: float = 4500.0, dtype=np.float32) -> np.ndarray:
+    """Generate a linear velocity gradient with depth.
+
+    Parameters
+    ----------
+    nx : int
+        Number of cells along x (horizontal direction).
+    nz : int
+        Number of cells along z (vertical direction, positive downward).
+    v0 : float, optional
+        Velocity at the surface, in m/s. Default is 1500.0.
+    v1 : float, optional
+        Velocity at the bottom of the model, in m/s. Default is 4500.0.
+    dtype : str or np.dtype, optional
+        Data type precision ('f32', 'f64', etc.). Default is np.float32.
+
+    Returns
+    -------
+    ndarray (nx, nz)
+        Velocity field in m/s with the requested dtype.
+    """
+    dt = parse_dtype(dtype)
+    z = np.linspace(0.0, 1.0, nz, dtype=dt)
+    v_col = v0 + (v1 - v0) * z
+    return np.broadcast_to(v_col, (nx, nz)).copy()
+
+def add_gaussian_anomaly(v: np.ndarray, cx: float, cz: float, sigma_x: float, sigma_z: float, dv: float, vmin: float = 200.0, vmax: float = 8000.0) -> np.ndarray:
+    """Add a Gaussian velocity anomaly to an existing model.
+
+    Parameters
+    ----------
+    v : ndarray (nx, nz)
+        Velocity field to modify (not modified in place).
+    cx, cz : float
+        Center position along x and z, in cells.
+    sigma_x, sigma_z : float
+        Gaussian standard deviation along x and z, in cells.
+    dv : float
+        Amplitude of the anomaly at the center, in m/s.
+    vmin, vmax : float, optional
+        Clipping velocity bounds, in m/s.
+
+    Returns
+    -------
+    ndarray (nx, nz)
+        Copy of v with the anomaly added, preserving dtype and clipped.
+    """
+    nx, nz = v.shape
+    dt = v.dtype
+    ii = np.arange(nx, dtype=dt)[:, None]
+    jj = np.arange(nz, dtype=dt)[None, :]
+    g = dv * np.exp(-((ii - cx) ** 2 / (2 * sigma_x ** 2) + (jj - cz) ** 2 / (2 * sigma_z ** 2)))
+    return np.clip(v + g, vmin, vmax).astype(dt)
+
+def add_fault_offset(v: np.ndarray, ix_fault: int, throw: int) -> np.ndarray:
+    """Shift layers on either side of a vertical fault.
+
+    Parameters
+    ----------
+    v : ndarray (nx, nz)
+        Stratified velocity field to shift.
+    ix_fault : int
+        Column index of the fault.
+    throw : int
+        Fault throw in cells along z.
+
+    Returns
+    -------
+    ndarray (nx, nz)
+        Shifted field preserving original dtype.
+    """
+    out = v.copy()
+    left, right = slice(None, ix_fault), slice(ix_fault, None)
+    if throw >= 0:
+        out[left, throw:] = v[left, :out.shape[1] - throw]
+    else:
+        out[right, :throw] = v[right, -throw:]
+    return out

seiscode_models-0.1.0/src/seiscode_models/utils/dtypes.py

@@ -0,0 +1,45 @@
+"""Precision management utilities for velocity models."""
+from typing import Union
+
+import numpy as np
+
+
+def parse_dtype(dtype: Union[str, np.dtype] = np.float32) -> np.dtype:
+    """Parse and validate the requested floating-point precision dtype.
+
+    Parameters
+    ----------
+    dtype : str or np.dtype, optional
+        Target precision, e.g., 'f32', 'float32', 'f64', 'float64',
+        or np.float32, np.float64. Default is np.float32.
+
+    Returns
+    -------
+    np.dtype
+        Normalized NumPy floating-point dtype.
+
+    Raises
+    ------
+    ValueError
+        If the dtype is not supported or not a floating-point type.
+    """
+    if isinstance(dtype, str):
+        dtype_lower = dtype.lower()
+
+        if dtype_lower in ("f32", "float32"):
+            return np.dtype(np.float32)
+        elif dtype_lower in ("f64", "float64"):
+            return np.dtype(np.float64)
+        else:
+            raise ValueError(
+                f"Unsupported string dtype: '{dtype}'. Use 'f32' or 'f64'."
+            )
+
+    dt = np.dtype(dtype)
+
+    if dt == np.dtype(np.float32) or dt == np.dtype(np.float64):
+        return dt
+
+    raise ValueError(
+        f"Unsupported dtype: {dt}. Only float32 (f32) and float64 (f64) are allowed."
+    )

seiscode_models-0.1.0/src/seiscode_models/utils/io.py

@@ -0,0 +1,68 @@
+"""Input/Output utilities for exporting velocity models to seismic solvers."""
+from pathlib import Path
+import numpy as np
+from typing import Union, Tuple
+from .validation import validate_model
+
+def export_model(
+    v: np.ndarray, 
+    filepath: Union[str, Path], 
+    format: str = "bin", 
+    dx: float = 1.0, 
+    dz: float = 1.0
+) -> None:
+    """Export a velocity model to a file compatible with seismic solvers.
+
+    Parameters
+    ----------
+    v : ndarray (nx, nz)
+        Velocity model array.
+    filepath : str or Path
+        Destination file path.
+    format : str, optional
+        Export format:
+        - 'bin' or 'raw': Flat binary file (C-contiguous or Fortran-contiguous depending on solver needs).
+        - 'npy': Standard NumPy binary format preserving dtype and shape.
+        Default is 'bin'.
+    dx, dz : float, optional
+        Grid spacing (validated before export).
+    """
+    validate_model(v, dx=dx, dz=dz)
+    filepath = Path(filepath)
+    filepath.parent.mkdir(parents=True, exist_ok=True)
+
+    fmt = format.lower()
+    if fmt in ("bin", "raw"):
+        # Enregistrement en binaire brut (souvent attendu en float32/float64 pur par les solveurs C/Fortran)
+        v.tofile(filepath)
+    elif fmt == "npy":
+        np.save(filepath, v)
+    else:
+        raise ValueError(f"Unsupported export format: '{format}'. Use 'bin', 'raw', or 'npy'.")
+
+def load_model(filepath: Union[str, Path], shape: Tuple[int, int], dtype=np.float32) -> np.ndarray:
+    """Load a velocity model from a raw binary file.
+
+    Parameters
+    ----------
+    filepath : str or Path
+        Path to the binary file.
+    shape : tuple of int
+        Expected shape (nx, nz) of the model.
+    dtype : str or np.dtype, optional
+        Data type of the binary file. Default is np.float32.
+
+    Returns
+    -------
+    ndarray (nx, nz)
+        Loaded velocity model.
+    """
+    filepath = Path(filepath)
+    if filepath.suffix == ".npy":
+        return np.load(filepath)
+    
+    v = np.fromfile(filepath, dtype=dtype)
+    expected_size = shape[0] * shape[1]
+    if v.size != expected_size:
+        raise ValueError(f"File size mismatch: expected {expected_size} elements for shape {shape}, got {v.size}.")
+    return v.reshape(shape)

seiscode_models-0.1.0/src/seiscode_models/utils/validation.py

@@ -0,0 +1,32 @@
+"""Model validation utilities."""
+import numpy as np
+
+def validate_model(v: np.ndarray, dx: float = 1.0, dz: float = 1.0, v_min: float = 200.0, v_max: float = 8000.0) -> None:
+    """Validate a velocity model array and its parameters.
+
+    Parameters
+    ----------
+    v : ndarray
+        Velocity model array (nx, nz).
+    dx, dz : float
+        Grid spacing in meters.
+    v_min, v_max : float
+        Acceptable velocity limits in m/s.
+
+    Raises
+    ------
+    ValueError
+        If the model structure, dtype, or bounds are invalid.
+    """
+    if not isinstance(v, np.ndarray):
+        raise ValueError("Model must be a NumPy array.")
+    if v.ndim != 2:
+        raise ValueError(f"Model must be 2D, got {v.ndim}D.")
+    if v.dtype not in (np.dtype(np.float32), np.dtype(np.float64)):
+        raise ValueError(f"Model dtype must be float32 or float64, got {v.dtype}.")
+    if not np.all(np.isfinite(v)):
+        raise ValueError("Model contains non-finite values (NaN or Inf).")
+    if np.any(v < v_min) or np.any(v > v_max):
+        raise ValueError(f"Velocities out of range [{v_min}, {v_max}] m/s.")
+    if dx <= 0 or dz <= 0:
+        raise ValueError("Grid spacing dx and dz must be positive.")

seiscode_models-0.1.0/src/seiscode_models/utils/visualization.py

@@ -0,0 +1,39 @@
+"""Visualization utilities compatible with Python 3.8+."""
+import numpy as np
+from .validation import validate_model
+
+def quick_view(
+    velocities: np.ndarray, 
+    dx: float = 1.0, 
+    dz: float = 1.0, 
+    title: str = "Velocity model"
+) -> None:
+    """Display a velocity field with depth positive downward.
+
+    Parameters
+    ----------
+    velocities : ndarray (nx, nz)
+        Velocity field to display, in m/s.
+    dx : float, optional
+        Grid spacing along x, in meters. Default is 1.0.
+    dz : float, optional
+        Grid spacing along z, in meters. Default is 1.0.
+    title : str, optional
+        Figure title. Default is "Velocity model".
+    """
+    import matplotlib.pyplot as plt
+    validate_model(velocities, dx=dx, dz=dz)
+    
+    nx, nz = velocities.shape
+    fig, ax = plt.subplots(figsize=(12, 6))
+    im = ax.imshow(
+        velocities.T,
+        extent=[0, (nx - 1) * dx, (nz - 1) * dz, 0],
+        aspect="auto",
+        cmap="viridis"
+    )
+    ax.set_xlabel("x (m)")
+    ax.set_ylabel("Depth z (m)")
+    ax.set_title(title)
+    fig.colorbar(im, ax=ax, label="Velocity (m/s)")
+    plt.show()

seiscode_models-0.1.0/src/seiscode_models.egg-info/PKG-INFO

@@ -0,0 +1,31 @@
+Metadata-Version: 2.4
+Name: seiscode-models
+Version: 0.1.0
+Summary: Synthetic subsurface velocity model generators for seismic testing
+Author-email: Damien Pageot <damien.pageot@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/PageotD/seiscode-models
+Project-URL: Repository, https://github.com/PageotD/seiscode-models
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.21.0
+Requires-Dist: matplotlib>=3.5.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Dynamic: license-file
+
+# SeisCode Models

seiscode_models-0.1.0/src/seiscode_models.egg-info/SOURCES.txt

@@ -0,0 +1,22 @@
+LICENSE
+README.md
+pyproject.toml
+src/seiscode_models/__init__.py
+src/seiscode_models.egg-info/PKG-INFO
+src/seiscode_models.egg-info/SOURCES.txt
+src/seiscode_models.egg-info/dependency_links.txt
+src/seiscode_models.egg-info/requires.txt
+src/seiscode_models.egg-info/top_level.txt
+src/seiscode_models/models/__init__.py
+src/seiscode_models/models/geological.py
+src/seiscode_models/models/primitives.py
+src/seiscode_models/utils/__init__.py
+src/seiscode_models/utils/dtypes.py
+src/seiscode_models/utils/io.py
+src/seiscode_models/utils/validation.py
+src/seiscode_models/utils/visualization.py
+tests/test_dtypes.py
+tests/test_geological.py
+tests/test_io.py
+tests/test_primitives.py
+tests/test_visualization.py

seiscode_models-0.1.0/src/seiscode_models.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

seiscode_models-0.1.0/src/seiscode_models.egg-info/requires.txt

@@ -0,0 +1,9 @@
+numpy>=1.21.0
+matplotlib>=3.5.0
+
+[dev]
+pytest>=7.0
+pytest-cov
+ruff
+build
+twine

seiscode_models-0.1.0/src/seiscode_models.egg-info/top_level.txt

@@ -0,0 +1 @@
+seiscode_models

seiscode_models-0.1.0/tests/test_dtypes.py

@@ -0,0 +1,24 @@
+"""Tests for precision dtype utilities."""
+import numpy as np
+import pytest
+from seiscode_models.utils.dtypes import parse_dtype
+
+class TestParseDtype:
+    def test_default_dtype(self):
+        assert parse_dtype() == np.dtype(np.float32)
+
+    def test_string_inputs(self):
+        assert parse_dtype("f32") == np.dtype(np.float32)
+        assert parse_dtype("float32") == np.dtype(np.float32)
+        assert parse_dtype("f64") == np.dtype(np.float64)
+        assert parse_dtype("float64") == np.dtype(np.float64)
+
+    def test_numpy_dtype_inputs(self):
+        assert parse_dtype(np.float32) == np.dtype(np.float32)
+        assert parse_dtype(np.float64) == np.dtype(np.float64)
+
+    def test_invalid_inputs(self):
+        with pytest.raises(ValueError, match="Unsupported string dtype"):
+            parse_dtype("int32")
+        with pytest.raises(ValueError, match="Unsupported dtype"):
+            parse_dtype(np.int32)

seiscode_models-0.1.0/tests/test_geological.py

@@ -0,0 +1,27 @@
+"""Tests for geological models and precision behavior."""
+import numpy as np
+import pytest
+import seiscode_models as sm
+
+class TestGeologicalModels:
+    @pytest.mark.parametrize("model_func", [
+        sm.dipping_layers,
+        sm.sinusoidal_interface,
+        sm.faulted_layers,
+        sm.checkerboard,
+        sm.salt_dome,
+        sm.low_velocity_layer,
+        sm.heterogeneous_anomaly_model,
+    ])
+    def test_model_generation_and_dtype(self, model_func):
+        # Test f32
+        v_f32 = model_func(nx=50, nz=30, dtype="f32")
+        assert v_f32.shape == (50, 30)
+        assert v_f32.dtype == np.float32
+        sm.validate_model(v_f32)
+
+        # Test f64
+        v_f64 = model_func(nx=50, nz=30, dtype="f64")
+        assert v_f64.shape == (50, 30)
+        assert v_f64.dtype == np.float64
+        sm.validate_model(v_f64)

seiscode_models-0.1.0/tests/test_io.py

@@ -0,0 +1,33 @@
+"""Tests for model I/O export and import utilities."""
+import numpy as np
+import pytest
+import seiscode_models as sm
+
+class TestModelIO:
+    def test_export_import_bin(self, tmp_path):
+        v = sm.gradient_background(40, 20, dtype="f32")
+        file_path = tmp_path / "model.bin"
+        
+        sm.export_model(v, file_path, format="bin")
+        assert file_path.exists()
+        
+        v_loaded = sm.load_model(file_path, shape=(40, 20), dtype=np.float32)
+        assert v_loaded.shape == (40, 20)
+        assert v_loaded.dtype == np.float32
+        assert np.allclose(v, v_loaded)
+
+    def test_export_import_npy(self, tmp_path):
+        v = sm.salt_dome(30, 30, dtype="f64")
+        file_path = tmp_path / "model.npy"
+        
+        sm.export_model(v, file_path, format="npy")
+        assert file_path.exists()
+        
+        v_loaded = sm.load_model(file_path, shape=(30, 30))
+        assert v_loaded.dtype == np.float64
+        assert np.allclose(v, v_loaded)
+
+    def test_invalid_format(self, tmp_path):
+        v = sm.gradient_background(10, 10)
+        with pytest.raises(ValueError, match="Unsupported export format"):
+            sm.export_model(v, tmp_path / "model.xyz", format="xyz")

seiscode_models-0.1.0/tests/test_primitives.py

@@ -0,0 +1,35 @@
+"""Tests for primitive functions and dtype preservation."""
+import numpy as np
+import pytest
+import seiscode_models as sm
+
+class TestGradientBackground:
+    def test_shape_and_dtype(self):
+        v_f32 = sm.gradient_background(50, 30, dtype="f32")
+        assert v_f32.shape == (50, 30)
+        assert v_f32.dtype == np.float32
+
+        v_f64 = sm.gradient_background(50, 30, dtype="f64")
+        assert v_f64.dtype == np.float64
+
+    def test_gradient_values(self):
+        v = sm.gradient_background(10, 10, v0=1000.0, v1=3000.0)
+        assert np.allclose(v[:, 0], 1000.0)
+        assert np.allclose(v[:, -1], 3000.0)
+
+class TestAddGaussianAnomaly:
+    def test_dtype_preserved(self):
+        v = sm.gradient_background(40, 40, dtype=np.float64)
+        v_out = sm.add_gaussian_anomaly(v, 20, 20, 5.0, 5.0, 500.0)
+        assert v_out.dtype == np.float64
+        assert v_out.shape == (40, 40)
+
+class TestValidation:
+    def test_valid_model(self):
+        v = sm.gradient_background(20, 20, dtype="f32")
+        sm.validate_model(v) # Ne doit pas lever d'exception
+
+    def test_invalid_dtype(self):
+        v = sm.gradient_background(20, 20).astype(np.int32)
+        with pytest.raises(ValueError, match="Model dtype must be float32 or float64"):
+            sm.validate_model(v)

seiscode_models-0.1.0/tests/test_visualization.py

@@ -0,0 +1,18 @@
+"""Tests for visualization utilities."""
+from unittest.mock import patch
+import numpy as np
+import pytest
+import seiscode_models as sm
+
+class TestQuickView:
+    @patch("matplotlib.pyplot.show")
+    def test_quick_view_execution(self, mock_show):
+        v = sm.gradient_background(30, 20)
+        # Ne doit pas lever d'exception et doit appeler matplotlib.pyplot.show
+        sm.quick_view(v, dx=1.5, dz=1.5, title="Test Model")
+        mock_show.assert_called_once()
+
+    def test_quick_view_invalid_model(self):
+        v = np.array([1, 2, 3]) # 1D invalide
+        with pytest.raises(ValueError, match="Model must be 2D"):
+            sm.quick_view(v)