DeepGPR 0.0.8__tar.gz → 0.0.9__tar.gz

deepgpr-0.0.8/README.md → deepgpr-0.0.9/PKG-INFO

@@ -1,3 +1,20 @@
+Metadata-Version: 2.4
+Name: DeepGPR
+Version: 0.0.9
+Summary: PyTorch and CUDA for GPR FWI
+Author-email: Lei Liu <liulei990222@gmail.com>
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: matplotlib
+Requires-Dist: torch
+
 # DeepGPR
 
 DeepGPR provides a wave propagation module for PyTorch, designed for applications such as Ground Penetrating Radar (GPR) imaging and inversion. Its core concepts are derived from Deepwave. You can use it to perform both forward modeling and backpropagation—thereby enabling the simulation of wave propagation to generate synthetic data—as well as for Full Waveform Inversion (FWI). Furthermore, you can integrate this wave propagation functionality into a larger operational pipeline—incorporating various wavelets, loss functions, and other components—to achieve end-to-end forward and reverse propagation, powered by automatic differentiation and our high-performance operators.
@@ -19,40 +36,10 @@ Supports techniques such as checkpointing, DDP, and the utilization of CPU memor
 ## System Requirements
 
 - **OS**: Linux and Windows
-- **Python**: Python 3.8+
-- **GPU**: NVIDIA GPU with sufficient VRAM for 2D/3D computational grids
-- **CUDA**: NVIDIA driver and CUDA Toolkit
-- **Libraries**:
-  - `torch` with CUDA support
-  - `numpy`
-  - `scipy`
-  - `matplotlib`
-
-### Additional Requirements for Building from Source
-
-DeepGPR contains a CUDA backend that is compiled during installation. Therefore, users who install the package from source need a working CUDA/C++ build environment.
-
-#### Linux
-
-- CUDA Toolkit with `nvcc`
-- GCC/G++ compiler compatible with the installed CUDA version
-- CMake 3.23 or later
+- **Environment**: Python 3.8+, CUDA Toolkit 
+- **Libraries**: `torch` (with CUDA support), `numpy`, `scipy`, `matplotlib`
+- **Hardware**: NVIDIA GPU with sufficient VRAM for 3D computational grids.
 
-#### Windows
-
-- CUDA Toolkit with `nvcc`
-- CMake 3.23 or later
-- Microsoft Visual Studio Build Tools or Visual Studio Community
-- The **Desktop development with C++** workload
-- MSVC C++ compiler `cl.exe`
-- Windows SDK
-- Optional: `ninja`
-
-On Windows, `nvcc` relies on the MSVC compiler to build CUDA code. Please make sure that both `nvcc` and `cl.exe` are available before running:
-
-```bash
-pip install .
-```
 
 ## Start
 
@@ -244,4 +231,4 @@ If you find our codes useful, please kindly cite this article. Thanks.
 
   publisher={Elsevier}
 
-}
+}

deepgpr-0.0.9/README.md

