tide-GPR 0.0.9__py3-none-manylinux_2_28_x86_64.whl

tide/callbacks.py

@@ -0,0 +1,348 @@
+"""Callback state and helpers for TIDE propagators."""
+
+from typing import (
+    TYPE_CHECKING,
+    Callable,
+    Dict,
+    Optional,
+    Union,
+)
+
+if TYPE_CHECKING:
+    from types import EllipsisType
+
+import torch
+
+
+class CallbackState:
+    """State provided to user callbacks during wave propagation.
+
+    This class encapsulates the simulation state at a given time step,
+    providing convenient access to wavefields, model parameters, and
+    gradients with different views (full, pml, inner).
+
+    The three views correspond to different regions of the computational domain:
+    - 'full': The entire padded domain including FD padding
+    - 'pml': The model region plus PML absorbing layers
+    - 'inner': Only the physical model region (excluding PML)
+
+    Example:
+        >>> def my_callback(state: CallbackState):
+        ...     # Get the Ey field in the inner (physical) region
+        ...     ey = state.get_wavefield("Ey", view="inner")
+        ...     print(f"Step {state.step}, max |Ey| = {ey.abs().max():.6e}")
+        ...
+        ...     # Get the permittivity model
+        ...     eps = state.get_model("epsilon", view="inner")
+        ...
+        ...     # During backward pass, get gradients
+        ...     if state.is_backward:
+        ...         grad_eps = state.get_gradient("epsilon", view="inner")
+        >>>
+        >>> # Use with maxwell propagator
+        >>> result = maxwell.maxwelltm(..., forward_callback=my_callback)
+
+    Attributes:
+        dt: The time step size in seconds.
+        step: The current time step number (0-indexed).
+        nt: Total number of time steps.
+        is_backward: Whether this is during backward (adjoint) propagation.
+    """
+
+    def __init__(
+        self,
+        dt: float,
+        step: int,
+        nt: int,
+        wavefields: Dict[str, torch.Tensor],
+        models: Dict[str, torch.Tensor],
+        gradients: Optional[Dict[str, torch.Tensor]] = None,
+        fd_pad: Optional[list[int]] = None,
+        pml_width: Optional[list[int]] = None,
+        is_backward: bool = False,
+        grid_spacing: Optional[list[float]] = None,
+    ) -> None:
+        """Initialize the callback state.
+
+        Args:
+            dt: The time step size in seconds.
+            step: The current time step number.
+            nt: Total number of time steps.
+            wavefields: A dictionary mapping wavefield names to tensors.
+                For Maxwell TM: {"Ey", "Hx", "Hz", "m_Ey_x", "m_Ey_z", ...}
+            models: A dictionary mapping model names to tensors.
+                For Maxwell TM: {"epsilon", "sigma", "mu", "ca", "cb", "cq"}
+            gradients: A dictionary mapping gradient names to tensors.
+                Only available during backward pass.
+            fd_pad: Padding for finite difference stencil [y0, y1, x0, x1].
+                If None, assumes no padding.
+            pml_width: Width of PML layers [top, bottom, left, right].
+                If None, assumes no PML.
+            is_backward: Whether this is during backward propagation.
+            grid_spacing: Grid spacing [dy, dx] in meters.
+        """
+        self.dt = dt
+        self.step = step
+        self.nt = nt
+        self.is_backward = is_backward
+        self._wavefields = wavefields
+        self._models = models
+        self._gradients = gradients if gradients is not None else {}
+        self._fd_pad = fd_pad if fd_pad is not None else [0, 0, 0, 0]
+        self._pml_width = pml_width if pml_width is not None else [0, 0, 0, 0]
+        self._grid_spacing = grid_spacing
+
+        # Determine spatial ndim from padding (preferred) or model tensors.
+        # Padding lists are in [d0_low, d0_high, d1_low, d1_high, ...] format.
+        if fd_pad is not None and len(fd_pad) in {4, 6}:
+            self._ndim = len(fd_pad) // 2
+        elif pml_width is not None and len(pml_width) in {4, 6}:
+            self._ndim = len(pml_width) // 2
+        elif models:
+            first_model = next(iter(models.values()))
+            # Heuristic:
+            # - 2D unbatched: [ny, nx] -> 2
+            # - 2D batched:   [n_shots, ny, nx] -> 2
+            # - 3D unbatched: [nz, ny, nx] -> ambiguous with 2D batched; callers
+            #   should pass fd_pad/pml_width to disambiguate.
+            # - 3D batched:   [n_shots, nz, ny, nx] -> 3
+            if first_model.ndim == 2:
+                self._ndim = 2
+            elif first_model.ndim == 4:
+                self._ndim = 3
+            else:
+                # Preserve existing behavior (Maxwell TM callbacks) as default.
+                self._ndim = 2
+        else:
+            # Default to 2D when no other information is available.
+            self._ndim = 2
+
+    @property
+    def time(self) -> float:
+        """Current simulation time in seconds."""
+        return self.step * self.dt
+
+    @property
+    def progress(self) -> float:
+        """Simulation progress as a fraction [0, 1]."""
+        return self.step / max(self.nt - 1, 1)
+
+    @property
+    def wavefield_names(self) -> list[str]:
+        """list of available wavefield names."""
+        return list(self._wavefields.keys())
+
+    @property
+    def model_names(self) -> list[str]:
+        """list of available model names."""
+        return list(self._models.keys())
+
+    @property
+    def gradient_names(self) -> list[str]:
+        """list of available gradient names."""
+        return list(self._gradients.keys())
+
+    def get_wavefield(self, name: str, view: str = "inner") -> torch.Tensor:
+        """Get a wavefield tensor.
+
+        Args:
+            name: The name of the wavefield. For Maxwell TM mode:
+                - "Ey": Electric field (y-component)
+                - "Hx": Magnetic field (x-component)
+                - "Hz": Magnetic field (z-component)
+                - "m_Ey_x", "m_Ey_z", "m_Hx_z", "m_Hz_x": CPML auxiliary fields
+                - During backward: "lambda_Ey", "lambda_Hx", "lambda_Hz"
+            view: The part of the wavefield to return:
+                - 'inner': The physical model region (default)
+                - 'pml': Model region plus PML layers
+                - 'full': Entire domain including FD padding
+
+        Returns:
+            The specified part of the wavefield tensor.
+            Shape depends on view and whether batched: [n_shots, ny, nx] or [ny, nx]
+
+        Raises:
+            KeyError: If the wavefield name is not found.
+            ValueError: If view is not valid.
+        """
+        if name not in self._wavefields:
+            available = ", ".join(self._wavefields.keys())
+            raise KeyError(f"Wavefield '{name}' not found. Available: {available}")
+        return self._get_view(self._wavefields[name], view)
+
+    def get_model(self, name: str, view: str = "inner") -> torch.Tensor:
+        """Get a model parameter tensor.
+
+        Args:
+            name: The name of the model parameter. For Maxwell TM:
+                - "epsilon": Relative permittivity
+                - "sigma": Electrical conductivity (S/m)
+                - "mu": Relative permeability
+                - "ca", "cb", "cq": Update coefficients
+            view: The part of the model to return:
+                - 'inner': The physical model region (default)
+                - 'pml': Model region plus PML layers
+                - 'full': Entire domain including FD padding
+
+        Returns:
+            The specified part of the model tensor.
+
+        Raises:
+            KeyError: If the model name is not found.
+            ValueError: If view is not valid.
+        """
+        if name not in self._models:
+            available = ", ".join(self._models.keys())
+            raise KeyError(f"Model '{name}' not found. Available: {available}")
+        return self._get_view(self._models[name], view)
+
+    def get_gradient(self, name: str, view: str = "inner") -> torch.Tensor:
+        """Get a gradient tensor (only available during backward pass).
+
+        Args:
+            name: The name of the gradient. For Maxwell TM:
+                - "epsilon" or "ca": Gradient w.r.t. permittivity/Ca
+                - "sigma" or "cb": Gradient w.r.t. conductivity/Cb
+            view: The part of the gradient to return:
+                - 'inner': The physical model region (default)
+                - 'pml': Model region plus PML layers
+                - 'full': Entire domain including FD padding
+
+        Returns:
+            The specified part of the gradient tensor.
+
+        Raises:
+            KeyError: If the gradient name is not found.
+            ValueError: If view is not valid.
+            RuntimeError: If called during forward pass (no gradients available).
+        """
+        if not self._gradients:
+            raise RuntimeError(
+                "Gradients are only available during backward propagation. "
+                "Use backward_callback instead of forward_callback."
+            )
+        if name not in self._gradients:
+            available = ", ".join(self._gradients.keys())
+            raise KeyError(f"Gradient '{name}' not found. Available: {available}")
+        return self._get_view(self._gradients[name], view)
+
+    def _get_view(self, x: torch.Tensor, view: str) -> torch.Tensor:
+        """Extract a view of a tensor based on the specified region.
+
+        Args:
+            x: The tensor to extract a view from.
+            view: One of 'full', 'pml', or 'inner'.
+
+        Returns:
+            A view of the tensor corresponding to the specified region.
+        """
+        if view == "full":
+            return x
+
+        if view not in {"pml", "inner"}:
+            raise ValueError(
+                f"view must be 'full', 'pml', or 'inner', but got '{view}'"
+            )
+
+        spatial_ndim = self._ndim
+        if spatial_ndim not in {2, 3}:
+            raise ValueError(f"Unsupported spatial ndim {spatial_ndim}.")
+
+        if view == "pml":
+            starts = [self._fd_pad[2 * i] for i in range(spatial_ndim)]
+            ends = [self._fd_pad[2 * i + 1] for i in range(spatial_ndim)]
+        else:
+            starts = [
+                self._fd_pad[2 * i] + self._pml_width[2 * i]
+                for i in range(spatial_ndim)
+            ]
+            ends = [
+                self._fd_pad[2 * i + 1] + self._pml_width[2 * i + 1]
+                for i in range(spatial_ndim)
+            ]
+
+        def _slice(dim_size: int, start: int, end: int) -> slice:
+            stop = dim_size - end if end > 0 else None
+            return slice(start, stop)
+
+        if x.ndim == spatial_ndim:
+            # Non-batched: [ny, nx] or [nz, ny, nx]
+            idx = tuple(
+                _slice(x.shape[i], starts[i], ends[i]) for i in range(spatial_ndim)
+            )
+            return x[idx]
+
+        # Batched: [..., ny, nx] or [..., nz, ny, nx]
+        idx_batched: tuple[Union["EllipsisType", slice], ...] = (
+            ...,
+            *(
+                _slice(
+                    x.shape[-spatial_ndim + i],
+                    starts[i],
+                    ends[i],
+                )
+                for i in range(spatial_ndim)
+            ),
+        )
+        return x[idx_batched]
+
+    def __repr__(self) -> str:
+        """Return a string representation of the callback state."""
+        return (
+            f"CallbackState(step={self.step}/{self.nt}, "
+            f"time={self.time:.2e}s, "
+            f"is_backward={self.is_backward}, "
+            f"wavefields={self.wavefield_names}, "
+            f"models={self.model_names})"
+        )
+
+
+# Type alias for callback functions
+Callback = Callable[[CallbackState], None]
+
+
+def create_callback_state(
+    dt: float,
+    step: int,
+    nt: int,
+    wavefields: Dict[str, torch.Tensor],
+    models: Dict[str, torch.Tensor],
+    gradients: Optional[Dict[str, torch.Tensor]] = None,
+    fd_pad: Optional[list[int]] = None,
+    pml_width: Optional[list[int]] = None,
+    is_backward: bool = False,
+    grid_spacing: Optional[list[float]] = None,
+) -> CallbackState:
+    """Factory function to create a CallbackState.
+
+    This is a convenience function that creates a CallbackState with
+    the given parameters. It's equivalent to calling the CallbackState
+    constructor directly.
+
+    Args:
+        dt: The time step size in seconds.
+        step: The current time step number.
+        nt: Total number of time steps.
+        wavefields: A dictionary mapping wavefield names to tensors.
+        models: A dictionary mapping model names to tensors.
+        gradients: A dictionary mapping gradient names to tensors (backward only).
+        fd_pad: Padding for finite difference stencil [y0, y1, x0, x1].
+        pml_width: Width of PML layers [top, bottom, left, right].
+        is_backward: Whether this is during backward propagation.
+        grid_spacing: Grid spacing [dy, dx] in meters.
+
+    Returns:
+        A new CallbackState instance.
+    """
+    return CallbackState(
+        dt=dt,
+        step=step,
+        nt=nt,
+        wavefields=wavefields,
+        models=models,
+        gradients=gradients,
+        fd_pad=fd_pad,
+        pml_width=pml_width,
+        is_backward=is_backward,
+        grid_spacing=grid_spacing,
+    )

