seiscode-models 0.1.0__tar.gz → 0.2.0__tar.gz

{seiscode_models-0.1.0 → seiscode_models-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: seiscode-models
-Version: 0.1.0
+Version: 0.2.0
 Summary: Synthetic subsurface velocity model generators for seismic testing
 Author-email: Damien Pageot <damien.pageot@gmail.com>
 License: MIT

{seiscode_models-0.1.0 → seiscode_models-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "seiscode-models"
-version = "0.1.0"
+version = "0.2.0"
 description = "Synthetic subsurface velocity model generators for seismic testing"
 readme = "README.md"
 license = {text = "MIT"}

{seiscode_models-0.1.0 → seiscode_models-0.2.0}/src/seiscode_models/__init__.py

@@ -20,10 +20,12 @@ from .utils.io import (
     load_model
 )
 from .utils.visualization import quick_view
+from .core import VelocityModel
 
 __version__ = "0.1.0"
 
 __all__ = [
+    "VelocityModel",
     "gradient_background",
     "add_gaussian_anomaly",
     "add_fault_offset",

seiscode_models-0.2.0/src/seiscode_models/core.py

@@ -0,0 +1,226 @@
+"""Object-oriented interface for 2D subsurface velocity models."""
+from pathlib import Path
+from typing import Union, Tuple, Optional
+import numpy as np
+
+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
+from .utils.visualization import quick_view
+
+class VelocityModel:
+    """Represents a 2D subsurface velocity model with grid metadata and method chaining."""
+
+    def __init__(self, data: np.ndarray, dx: float = 1.0, dz: float = 1.0) -> None:
+        """Initialize a VelocityModel from an existing NumPy array.
+
+        Parameters
+        ----------
+        data : ndarray (nx, nz)
+            Velocity model array in m/s.
+        dx, dz : float, optional
+            Grid spacing in meters. Default is 1.0.
+        """
+        validate_model(data, dx=dx, dz=dz)
+        self._data: np.ndarray = data
+        self._dx: float = float(dx)
+        self._dz: float = float(dz)
+
+    @property
+    def data(self) -> np.ndarray:
+        """Underlying NumPy array (nx, nz)."""
+        return self._data
+
+    @property
+    def nx(self) -> int:
+        """Number of grid cells along x."""
+        return self._data.shape[0]
+
+    @property
+    def nz(self) -> int:
+        """Number of grid cells along z."""
+        return self._data.shape[1]
+
+    @property
+    def dx(self) -> float:
+        """Grid spacing along x in meters."""
+        return self._dx
+
+    @property
+    def dz(self) -> float:
+        """Grid spacing along z in meters."""
+        return self._dz
+
+    @property
+    def dtype(self) -> np.dtype:
+        """NumPy data type precision (float32 or float64)."""
+        return self._data.dtype
+
+    # --- Factory Methods (Constructeurs géologiques orientés objet) ---
+
+    @classmethod
+    def gradient(
+        cls, 
+        nx: int = 201, 
+        nz: int = 51, 
+        dx: float = 1.0, 
+        dz: float = 1.0, 
+        v0: float = 1500.0, 
+        v1: float = 4500.0, 
+        dtype: Union[str, np.dtype] = np.float32
+    ) -> "VelocityModel":
+        """Create a model with a linear velocity gradient with depth."""
+        arr = gradient_background(nx, nz, v0=v0, v1=v1, dtype=dtype)
+        return cls(arr, dx=dx, dz=dz)
+
+    @classmethod
+    def salt_dome(
+        cls, 
+        nx: int = 201, 
+        nz: int = 51, 
+        dx: float = 1.0, 
+        dz: float = 1.0, 
+        cx: int = 140, 
+        width: float = 40.0, 
+        v_salt: float = 4500.0, 
+        v_sed: float = 2500.0, 
+        dtype: Union[str, np.dtype] = np.float32
+    ) -> "VelocityModel":
+        """Create a salt dome model."""
+        arr = salt_dome(nx, nz, cx=cx, width=width, v_salt=v_salt, v_sed=v_sed, dtype=dtype)
+        return cls(arr, dx=dx, dz=dz)
+
+    @classmethod
+    def dipping_layers(
+        cls, 
+        nx: int = 201, 
+        nz: int = 51, 
+        dx: float = 1.0, 
+        dz: float = 1.0, 
+        v: Tuple[float, ...] = (1800.0, 2400.0, 3200.0, 4200.0), 
+        dip_deg: float = 8.0, 
+        dtype: Union[str, np.dtype] = np.float32
+    ) -> "VelocityModel":
+        """Create a dipping layers model."""
+        arr = dipping_layers(nx=nx, nz=nz, dx=dx, dz=dz, v=v, dip_deg=dip_deg, dtype=dtype)
+        return cls(arr, dx=dx, dz=dz)
+
+    @classmethod
+    def sinusoidal_interface(
+        cls, 
+        nx: int = 201, 
+        nz: int = 51, 
+        dx: float = 1.0, 
+        dz: float = 1.0, 
+        period: float = 100.0, 
+        amplitude: float = 8.0, 
+        v_top: float = 2000.0, 
+        v_bottom: float = 3500.0, 
+        dtype: Union[str, np.dtype] = np.float32
+    ) -> "VelocityModel":
+        """Create a model with a sinusoidal interface."""
+        arr = sinusoidal_interface(nx=nx, nz=nz, period=period, amplitude=amplitude, v_top=v_top, v_bottom=v_bottom, dtype=dtype)
+        return cls(arr, dx=dx, dz=dz)
+
+    @classmethod
+    def faulted_layers(
+        cls, 
+        nx: int = 201, 
+        nz: int = 51, 
+        dx: float = 1.0, 
+        dz: float = 1.0, 
+        ix_fault: int = 120, 
+        throw: int = 8, 
+        v: Tuple[float, ...] = (1800.0, 2400.0, 3200.0, 4200.0), 
+        dtype: Union[str, np.dtype] = np.float32
+    ) -> "VelocityModel":
+        """Create a faulted stratigraphic layers model."""
+        arr = faulted_layers(nx=nx, nz=nz, ix_fault=ix_fault, throw=throw, v=v, dtype=dtype)
+        return cls(arr, dx=dx, dz=dz)
+
+    @classmethod
+    def checkerboard(
+        cls, 
+        nx: int = 201, 
+        nz: int = 51, 
+        dx: float = 1.0, 
+        dz: float = 1.0, 
+        cell: int = 20, 
+        v0: float = 3000.0, 
+        dv: float = 600.0, 
+        dtype: Union[str, np.dtype] = np.float32
+    ) -> "VelocityModel":
+        """Create a checkerboard resolution test model."""
+        arr = checkerboard(nx=nx, nz=nz, cell=cell, v0=v0, dv=dv, dtype=dtype)
+        return cls(arr, dx=dx, dz=dz)
+
+    @classmethod
+    def low_velocity_layer(
+        cls, 
+        nx: int = 201, 
+        nz: int = 51, 
+        dx: float = 1.0, 
+        dz: float = 1.0, 
+        k0: int = 20, 
+        thickness: int = 8, 
+        v_slow: float = 1200.0, 
+        dtype: Union[str, np.dtype] = np.float32
+    ) -> "VelocityModel":
+        """Create a model with a buried low-velocity channel."""
+        arr = low_velocity_layer(nx=nx, nz=nz, k0=k0, thickness=thickness, v_slow=v_slow, dtype=dtype)
+        return cls(arr, dx=dx, dz=dz)
+
+    @classmethod
+    def heterogeneous_anomaly_model(
+        cls, 
+        nx: int = 384, 
+        nz: int = 122, 
+        dx: float = 1.0, 
+        dz: float = 1.0, 
+        seed: int = 7, 
+        dtype: Union[str, np.dtype] = np.float32
+    ) -> "VelocityModel":
+        """Create a complex heterogeneous synthetic anomaly model."""
+        arr = heterogeneous_anomaly_model(nx=nx, nz=nz, seed=seed, dtype=dtype)
+        return cls(arr, dx=dx, dz=dz)
+
+    # --- Modifier Methods (Fluent Interface / Method Chaining) ---
+
+    def add_anomaly(
+        self, 
+        cx: float, 
+        cz: float, 
+        sigma_x: float, 
+        sigma_z: float, 
+        dv: float, 
+        vmin: float = 200.0, 
+        vmax: float = 8000.0
+    ) -> "VelocityModel":
+        """Add a Gaussian velocity anomaly in place and return self for method chaining."""
+        self._data = add_gaussian_anomaly(self._data, cx, cz, sigma_x, sigma_z, dv, vmin=vmin, vmax=vmax)
+        return self
+
+    def add_fault(self, ix_fault: int, throw: int) -> "VelocityModel":
+        """Apply a fault offset in place and return self for method chaining."""
+        self._data = add_fault_offset(self._data, ix_fault, throw)
+        return self
+
+    # --- Utility Methods ---
+
+    def export(self, filepath: Union[str, Path], format: str = "bin") -> None:
+        """Export the model to a file compatible with seismic solvers."""
+        export_model(self._data, filepath, format=format, dx=self._dx, dz=self._dz)
+
+    def plot(self, title: str = "Velocity model") -> None:
+        """Display the velocity model."""
+        quick_view(self._data, dx=self._dx, dz=self._dz, title=title)

{seiscode_models-0.1.0 → seiscode_models-0.2.0}/src/seiscode_models.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: seiscode-models
-Version: 0.1.0
+Version: 0.2.0
 Summary: Synthetic subsurface velocity model generators for seismic testing
 Author-email: Damien Pageot <damien.pageot@gmail.com>
 License: MIT

{seiscode_models-0.1.0 → seiscode_models-0.2.0}/src/seiscode_models.egg-info/SOURCES.txt

@@ -2,6 +2,7 @@ LICENSE
 README.md
 pyproject.toml
 src/seiscode_models/__init__.py
+src/seiscode_models/core.py
 src/seiscode_models.egg-info/PKG-INFO
 src/seiscode_models.egg-info/SOURCES.txt
 src/seiscode_models.egg-info/dependency_links.txt
@@ -15,6 +16,7 @@ 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_core.py
 tests/test_dtypes.py
 tests/test_geological.py
 tests/test_io.py

seiscode_models-0.2.0/tests/test_core.py

@@ -0,0 +1,30 @@
+"""Tests for the object-oriented VelocityModel interface."""
+import numpy as np
+import pytest
+import seiscode_models as sm
+
+class TestVelocityModelOOP:
+    def test_factory_and_properties(self):
+        model = sm.VelocityModel.gradient(nx=100, nz=50, dx=2.0, dz=2.0, dtype="f32")
+        assert model.nx == 100
+        assert model.nz == 50
+        assert model.dx == 2.0
+        assert model.dz == 2.0
+        assert model.dtype == np.float32
+        assert model.data.shape == (100, 50)
+
+    def test_method_chaining(self):
+        model = (
+            sm.VelocityModel.gradient(nx=80, nz=40, dtype="f64")
+            .add_anomaly(cx=40, cz=20, sigma_x=5.0, sigma_z=5.0, dv=500.0)
+            .add_fault(ix_fault=50, throw=5)
+        )
+        assert isinstance(model, sm.VelocityModel)
+        assert model.dtype == np.float64
+        assert model.data.shape == (80, 40)
+
+    def test_export_from_model(self, tmp_path):
+        model = sm.VelocityModel.salt_dome(30, 30)
+        file_path = tmp_path / "oop_model.bin"
+        model.export(file_path, format="bin")
+        assert file_path.exists()