@@ -0,0 +1,217 @@
+# DeepGPR
+
+DeepGPR provides a wave propagation module for PyTorch, designed for applications such as Ground Penetrating Radar (GPR) imaging and inversion. Its core concepts are derived from Deepwave. You can use it to perform both forward modeling and backpropagation—thereby enabling the simulation of wave propagation to generate synthetic data—as well as for Full Waveform Inversion (FWI). Furthermore, you can integrate this wave propagation functionality into a larger operational pipeline—incorporating various wavelets, loss functions, and other components—to achieve end-to-end forward and reverse propagation, powered by automatic differentiation and our high-performance operators.
+
+
+## Features
+
+Supports 2D and 3D forward modeling of Maxwell's equations—via the Finite-Difference Time-Domain (FDTD) method—for both single and multiple excitation scenarios.
+
+Gradients of the output receiver data can be computed with respect to model parameters (relative permittivity, conductivity), the initial wavefield, and source amplitudes.
+
+Utilizes CPML, allowing the width of the PML layer to be configured independently for each boundary.
+
+All operations are executed on the GPU.
+
+Supports techniques such as checkpointing, DDP, and the utilization of CPU memory to minimize GPU memory consumption, thereby enabling the execution of large-scale models.
+
+
+## System Requirements
+
+- **OS**: Linux and Windows
+- **Environment**: Python 3.8+, CUDA Toolkit 
+- **Libraries**: `torch` (with CUDA support), `numpy`, `scipy`, `matplotlib`
+- **Hardware**: NVIDIA GPU with sufficient VRAM for 3D computational grids.
+
+
+## Start
+
+Before use, you must ensure that you have an NVIDIA graphics card and have installed a CUDA-enabled version of PyTorch.
+
+DeepGPR can then be installed using
+
+```bash
+  pip install DeepGPR
+```
+
+
+
+## A Small Forward Modeling Test
+
+```python
+import torch
+import DeepGPR
+import matplotlib.pyplot as plt
+
+# Set up the parameters and models
+device=torch.device("cuda")
+dx=0.02
+dt=3e-11
+nt=2000
+er = torch.ones(100, 100,1) * 2  
+er[50:,:]=5
+se = torch.zeros_like(er)  
+er.requires_grad_()
+source_location=torch.tensor([[[10,10,0]]],device=device,dtype=torch.int)
+receiver_location=torch.tensor([[[10,90,0]]],device=device,dtype=torch.int)
+freq=2e8
+peak_time = 1 / freq
+source_amplitudes = torch.zeros((1,nt,1),device=device)
+source_amplitudes[0,:,0]=DeepGPR.ricker(freq, nt, dt, peak_time).to(device)
+
+
+#forward modeling
+r = DeepGPR.compute(
+    device=device, dx=dx, dt=dt, 
+    source_amplitudes=source_amplitudes,
+    source_location=source_location, 
+    receiver_location=receiver_location, 
+    er=er, se=se
+)
+
+(r[-1]**2).sum().backward()
+
+_, ax = plt.subplots(1, 2, figsize=(10, 3))
+ax[0].plot(r[-1].detach().flatten().cpu().numpy())
+ax[0].set_title("Receiver data")
+ax[1].imshow(er.grad.detach())
+ax[1].set_title("Gradient")
+plt.show()
+```
+
+![result](./Fig/example.png)
+
+There are more examples in the ./examples.
+
+
+
+The following figures present representative 2D and 3D full-waveform inversion (FWI) examples. For each case, the true model, initial model, and inverted result are shown to evaluate the reconstruction performance of the proposed method.
+
+### 2D FWI Result
+
+The 2D example illustrates the inversion performance on a two-dimensional subsurface model. The comparison between the true model, initial model, and inverted result shows that the proposed method can effectively recover the main structural features from the initial model.
+
+| True Model | Initial Model | Inverted Result |
+|---|---|---|
+| ![2D true model](./Fig/2dfwitrue.png) | ![2D initial model](./Fig/2dfwiinit.png) | ![2D inverted result](./Fig/2dfwipred.png) |
+
+### 3D FWI Result
+
+The 3D example demonstrates the applicability of the proposed method to three-dimensional full-waveform inversion. For visualization, the figures below show the central slice of the 3D model, including the true model, the initial model, and the inverted result. The comparison indicates that the proposed method can reconstruct the dominant subsurface structures in the 3D case and improve the model consistency relative to the initial model.
+
+| Model Type | Central Slice of 3D Model |
+|---|---|
+| True Model | ![3D true model central slice](./Fig/3dfwitrue.png) |
+| Initial Model | ![3D initial model central slice](./Fig/3dfwiinit.png) |
+| Inverted Result | ![3D inverted result central slice](./Fig/3dfwipred.png) |
+
+# `compute` Interface Documentation
+
+`compute` is a core function for 3D/2D Finite-Difference Time-Domain (FDTD) forward modeling, primarily designed for Ground Penetrating Radar (GPR) and electromagnetic wave propagation. It fully supports backpropagation (e.g., for Full Waveform Inversion, FWI) utilizing PyTorch's `autograd` engine.
+
+## 📝 Function Signature
+
+```python
+def compute(device, dx=None, dt=None, 
+            source_amplitudes=None,
+            source_location=None, 
+            receiver_location=None, 
+            er=None, se=None, mr=None, 
+            E=None, H=None, PML=None,
+            pmlthick=10, source_direction=2, reciever_direction=2,
+            model_gradient_sampling_interval=1,
+            use_async_offload=False):
+```
+## 📥 Input Parameters
+### 1. Basic Physics & Grid Parameters
+
+| Parameter | Data Type | Description |
+| :--- | :--- | :--- |
+| **`device`** | `torch.device` / `str` | PyTorch computation device, e.g., `'cuda:0'`. Determines where the computation takes place. |
+| **`dx`** | `float` | Spatial grid step size (assuming an isotropic grid, i.e., $dx = dy = dz$). Typically in meters (m). |
+| **`dt`** | `float` | Time step size. **Note**: Must strictly satisfy the CFL (Courant-Friedrichs-Lewy) stability condition, or an exception will be raised. Typically in seconds (s). |
+### 2. Medium Model Parameters
+
+This section defines the electromagnetic properties of the simulation space. For 2D simulations, set `nz=1`.
+
+| Parameter | Data Type | Shape | Description |
+| :--- | :--- | :--- | :--- |
+| **`er`** | `Tensor` (float) | `(nx, ny, nz)` or `(nx, ny)` | Relative permittivity ($\epsilon_r$). Values must be $\ge 1$. |
+| **`se`** | `Tensor` (float) | `(nx, ny, nz)` or `(nx, ny)` | Electrical conductivity ($\sigma$). Values must be non-negative. |
+| **`mr`** | `Tensor` (float) | `(nx, ny, nz)` or `(nx, ny)` | Relative permeability ($\mu_r$). Optional; defaults to 1 for the entire space. Shape must match `er`. |
+
+> **Dimension Key**: `nx`, `ny`, and `nz` represent the number of grid cells along the X, Y, and Z axes, respectively. 
+
+### 3. Source & Receiver Setup
+
+This section defines the geometric observation system (coordinates) and the excitation waveforms.
+
+| Parameter | Data Type | Shape | Description |
+| :--- | :--- | :--- | :--- |
+| **`source_amplitudes`** | `Tensor` (float) | `(num_waveforms, nt)` | Source excitation waveforms. `nt` is the total number of time steps.<br>- If `num_waveforms == 1`: All sources share this single waveform.<br>- If `num_waveforms == nsr`: Each source uses its corresponding waveform. |
+| **`source_location`** | `Tensor` (int) | `(nstep, nsr, 3)` | Grid coordinate indices of the sources.<br>The last dimension corresponds to `[x_idx, y_idx, z_idx]`. |
+| **`receiver_location`** | `Tensor` (int) | `(nstep, nrx, 3)` | Grid coordinate indices of the receivers.<br>The last dimension corresponds to `[x_idx, y_idx, z_idx]`. |
+| **`source_direction`** | `int` | Scalar | Polarization direction/component of the source excitation.<br>`0` = X, `1` = Y, `2` = Z (e.g., exciting $E_z$). |
+| **`reciever_direction`** | `int` | Scalar | The component direction recorded by the receivers. (Note: typo in variable name is kept as-is to match code).<br>`0` = $E_x$, `1` = $E_y$, `2` = $E_z$. |
+
+> **Core Shape Definitions**:
+> *   `nstep`: Number of shots/batches (independent simulation tasks running in parallel).
+> *   `nsr`: Number of **sources** per single simulation.
+> *   `nrx`: Number of **receivers** per single simulation.
+> *   `nt`: Total number of time steps to simulate.
+
+### 4. Boundary Conditions & Optimization
+
+| Parameter | Data Type | Format | Description |
+| :--- | :--- | :--- | :--- |
+| **`pmlthick`** | `int` / `list` / `Tensor`| Scalar or list of 6 | Thickness (in grid layers) of the PML (Perfectly Matched Layer) absorbing boundaries.<br>- Integer `p`: All six boundaries have thickness `p` (Z-boundaries are ignored in 2D).<br>- List `[x0, xm, y0, ym, z0, zm]`: Specific thicknesses for the 6 boundaries. |
+| **`model_gradient_sampling_interval`**| `int` | Scalar | Wavefield sampling interval during forward propagation (Default: 1).<br>A larger integer reduces the VRAM usage for the saved `Eall` tensor, but may decrease the accuracy of backpropagated gradients. |
+| **`use_async_offload`** | `bool` | Scalar | VRAM optimization flag (Default: `False`).<br>If `True`, the internal full wavefield tensor (`Eall`) is asynchronously offloaded to page-locked host memory (`pin_memory` CPU RAM). This drastically reduces GPU VRAM consumption at the cost of slightly slower computation times due to PCIe data transfer latency. |
+
+### 5. Field Variable States (Checkpoints / Initial Fields)
+
+For starting a forward simulation from scratch ($t=0$), these three parameters should be passed as `None` (the system will automatically initialize zero-tensors).
+
+| Parameter | Data Type | Shape | Description |
+| :--- | :--- | :--- | :--- |
+| **`E`** | `tuple` / `None` | 3 Tensors | Initial state of the electric field components `(Ex, Ey, Ez)`. Each tensor shape is `(nstep, nx+1, ny+1, nz+1)`. |
+| **`H`** | `tuple` / `None` | 3 Tensors | Initial state of the magnetic field components `(Hx, Hy, Hz)`. Shapes identical to `E`. |
+| **`PML`** | `tuple` / `None` | 24 Tensors | Auxiliary state variables ($\Phi$ fields) for the PML boundary updates. |
+
+---
+
+## 📤 Return Values
+
+The function returns a tuple of 5 elements. These are used to extract synthetic data, initiate the gradient flow for backpropagation, or serve as initial parameters (`E`, `H`, `PML`) for subsequent time-stepped calculations.
+
+```python
+return Eall, (Ex, Ey, Ez), (Hx, Hy, Hz), (x0EPhi1...zmHPhi2), receiver_amplitudes
+```
+
+1.  **`Eall`**: The global electric field history saved for gradient calculation.
+    *   **Shape**: `(nt_saved, nstep, nx, ny, nz)` (where `nt_saved` depends on `nt` and `model_gradient_sampling_interval`).
+2.  **`(Ex, Ey, Ez)`**: The 3D electric field state at the final time step. 
+3.  **`(Hx, Hy, Hz)`**: The 3D magnetic field state at the final time step.
+4.  **`(PML_Tuple)`**: A tuple of 24 Tensors recording the final time step state of the PML auxiliary $\Phi$ variables.
+5.  **`receiver_amplitudes`**: **The core output.** The waveform signals recorded by the receivers over the entire simulation time.
+    *   **Shape**: `(nstep, nt, nrx)`
+    *   **Meaning**: `[Shot Index, Time Step, Receiver Index]`. Note that this output is already sliced to extract only the component specified by `reciever_direction`.
+
+
+# Cite information
+If you find our codes useful, please kindly cite this article. Thanks.
+
+@article{liu2026fast,
+
+  title={Fast ground penetrating radar dual-parameter full waveform inversion method accelerated by hybrid compilation of CUDA kernel function and PyTorch},
+
+  author={Liu, Lei and Song, Chao and He, Liangsheng and Wang, Silin and Feng, Xuan and Liu, Cai},
+  journal={Computers \& Geosciences},
+
+  pages={106101},
+
+  year={2026},
+
+  publisher={Elsevier}
+
+}