tide/cfl.py

@@ -0,0 +1,64 @@
+"""CFL condition helpers for stable time stepping."""
+
+import math
+from typing import Union
+
+
+def cfl_condition(
+    grid_spacing: Union[float, list[float]],
+    dt: float,
+    max_vel: float,
+    c_max: float = 1,
+    eps: float = 1e-15,
+) -> tuple[float, int]:
+    """Calculate time step interval to satisfy CFL condition.
+
+    The CFL (Courant-Friedrichs-Lewy) condition ensures numerical stability
+    for explicit FDTD schemes. If the user-provided dt is too large, this
+    function computes a smaller internal dt and the ratio between them.
+
+    Args:
+        grid_spacing: Grid spacing [dy, dx] or single value for isotropic.
+        dt: User-provided time step.
+        max_vel: Maximum wave velocity in the model.
+        c_max: Maximum Courant number (default 0.6 for stability margin).
+        eps: Small value to prevent division by zero.
+
+    Returns:
+        Tuple of (inner_dt, step_ratio) where:
+        - inner_dt: Time step satisfying CFL condition
+        - step_ratio: Integer ratio dt / inner_dt
+
+    Example:
+        >>> # Check if dt=1e-9 is stable for v=3e8 m/s, dx=1e-3 m
+        >>> inner_dt, ratio = cfl_condition([1e-3, 1e-3], 1e-9, 3e8)
+        >>> print(f"Need {ratio}x smaller time step")
+    """
+    # Normalize grid_spacing to list
+    if isinstance(grid_spacing, (int, float)):
+        grid_spacing = [float(grid_spacing), float(grid_spacing)]
+    else:
+        grid_spacing = list(grid_spacing)
+
+    if max_vel <= 0:
+        raise ValueError("max_vel must be positive")
+
+    # Maximum stable dt from CFL condition
+    max_dt = (
+        c_max / math.sqrt(sum(1 / dx**2 for dx in grid_spacing)) / (max_vel**2 + eps)
+    ) * max_vel
+
+    step_ratio = math.ceil(abs(dt) / max_dt)
+    inner_dt = dt / step_ratio
+
+    if step_ratio >= 2:
+        import warnings
+
+        warnings.warn(
+            f"CFL condition requires {step_ratio} internal time steps per "
+            f"user time step (dt={dt}, inner_dt={inner_dt}). Consider using "
+            "a smaller dt or coarser grid.",
+            stacklevel=2,
+        )
+
+    return inner_dt, step_ratio

tide/csrc/CMakeLists.txt

@@ -0,0 +1,263 @@
+# TIDE Backend CMakelists.txt
+
+cmake_minimum_required(VERSION 3.18)
+project(tide_backend LANGUAGES C CXX)
+
+option(TIDE_ENABLE_CUDA "Enable CUDA backend" ON)
+
+# Detect and enable CUDA if present and enabled
+if(TIDE_ENABLE_CUDA)
+    find_package(CUDAToolkit)
+    if(CUDAToolkit_FOUND)
+        enable_language(CUDA)
+    else()
+        message(WARNING "CUDA not found. Building without CUDA support.")
+    endif()
+else()
+    message(STATUS "CUDA disabled (TIDE_ENABLE_CUDA=OFF).")
+    set(CUDAToolkit_FOUND FALSE)
+endif()
+
+# Default build type
+if(NOT CMAKE_BUILD_TYPE)
+    set(CMAKE_BUILD_TYPE Release CACHE STRING "Choose the type of build." FORCE)
+endif()
+
+# --- OpenMP Configuration (aligned with deepwave) ---
+add_library(Tide_OpenMP_Interface INTERFACE)
+set(OPENMP_CONFIGURED FALSE)
+
+# On Windows with Clang, we need to manually configure OpenMP
+if(WIN32 AND CMAKE_C_COMPILER_ID MATCHES "Clang")
+    # Find libomp from LLVM installation
+    find_library(LIBOMP_LIB NAMES libomp omp PATHS "C:/Program Files/LLVM/lib" NO_DEFAULT_PATH)
+    if(LIBOMP_LIB)
+        target_link_libraries(Tide_OpenMP_Interface INTERFACE "${LIBOMP_LIB}")
+        target_compile_options(Tide_OpenMP_Interface INTERFACE -fopenmp)
+        set(OPENMP_CONFIGURED TRUE)
+        message(STATUS "OpenMP enabled (Clang/LLVM on Windows).")
+    else()
+        message(STATUS "OpenMP not found (libomp.lib not in LLVM/lib).")
+    endif()
+else()
+    find_package(OpenMP QUIET)
+    if(OpenMP_C_FOUND)
+        target_link_libraries(Tide_OpenMP_Interface INTERFACE OpenMP::OpenMP_C)
+        set(OPENMP_CONFIGURED TRUE)
+        message(STATUS "OpenMP enabled.")
+    else()
+        message(STATUS "OpenMP not found.")
+    endif()
+endif()
+
+# --- Compiler Feature Detection and Flags ---
+include(CheckCSourceCompiles)
+
+# AVX2 detection
+set(AVX2_TEST_CODE "
+    #include <immintrin.h>
+    int main() {
+        __m256 vec = _mm256_set1_ps(42.0f);
+        return 0;
+    }")
+
+if(CMAKE_C_COMPILER_ID MATCHES "GNU|Clang|Intel")
+    if(WIN32)
+        set(C_AVX2_FLAG "/arch:AVX2")  # Clang-cl uses MSVC-style flags
+    else()
+        set(C_AVX2_FLAG "-mavx2")
+    endif()
+endif()
+
+if(C_AVX2_FLAG)
+    set(CMAKE_REQUIRED_FLAGS "${C_AVX2_FLAG}")
+    check_c_source_compiles("${AVX2_TEST_CODE}" HAVE_AVX2)
+    unset(CMAKE_REQUIRED_FLAGS)
+else()
+    set(HAVE_AVX2 FALSE)
+endif()
+
+if(HAVE_AVX2)
+    message(STATUS "AVX2 is supported.")
+else()
+    message(STATUS "AVX2 is not supported.")
+endif()
+
+# Release flags (aligned with deepwave)
+if(CMAKE_BUILD_TYPE MATCHES Release)
+    if(CMAKE_C_COMPILER_ID MATCHES "GNU|Clang|Intel")
+        if(WIN32)
+            # Clang-cl on Windows uses MSVC-style flags
+            set(C_RELEASE_FLAGS "/O2" "/fp:fast")
+        else()
+            set(C_RELEASE_FLAGS "-Ofast")
+            set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Ofast")
+        endif()
+    endif()
+endif()
+
+# --- Helper Macros for Object Libraries ---
+macro(add_tide_cpu_object_library BASENAME ACCURACY DTYPE)
+    set(TARGET_NAME "${BASENAME}_${ACCURACY}_${DTYPE}_cpu_obj")
+    add_library(${TARGET_NAME} OBJECT ${CMAKE_CURRENT_SOURCE_DIR}/${BASENAME}.c)
+    target_compile_definitions(${TARGET_NAME} PRIVATE 
+        TIDE_STENCIL=${ACCURACY} 
+        TIDE_DTYPE=${DTYPE}
+        TIDE_DEVICE=cpu
+    )
+    target_include_directories(${TARGET_NAME} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})
+    list(APPEND TIDE_OBJECTS $<TARGET_OBJECTS:${TARGET_NAME}>)
+    list(APPEND CPU_TARGETS ${TARGET_NAME})
+
+    # Set PIC for shared library objects
+    set_target_properties(${TARGET_NAME} PROPERTIES POSITION_INDEPENDENT_CODE ON)
+
+    if(C_RELEASE_FLAGS)
+        target_compile_options(${TARGET_NAME} PRIVATE ${C_RELEASE_FLAGS})
+    endif()
+
+    if(HAVE_AVX2 AND C_AVX2_FLAG)
+        target_compile_options(${TARGET_NAME} PRIVATE ${C_AVX2_FLAG})
+    endif()
+endmacro()
+
+if(CUDAToolkit_FOUND)
+    macro(add_tide_cuda_object_library BASENAME ACCURACY DTYPE)
+        set(TARGET_NAME "${BASENAME}_${ACCURACY}_${DTYPE}_cuda_obj")
+        add_library(${TARGET_NAME} OBJECT ${CMAKE_CURRENT_SOURCE_DIR}/${BASENAME}.cu)
+        # Set TIDE_DTYPE_FLOAT based on DTYPE (optimization 2.1)
+        if(${DTYPE} STREQUAL "float")
+            set(IS_FLOAT 1)
+        else()
+            set(IS_FLOAT 0)
+        endif()
+        target_compile_definitions(${TARGET_NAME} PRIVATE
+            TIDE_STENCIL=${ACCURACY}
+            TIDE_DTYPE=${DTYPE}
+            TIDE_DEVICE=cuda
+            TIDE_DTYPE_FLOAT=${IS_FLOAT}
+        )
+        target_include_directories(${TARGET_NAME} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})
+        list(APPEND TIDE_OBJECTS $<TARGET_OBJECTS:${TARGET_NAME}>)
+        
+        # Use "all" or specific architectures
+        if(NOT DEFINED CMAKE_CUDA_ARCHITECTURES)
+            set_target_properties(${TARGET_NAME} PROPERTIES CUDA_ARCHITECTURES "89")
+        else()
+            set_target_properties(${TARGET_NAME} PROPERTIES CUDA_ARCHITECTURES "${CMAKE_CUDA_ARCHITECTURES}")
+        endif()
+
+        if(CMAKE_BUILD_TYPE MATCHES Release)
+            target_compile_options(${TARGET_NAME} PRIVATE
+                $<$<COMPILE_LANGUAGE:CUDA>:
+                    --use_fast_math
+                    -O3
+                    --restrict
+                    --maxrregcount=64
+                    -Xptxas=-dlcm=ca
+                >)
+        endif()
+    endmacro()
+endif()
+
+# Prepare lists that will collect the object files
+set(TIDE_OBJECTS)
+set(CPU_TARGETS)
+set(ACCURACIES 2 4 6 8)
+set(DTYPES float double)
+
+# --- Storage utilities ---
+set(STORAGE_UTILS_CPU_SRC ${CMAKE_CURRENT_SOURCE_DIR}/storage_utils.c)
+set(STORAGE_UTILS_CUDA_SRC "")
+
+# --- CPU object libraries ---
+foreach(ACCURACY ${ACCURACIES})
+    foreach(DTYPE ${DTYPES})
+        add_tide_cpu_object_library(maxwell ${ACCURACY} ${DTYPE})
+    endforeach()
+endforeach()
+
+if(OPENMP_CONFIGURED)
+    foreach(CPU_TARGET ${CPU_TARGETS})
+        target_link_libraries(${CPU_TARGET} PRIVATE Tide_OpenMP_Interface)
+    endforeach()
+endif()
+
+# --- CUDA object libraries ---
+if(CUDAToolkit_FOUND)
+    if(CMAKE_BUILD_TYPE MATCHES Release)
+        set(CUDA_RELEASE_OPTIONS --use_fast_math -O3 --restrict --maxrregcount=64 -Xptxas=-dlcm=ca)
+    endif()
+    if(NOT WIN32)
+        list(APPEND CMAKE_CUDA_FLAGS -Xcompiler=-fPIC)
+    endif()
+
+    foreach(ACCURACY ${ACCURACIES})
+        foreach(DTYPE ${DTYPES})
+            add_tide_cuda_object_library(maxwell ${ACCURACY} ${DTYPE})
+        endforeach()
+    endforeach()
+
+    # --- Storage utilities ---
+    set(STORAGE_UTILS_CUDA_SRC ${CMAKE_CURRENT_SOURCE_DIR}/storage_utils.cu)
+    set_source_files_properties(${STORAGE_UTILS_CUDA_SRC} PROPERTIES CUDA_ARCHITECTURES "89")
+endif()
+
+# --- Final Library Build ---
+# Combine all objects into a single shared library
+add_library(tide_C SHARED ${TIDE_OBJECTS} ${STORAGE_UTILS_CUDA_SRC} ${STORAGE_UTILS_CPU_SRC})
+
+if(WIN32)
+    set_target_properties(tide_C PROPERTIES OUTPUT_NAME "libtide_C")
+endif()
+
+set_target_properties(tide_C PROPERTIES
+    C_VISIBILITY_PRESET default
+    CUDA_VISIBILITY_PRESET default
+    POSITION_INDEPENDENT_CODE ON
+    WINDOWS_EXPORT_ALL_SYMBOLS ON
+)
+
+if(OPENMP_CONFIGURED)
+    target_link_libraries(tide_C PRIVATE Tide_OpenMP_Interface)
+endif()
+
+if(HAVE_AVX2)
+    target_compile_definitions(tide_C PRIVATE HAVE_AVX2)
+endif()
+
+# Set output directory to the tide package directory
+set_target_properties(tide_C PROPERTIES
+    LIBRARY_OUTPUT_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/..
+    RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/..
+)
+
+# --- Print Configuration Summary ---
+message(STATUS "")
+message(STATUS "TIDE Backend Configuration:")
+message(STATUS "  Build Type: ${CMAKE_BUILD_TYPE}")
+message(STATUS "  OpenMP: ${OPENMP_CONFIGURED}")
+message(STATUS "  AVX2: ${HAVE_AVX2}")
+if(CUDAToolkit_FOUND)
+    message(STATUS "  CUDA: ON")
+    message(STATUS "  CUDA Compiler: ${CMAKE_CUDA_COMPILER}")
+else()
+    message(STATUS "  CUDA: OFF")
+endif()
+message(STATUS "  Output Directory: ${CMAKE_CURRENT_SOURCE_DIR}/..")
+message(STATUS "")
+
+# Install target
+install(TARGETS tide_C
+    LIBRARY DESTINATION tide
+    ARCHIVE DESTINATION tide
+    RUNTIME DESTINATION tide
+)
+
+# Bundle OpenMP runtime on Windows (Clang's libomp.dll)
+if(WIN32)
+    set(TIDE_LIBOMP_DLL "${CMAKE_CURRENT_SOURCE_DIR}/../libomp.dll")
+    if(EXISTS "${TIDE_LIBOMP_DLL}")
+        install(FILES "${TIDE_LIBOMP_DLL}" DESTINATION tide)
+    endif()
+endif()