deepgpr-0.0.9/pyproject.toml

@@ -0,0 +1,48 @@
+[build-system]
+requires = ["setuptools>=70", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "DeepGPR"
+version = "0.0.9"
+authors = [
+    { name = "Lei Liu", email = "liulei990222@gmail.com" }
+]
+description = "PyTorch and CUDA for GPR FWI"
+readme = "README.md"
+requires-python = ">=3.8"
+
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: Microsoft :: Windows",
+    "Operating System :: POSIX :: Linux",
+    "Topic :: Scientific/Engineering",
+    "Topic :: Scientific/Engineering :: Physics"
+]
+
+dependencies = [
+    "numpy",
+    "scipy",
+    "matplotlib",
+    "torch"
+]
+
+[tool.setuptools]
+package-dir = { "" = "src" }
+include-package-data = true
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+DeepGPR = [
+    "lib/*.cu",
+    "lib/*.cuh",
+    "lib/*.h",
+    "lib/*.hpp",
+    "lib/*.cpp",
+    "lib/*.c",
+    "lib/*.dll",
+    "lib/*.so",
+    "lib/*.pyd"
+]

deepgpr-0.0.9/setup.cfg

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

deepgpr-0.0.9/src/DeepGPR/__init__.py

@@ -0,0 +1,140 @@
+import ctypes
+import os
+import subprocess
+import platform
+from pathlib import Path
+
+
+system_name = platform.system()
+lib_dir = Path(__file__).parent / 'lib'
+cu_file = lib_dir / 'deepgpr.cu'
+
+if system_name == "Windows":
+    lib_extension = ".dll"
+    lib_filename = f'deepgpr{lib_extension}'
+    lib_path_obj = lib_dir / lib_filename
+    
+    nvcc_cmd = [
+        'nvcc', '-shared', 
+        '-o', str(lib_path_obj), 
+        str(cu_file)
+    ]
+else:
+    lib_extension = ".so"
+    lib_filename = f'deepgpr{lib_extension}'
+    lib_path_obj = lib_dir / lib_filename
+    
+    nvcc_cmd = [
+        'nvcc', '-shared', '-Xcompiler', '-fPIC', 
+        '-D_GLIBCXX_USE_CXX11_ABI=0', 
+        '-o', str(lib_path_obj), 
+        str(cu_file)
+    ]
+
+if not lib_path_obj.is_file():
+    print(f'Compiling CUDA extension for {system_name} directly via nvcc...')
+    try:
+        subprocess.run(nvcc_cmd, check=True)
+    except FileNotFoundError:
+        raise RuntimeError(
+            "Compilation failed: 'nvcc' command not found. "
+            "Please ensure NVIDIA CUDA Toolkit is installed and 'nvcc' is added to your system PATH."
+        )
+    except subprocess.CalledProcessError as e:
+        raise RuntimeError(f"Compilation failed with error code {e.returncode}.")
+
+lib_path = str(lib_path_obj)
+c_lib = ctypes.cdll.LoadLibrary(lib_path)
+
+
+c_lib.forward.argtypes = [
+    ctypes.POINTER(ctypes.c_float), ctypes.POINTER(ctypes.c_float), 
+    ctypes.POINTER(ctypes.c_float), ctypes.POINTER(ctypes.c_float), 
+    ctypes.POINTER(ctypes.c_float), ctypes.POINTER(ctypes.c_float),
+    ctypes.POINTER(ctypes.c_float), ctypes.POINTER(ctypes.c_float), 
+    ctypes.POINTER(ctypes.c_float),
+    ctypes.POINTER(ctypes.c_float),
+    ctypes.POINTER(ctypes.c_float), ctypes.POINTER(ctypes.c_float), 
+    ctypes.POINTER(ctypes.c_float), ctypes.POINTER(ctypes.c_float), 
+    ctypes.POINTER(ctypes.c_float), ctypes.POINTER(ctypes.c_float),
+    
+    ctypes.POINTER(ctypes.c_float), ctypes.POINTER(ctypes.c_float), 
+    ctypes.POINTER(ctypes.c_float), ctypes.POINTER(ctypes.c_float), 
+    ctypes.POINTER(ctypes.c_float), ctypes.POINTER(ctypes.c_float),
+    ctypes.POINTER(ctypes.c_float), ctypes.POINTER(ctypes.c_float), 
+    ctypes.POINTER(ctypes.c_float), ctypes.POINTER(ctypes.c_float), 
+    ctypes.POINTER(ctypes.c_float), ctypes.POINTER(ctypes.c_float),
+    ctypes.POINTER(ctypes.c_float), ctypes.POINTER(ctypes.c_float), 
+    ctypes.POINTER(ctypes.c_float), ctypes.POINTER(ctypes.c_float), 
+    ctypes.POINTER(ctypes.c_float), ctypes.POINTER(ctypes.c_float),
+    ctypes.POINTER(ctypes.c_float), ctypes.POINTER(ctypes.c_float), 
+    ctypes.POINTER(ctypes.c_float), ctypes.POINTER(ctypes.c_float), 
+    ctypes.POINTER(ctypes.c_float), ctypes.POINTER(ctypes.c_float),
+
+    ctypes.c_int, ctypes.c_int, ctypes.c_int, 
+    ctypes.c_int, ctypes.c_int, ctypes.c_int, 
+
+    ctypes.POINTER(ctypes.c_float), ctypes.POINTER(ctypes.c_float), 
+    ctypes.POINTER(ctypes.c_float), ctypes.POINTER(ctypes.c_float), 
+    ctypes.POINTER(ctypes.c_float), ctypes.POINTER(ctypes.c_float),
+    ctypes.POINTER(ctypes.c_float), ctypes.POINTER(ctypes.c_float), 
+    ctypes.POINTER(ctypes.c_float), ctypes.POINTER(ctypes.c_float), 
+    ctypes.POINTER(ctypes.c_float), ctypes.POINTER(ctypes.c_float),
+    
+    ctypes.c_float,ctypes.c_int,ctypes.c_int,ctypes.c_int,ctypes.c_float,
+    ctypes.POINTER(ctypes.c_int), ctypes.POINTER(ctypes.c_float),
+    ctypes.c_int, ctypes.c_int, ctypes.c_int, ctypes.c_int, 
+    ctypes.POINTER(ctypes.c_int), ctypes.POINTER(ctypes.c_float),
+    ctypes.c_int, ctypes.c_int
+]
+c_lib.forward.restype = None  
+
+c_lib.backward.argtypes = [
+    ctypes.POINTER(ctypes.c_float), ctypes.POINTER(ctypes.c_float), 
+    ctypes.POINTER(ctypes.c_float), ctypes.POINTER(ctypes.c_float), 
+    ctypes.POINTER(ctypes.c_float), ctypes.POINTER(ctypes.c_float),
+    ctypes.POINTER(ctypes.c_float), ctypes.POINTER(ctypes.c_float), 
+    ctypes.POINTER(ctypes.c_float),
+    ctypes.POINTER(ctypes.c_float),
+    ctypes.POINTER(ctypes.c_float), ctypes.POINTER(ctypes.c_float), 
+    ctypes.POINTER(ctypes.c_float), ctypes.POINTER(ctypes.c_float), 
+    ctypes.POINTER(ctypes.c_float), ctypes.POINTER(ctypes.c_float),#16
+    
+    ctypes.POINTER(ctypes.c_float), ctypes.POINTER(ctypes.c_float), 
+    ctypes.POINTER(ctypes.c_float), ctypes.POINTER(ctypes.c_float), 
+    ctypes.POINTER(ctypes.c_float), ctypes.POINTER(ctypes.c_float),
+    ctypes.POINTER(ctypes.c_float), ctypes.POINTER(ctypes.c_float), 
+    ctypes.POINTER(ctypes.c_float), ctypes.POINTER(ctypes.c_float), 
+    ctypes.POINTER(ctypes.c_float), ctypes.POINTER(ctypes.c_float),
+    ctypes.POINTER(ctypes.c_float), ctypes.POINTER(ctypes.c_float), 
+    ctypes.POINTER(ctypes.c_float), ctypes.POINTER(ctypes.c_float), 
+    ctypes.POINTER(ctypes.c_float), ctypes.POINTER(ctypes.c_float),
+    ctypes.POINTER(ctypes.c_float), ctypes.POINTER(ctypes.c_float), 
+    ctypes.POINTER(ctypes.c_float), ctypes.POINTER(ctypes.c_float), 
+    ctypes.POINTER(ctypes.c_float), ctypes.POINTER(ctypes.c_float),#40
+
+    ctypes.c_int, ctypes.c_int, ctypes.c_int, 
+    ctypes.c_int, ctypes.c_int, ctypes.c_int, 
+
+    ctypes.POINTER(ctypes.c_float), ctypes.POINTER(ctypes.c_float), 
+    ctypes.POINTER(ctypes.c_float), ctypes.POINTER(ctypes.c_float), 
+    ctypes.POINTER(ctypes.c_float), ctypes.POINTER(ctypes.c_float),
+    ctypes.POINTER(ctypes.c_float), ctypes.POINTER(ctypes.c_float), 
+    ctypes.POINTER(ctypes.c_float), ctypes.POINTER(ctypes.c_float), 
+    ctypes.POINTER(ctypes.c_float), ctypes.POINTER(ctypes.c_float), #58
+    
+    ctypes.c_float,ctypes.c_int,ctypes.c_int,ctypes.c_int,ctypes.c_float,
+    ctypes.c_int, ctypes.c_int, ctypes.c_int, ctypes.c_int, 
+    ctypes.POINTER(ctypes.c_int), ctypes.POINTER(ctypes.c_float),
+    ctypes.c_int ,ctypes.POINTER(ctypes.c_float), ctypes.POINTER(ctypes.c_float),
+    ctypes.c_int, ctypes.c_int , ctypes.c_int 
+]
+
+c_lib.backward.restype = None 
+__all__ = ['c_lib']
+
+
+from .common import *
+from .compute2 import *
+from .multiscale import *
+from .wavelet import *