tide/csrc/common_cpu.h

@@ -0,0 +1,31 @@
+#ifndef COMMON_CPU_H
+#define COMMON_CPU_H
+
+#include <stdint.h>
+#include <stdbool.h>
+
+#ifndef TIDE_DTYPE
+#define TIDE_DTYPE float
+#endif
+
+#ifndef TIDE_STENCIL
+#define TIDE_STENCIL 4
+#endif
+
+#if defined(_OPENMP)
+#define TIDE_OMP_INDEX int64_t
+#define TIDE_OMP_PARALLEL_FOR _Pragma("omp parallel for")
+#define TIDE_OMP_PARALLEL_FOR_COLLAPSE2 _Pragma("omp parallel for collapse(2)")
+#define TIDE_OMP_PARALLEL_FOR_COLLAPSE4 _Pragma("omp parallel for collapse(4)")
+#define TIDE_OMP_SIMD _Pragma("omp simd")
+#define TIDE_OMP_SIMD_COLLAPSE2 _Pragma("omp simd collapse(2)")
+#else
+#define TIDE_OMP_INDEX int64_t
+#define TIDE_OMP_PARALLEL_FOR
+#define TIDE_OMP_PARALLEL_FOR_COLLAPSE2
+#define TIDE_OMP_PARALLEL_FOR_COLLAPSE4
+#define TIDE_OMP_SIMD
+#define TIDE_OMP_SIMD_COLLAPSE2
+#endif
+
+#endif