{deepgpr-0.0.8 → deepgpr-0.0.9}/src/DeepGPR/lib/deepgpr.cu

@@ -2,13 +2,6 @@
 #include <iostream>
 #include <stdio.h>
 #include <cfloat>
-#include <cstdlib>
-
-#ifdef _WIN32
-#define DEEPGPR_API extern "C" __declspec(dllexport)
-#else
-#define DEEPGPR_API extern "C" __attribute__((visibility("default")))
-#endif
 
 __constant__ float e0 = 8.8541878128e-12;
 __constant__ float m0 = 1.25663706212e-06;
@@ -605,7 +598,9 @@ __global__ void accumulate_gradients(
 }
 
 
-DEEPGPR_API void forward(const float* __restrict__ er, const float* __restrict__ se, const float* __restrict__ mr,  
+extern "C" {
+
+void forward(const float* __restrict__ er, const float* __restrict__ se, const float* __restrict__ mr,  
              float* __restrict__ Eall_ptr, 
              float* __restrict__ Ex,  float* __restrict__ Ey, float* __restrict__ Ez,  
              float* __restrict__ Hx, float* __restrict__ Hy,  float* __restrict__ Hz,
@@ -707,7 +702,7 @@ DEEPGPR_API void forward(const float* __restrict__ er, const float* __restrict__
     }
 }
 
-DEEPGPR_API void backward(const float* __restrict__ er, const float* __restrict__ se, const float* __restrict__ mr,  
+void backward(const float* __restrict__ er, const float* __restrict__ se, const float* __restrict__ mr,  
              const float* __restrict__ Eall_ptr,
              float* __restrict__ Ex,  float* __restrict__ Ey, float* __restrict__ Ez,  
              float* __restrict__ Hx, float* __restrict__ Hy,  float* __restrict__ Hz,
@@ -820,4 +815,6 @@ DEEPGPR_API void backward(const float* __restrict__ er, const float* __restrict_
         cudaStreamDestroy(stream_comp);
         cudaStreamDestroy(stream_trans);
     }
+}
+
 }

{deepgpr-0.0.8 → deepgpr-0.0.9/src/DeepGPR.egg-info}/PKG-INFO

@@ -1,16 +1,19 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: DeepGPR
-Version: 0.0.8
+Version: 0.0.9
 Summary: PyTorch and CUDA for GPR FWI
-Author-Email: Lei Liu <liulei990222@gmail.com>
+Author-email: Lei Liu <liulei990222@gmail.com>
 Classifier: Programming Language :: Python :: 3
 Classifier: Operating System :: Microsoft :: Windows
 Classifier: Operating System :: POSIX :: Linux
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Physics
 Requires-Python: >=3.8
+Description-Content-Type: text/markdown
 Requires-Dist: numpy
 Requires-Dist: scipy
 Requires-Dist: matplotlib
-Description-Content-Type: text/markdown
+Requires-Dist: torch
 
 # DeepGPR
 
@@ -33,40 +36,10 @@ Supports techniques such as checkpointing, DDP, and the utilization of CPU memor
 ## System Requirements
 
 - **OS**: Linux and Windows
-- **Python**: Python 3.8+
-- **GPU**: NVIDIA GPU with sufficient VRAM for 2D/3D computational grids
-- **CUDA**: NVIDIA driver and CUDA Toolkit
-- **Libraries**:
-  - `torch` with CUDA support
-  - `numpy`
-  - `scipy`
-  - `matplotlib`
-
-### Additional Requirements for Building from Source
-
-DeepGPR contains a CUDA backend that is compiled during installation. Therefore, users who install the package from source need a working CUDA/C++ build environment.
-
-#### Linux
-
-- CUDA Toolkit with `nvcc`
-- GCC/G++ compiler compatible with the installed CUDA version
-- CMake 3.23 or later
+- **Environment**: Python 3.8+, CUDA Toolkit 
+- **Libraries**: `torch` (with CUDA support), `numpy`, `scipy`, `matplotlib`
+- **Hardware**: NVIDIA GPU with sufficient VRAM for 3D computational grids.
 
-#### Windows
-
-- CUDA Toolkit with `nvcc`
-- CMake 3.23 or later
-- Microsoft Visual Studio Build Tools or Visual Studio Community
-- The **Desktop development with C++** workload
-- MSVC C++ compiler `cl.exe`
-- Windows SDK
-- Optional: `ninja`
-
-On Windows, `nvcc` relies on the MSVC compiler to build CUDA code. Please make sure that both `nvcc` and `cl.exe` are available before running:
-
-```bash
-pip install .
-```
 
 ## Start
 
@@ -258,4 +231,4 @@ If you find our codes useful, please kindly cite this article. Thanks.
 
   publisher={Elsevier}
 
-}
+}

deepgpr-0.0.9/src/DeepGPR.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+README.md
+pyproject.toml
+src/DeepGPR/__init__.py
+src/DeepGPR/common.py
+src/DeepGPR/compute2.py
+src/DeepGPR/multiscale.py
+src/DeepGPR/wavelet.py
+src/DeepGPR.egg-info/PKG-INFO
+src/DeepGPR.egg-info/SOURCES.txt
+src/DeepGPR.egg-info/dependency_links.txt
+src/DeepGPR.egg-info/requires.txt
+src/DeepGPR.egg-info/top_level.txt
+src/DeepGPR/lib/deepgpr.cu
+src/DeepGPR/lib/deepgpr.so

deepgpr-0.0.9/src/DeepGPR.egg-info/requires.txt

@@ -0,0 +1,4 @@
+numpy
+scipy
+matplotlib
+torch

deepgpr-0.0.9/src/DeepGPR.egg-info/top_level.txt

@@ -0,0 +1 @@
+DeepGPR

deepgpr-0.0.8/.gitignore

@@ -1,7 +0,0 @@
-lib/deepgpr.so
-__pycache__/
-dist/
-build/
-.vscode/
-*.egg-info/
-pyproject.toml