move Datasets Construction Details to Github

Datasets-Construction/OpenSWI-deep/1s-100s-Aug/vs_demo.txt

@@ -1,301 +0,0 @@
-0.0000 3.1342
-1.0000 3.1342
-2.0000 3.1342
-3.0000 3.1342
-4.0000 3.1342
-5.0000 3.1342
-6.0000 3.1345
-7.0000 3.1345
-8.0000 3.1345
-9.0000 3.1345
-10.0000 3.1345
-11.0000 3.1345
-12.0000 3.1345
-13.0000 3.1345
-14.0000 3.1345
-15.0000 3.1345
-16.0000 3.9061
-17.0000 3.9061
-18.0000 3.9061
-19.0000 3.9061
-20.0000 3.9061
-21.0000 3.9061
-22.0000 3.9061
-23.0000 3.9061
-24.0000 3.9061
-25.0000 3.9061
-26.0000 4.3299
-27.0000 4.3299
-28.0000 4.3299
-29.0000 4.3299
-30.0000 4.3299
-31.0000 4.3299
-32.0000 4.3299
-33.0000 4.3299
-34.0000 4.3299
-35.0000 4.3299
-36.0000 4.4193
-37.0000 4.4193
-38.0000 4.4193
-39.0000 4.4193
-40.0000 4.4193
-41.0000 4.4193
-42.0000 4.4193
-43.0000 4.4193
-44.0000 4.4193
-45.0000 4.4193
-46.0000 4.4396
-47.0000 4.4396
-48.0000 4.4396
-49.0000 4.4396
-50.0000 4.4396
-51.0000 4.4396
-52.0000 4.4396
-53.0000 4.4396
-54.0000 4.4396
-55.0000 4.4396
-56.0000 4.4369
-57.0000 4.4369
-58.0000 4.4369
-59.0000 4.4369
-60.0000 4.4369
-61.0000 4.4369
-62.0000 4.4369
-63.0000 4.4369
-64.0000 4.4369
-65.0000 4.4369
-66.0000 4.4306
-67.0000 4.4306
-68.0000 4.4306
-69.0000 4.4306
-70.0000 4.4306
-71.0000 4.4306
-72.0000 4.4306
-73.0000 4.4306
-74.0000 4.4306
-75.0000 4.4306
-76.0000 4.4185
-77.0000 4.4185
-78.0000 4.4185
-79.0000 4.4185
-80.0000 4.4185
-81.0000 4.4185
-82.0000 4.4185
-83.0000 4.4185
-84.0000 4.4185
-85.0000 4.4185
-86.0000 4.4073
-87.0000 4.4073
-88.0000 4.4073
-89.0000 4.4073
-90.0000 4.4073
-91.0000 4.4073
-92.0000 4.4073
-93.0000 4.4073
-94.0000 4.4073
-95.0000 4.4073
-96.0000 4.3917
-97.0000 4.3917
-98.0000 4.3917
-99.0000 4.3917
-100.0000 4.3917
-101.0000 4.3917
-102.0000 4.3917
-103.0000 4.3917
-104.0000 4.3917
-105.0000 4.3917
-106.0000 4.3728
-107.0000 4.3728
-108.0000 4.3728
-109.0000 4.3728
-110.0000 4.3728
-111.0000 4.3728
-112.0000 4.3728
-113.0000 4.3728
-114.0000 4.3728
-115.0000 4.3728
-116.0000 4.3649
-117.0000 4.3649
-118.0000 4.3649
-119.0000 4.3649
-120.0000 4.3649
-121.0000 4.3649
-122.0000 4.3649
-123.0000 4.3649
-124.0000 4.3649
-125.0000 4.3649
-126.0000 4.3397
-127.0000 4.3397
-128.0000 4.3397
-129.0000 4.3397
-130.0000 4.3397
-131.0000 4.3397
-132.0000 4.3397
-133.0000 4.3397
-134.0000 4.3397
-135.0000 4.3397
-136.0000 4.3209
-137.0000 4.3209
-138.0000 4.3209
-139.0000 4.3209
-140.0000 4.3209
-141.0000 4.3209
-142.0000 4.3209
-143.0000 4.3209
-144.0000 4.3209
-145.0000 4.3209
-146.0000 4.3034
-147.0000 4.3034
-148.0000 4.3034
-149.0000 4.3034
-150.0000 4.3034
-151.0000 4.3034
-152.0000 4.3034
-153.0000 4.3034
-154.0000 4.3034
-155.0000 4.3034
-156.0000 4.2835
-157.0000 4.2835
-158.0000 4.2835
-159.0000 4.2835
-160.0000 4.2835
-161.0000 4.2835
-162.0000 4.2835
-163.0000 4.2835
-164.0000 4.2835
-165.0000 4.2835
-166.0000 4.2605
-167.0000 4.2605
-168.0000 4.2605
-169.0000 4.2605
-170.0000 4.2605
-171.0000 4.2605
-172.0000 4.2605
-173.0000 4.2605
-174.0000 4.2605
-175.0000 4.2605
-176.0000 4.2465
-177.0000 4.2465
-178.0000 4.2465
-179.0000 4.2465
-180.0000 4.2465
-181.0000 4.2465
-182.0000 4.2465
-183.0000 4.2465
-184.0000 4.2465
-185.0000 4.2465
-186.0000 4.2476
-187.0000 4.2476
-188.0000 4.2476
-189.0000 4.2476
-190.0000 4.2476
-191.0000 4.2476
-192.0000 4.2476
-193.0000 4.2476
-194.0000 4.2476
-195.0000 4.2476
-196.0000 4.4260
-197.0000 4.4260
-198.0000 4.4260
-199.0000 4.4260
-200.0000 4.4260
-201.0000 4.4260
-202.0000 4.4260
-203.0000 4.4260
-204.0000 4.4260
-205.0000 4.4260
-206.0000 4.2914
-207.0000 4.2914
-208.0000 4.2914
-209.0000 4.2914
-210.0000 4.2914
-211.0000 4.2914
-212.0000 4.2914
-213.0000 4.2914
-214.0000 4.2914
-215.0000 4.2914
-216.0000 4.3180
-217.0000 4.3180
-218.0000 4.3180
-219.0000 4.3180
-220.0000 4.3180
-221.0000 4.3180
-222.0000 4.3180
-223.0000 4.3180
-224.0000 4.3180
-225.0000 4.3180
-226.0000 4.3433
-227.0000 4.3433
-228.0000 4.3433
-229.0000 4.3433
-230.0000 4.3433
-231.0000 4.3433
-232.0000 4.3433
-233.0000 4.3433
-234.0000 4.3433
-235.0000 4.3433
-236.0000 4.3661
-237.0000 4.3661
-238.0000 4.3661
-239.0000 4.3661
-240.0000 4.3661
-241.0000 4.3661
-242.0000 4.3661
-243.0000 4.3661
-244.0000 4.3661
-245.0000 4.3661
-246.0000 4.3956
-247.0000 4.3956
-248.0000 4.3956
-249.0000 4.3956
-250.0000 4.3956
-251.0000 4.3956
-252.0000 4.3956
-253.0000 4.3956
-254.0000 4.3956
-255.0000 4.3956
-256.0000 4.4230
-257.0000 4.4230
-258.0000 4.4230
-259.0000 4.4230
-260.0000 4.4230
-261.0000 4.4230
-262.0000 4.4230
-263.0000 4.4230
-264.0000 4.4230
-265.0000 4.4230
-266.0000 4.4492
-267.0000 4.4492
-268.0000 4.4492
-269.0000 4.4492
-270.0000 4.4492
-271.0000 4.4492
-272.0000 4.4492
-273.0000 4.4492
-274.0000 4.4492
-275.0000 4.4492
-276.0000 4.4802
-277.0000 4.4802
-278.0000 4.4802
-279.0000 4.4802
-280.0000 4.4802
-281.0000 4.4802
-282.0000 4.4802
-283.0000 4.4802
-284.0000 4.4802
-285.0000 4.4802
-286.0000 4.5075
-287.0000 4.5075
-288.0000 4.5075
-289.0000 4.5075
-290.0000 4.5075
-291.0000 4.5075
-292.0000 4.5075
-293.0000 4.5075
-294.0000 4.5075
-295.0000 4.5075
-296.0000 4.5413
-297.0000 4.5413
-298.0000 4.5413
-299.0000 4.5413
-300.0000 4.5413

Datasets-Construction/OpenSWI-shallow/0.2-10s-Aug/vp_demo.txt

@@ -1,70 +0,0 @@
-0.0000 1.5870
-0.0400 1.5870
-0.0800 1.5870
-0.1200 1.5870
-0.1600 1.5870
-0.2000 1.5870
-0.2400 1.5870
-0.2800 1.5870
-0.3200 2.1660
-0.3600 2.1660
-0.4000 2.1660
-0.4400 2.1660
-0.4800 2.1660
-0.5200 2.1660
-0.5600 2.1660
-0.6000 2.1660
-0.6400 2.1660
-0.6800 2.7230
-0.7200 2.7230
-0.7600 2.7230
-0.8000 2.7230
-0.8400 2.7230
-0.8800 2.7230
-0.9200 2.7230
-0.9600 2.7230
-1.0000 2.7230
-1.0400 2.7230
-1.0800 2.7230
-1.1200 2.9820
-1.1600 2.9820
-1.2000 2.9820
-1.2400 2.9820
-1.2800 2.9820
-1.3200 2.9820
-1.3600 2.9820
-1.4000 2.9820
-1.4400 2.9820
-1.4800 3.0040
-1.5200 3.0040
-1.5600 3.0040
-1.6000 3.0040
-1.6400 3.0040
-1.6800 3.0040
-1.7200 3.0040
-1.7600 3.0040
-1.8000 3.0040
-1.8400 3.0180
-1.8800 3.0180
-1.9200 3.0180
-1.9600 3.0180
-2.0000 3.0180
-2.0400 3.0180
-2.0800 3.0180
-2.1200 3.0180
-2.1600 3.0180
-2.2000 3.0180
-2.2400 3.0180
-2.2800 3.7610
-2.3200 3.7610
-2.3600 3.7610
-2.4000 3.7610
-2.4400 3.7610
-2.4800 3.7610
-2.5200 3.7610
-2.5600 3.7610
-2.6000 3.7610
-2.6400 4.4770
-2.6800 4.4770
-2.7200 4.4770
-2.7600 4.4770

SWIDP/README.md

@@ -1,180 +0,0 @@
-## [SWIDP: Integrated Workflow for Dataset Construction](../SWIDP/)  
-
-SWIDP provides a fully modular pipeline for constructing large-scale surface-wave dispersion curve datasets:  
-
-1. **Collect and standardize geological models**  
-   Aggregate 2D/3D geological–geomorphological models from public databases and literature, and unify data format through cleaning, parameter conversion, and normalization.  
-
-2. **Build 1D velocity models**  
-   Extract representative 1D shear-wave velocity profiles, de-duplicate, optimize thin layers, interpolate to uniform thickness, and complete missing parameters (e.g., \(v_p\), density).  
-
-3. **Augment for geological diversity**  
-   Apply perturbation-based and generative-model-based enhancements to improve geological diversity and boundary complexity coverage.  
-
-4. **Forward modeling of dispersion curves**  
-   Efficiently compute large-scale surface-wave dispersion curves (using an optimized **Disba**-based solver with parallelization) across diverse period ranges.  
-
-```mermaid
-flowchart LR
-    A[Collect & Standardize Geological Models] --> B[Build 1D Velocity Models]
-    B --> C[Augment for Geological Diversity]
-    C --> D[Forward Modeling of Dispersion Curves]
-```
-
----
-
-### Example 1: Building the **OpenSWI-shallow** Dataset
-
-```python
-import numpy as np
-import sys
-sys.path.append("OpenSWI/Datasets/OpenSWI/")
-from SWIDP.process_1d_shallow import augment_workflow
-from SWIDP.dispersion import (
-    generate_mixed_samples, calculate_dispersion,
-    transform_vp_to_vs, transform_vs_to_vel_model
-)
-from p_tqdm import p_map
-
-# Step 1: Load 1D velocity model n x (depth, vp)
-depth_vp = np.loadtxt(
-    "./OpenSWI/Datasets/OpenSWI/Datasets-Construction/OpenSWI-shallow/0.2-10s-Aug/vp_demo.txt"
-)
-depth = depth_vp[:, 0]
-vp = depth_vp[:, 1]
-
-# Step 2: Convert vp to vs
-vs = transform_vp_to_vs(vp)
-
-# Step 3: Augment vs models
-augment_nums = 100
-vs_augmented = augment_workflow(
-    vs, depth,
-    perturb_num=augment_nums,
-    vs_perturbation=0.05,           # relative ratio
-    thickness_perturbation=0.1,     # relative ratio
-    vel_threshold=0.05,             # km/s
-    thickness_threshold=0.01,       # km
-    min_layers_num=3,
-    smooth_vel=False,
-    smooth_nodes=10
-)
-
-# Step 4: Build full velocity models (depth, vp, vs, rho)
-vel_model_augmented = p_map(
-    transform_vs_to_vel_model,
-    list(vs_augmented),
-    [depth] * len(vs_augmented)
-)
-
-# Step 5: Generate dispersion curves [t, phase velocity, group velocity]
-t = generate_mixed_samples(
-    num_samples=100, start=0.2, end=10,
-    uniform_num=50, log_num=20, random_num=30
-)
-disp = p_map(
-    calculate_dispersion,
-    vel_model_augmented,
-    [t] * len(vel_model_augmented)
-)
-```
-
-Details of this example can be found at
-
-| Dataset Type    | Description                         | Link                                                                                      |
-|-----------------|-------------------------------------|-------------------------------------------------------------------------------------------|
-| **OpenSWI-shallow Example** | Example notebook for the OpenSWI dataset | [OpenSWI-shallow-example.ipynb](../Datasets-Construction/OpenSWI-shallow/0.2-10s-Aug/00_OpenSWI-shallow-example.ipynb) |
-| **Flat**        | Flat velocity model construction    | [OpenFWI-FlatVel-A.ipynb](../Datasets-Construction/OpenSWI-shallow/0.2-10s-Aug/01_1_OpenFWI-FlatVel-A.ipynb) |
-| **Flat-Fault**  | Flat velocity model with fault      | [OpenFWI-FlatFault-A.ipynb](../Datasets-Construction/OpenSWI-shallow/0.2-10s-Aug/01_2_OpenFWI-FlatFault-A.ipynb) |
-| **Fold**        | Fold velocity model construction    | [OpenFWI-CurveVel-A.ipynb](../Datasets-Construction/OpenSWI-shallow/0.2-10s-Aug/01_3_OpenFWI-CurveVel-A.ipynb) |
-| **Fold-Fault**  | Fold velocity model with fault      | [OpenFWI-CurveFault-A.ipynb](../Datasets-Construction/OpenSWI-shallow/0.2-10s-Aug/01_4_OpenFWI-CurveFault-A.ipynb) |
-| **Field**       | Field data modeling                 | [OpenFWI-Style-A.ipynb](../Datasets-Construction/OpenSWI-shallow/0.2-10s-Aug/01_5_OpenFWI-Style-A.ipynb) |
-
-
----
-
-### Example 2: Building the **OpenSWI-deep** Dataset
-
-```python
-import numpy as np
-import sys
-sys.path.append("../../../")
-from SWIDP.process_1d_deep import *
-from SWIDP.dispersion import generate_mixed_samples,calculate_dispersion,transform_vs_to_vel_model
-from p_tqdm import p_map
-
-# step1: get 1d velocity model (vp model or vs)
-depth_vs = np.loadtxt("../Datasets-Construction/OpenSWI-deep/1s-100s-Aug/vs_demo.txt")
-depth = depth_vs[:,0]
-vs = depth_vs[:,1]
-
-# step2-1: remove the thin sandwidth layer
-vs = combine_thin_sandwich(vs,
-                            depth,
-                            thickness_threshold=12, # km
-                            uniform_thickness=1,    # km (thickness_threshold/uniform_thickness) = max_check_layers
-                            gradient_threshold=0.05, # km/s (gradient_threshold)
-                            return_idx=False
-                            )
-
-# step2-2: smooth the vs model (selectable)
-vs = smooth_vs_by_node_interp(vs,
-                            depth,
-                            n_nodes=20,
-                            method="pchip"
-                            )
-
-# step3: find moho index
-moho_idx = find_moho_depth(vs,
-                           depth,
-                           [5,90], # range of moho index
-                           gradient_search=False,
-                           gradient_threshold=0.01)
-
-# step4: augment the vs model
-perturb_nums = 100
-vs_augmented = p_map(augment_crust_moho_mantle,
-                    [vs]*perturb_nums,
-                    list(depth.reshape(1,-1))*perturb_nums,
-                    [moho_idx]*perturb_nums,
-                    [[-0.1,0.1]]*perturb_nums, # relative ratio
-                    [[3,8]]*perturb_nums,     # nodes for crust
-                    [[8,15]]*perturb_nums,   # nodes for mantle
-                    [3]*perturb_nums,          # km 
-                    [2]*perturb_nums,     # km
-                    [False]*perturb_nums,
-                    np.random.randint(0,1000000,perturb_nums)
-                    )
-
-# step5: transform the vs model to vp model
-vel_models = p_map(transform_vs_to_vel_model,list(vs_augmented),[depth]*len(vs_augmented))
-
-# step6: calculate the dispersion curve
-t = generate_mixed_samples(num_samples=300,start=1,end=100,uniform_num=100,log_num=100,random_num=100)
-t = np.ones((len(vel_models),len(t)))*t
-disp_data = p_map(calculate_dispersion, vel_models, list(t))
-disp_data = np.array(disp_data)
-vel_models = np.array(vel_models)
-
-```
-Details of this example can be found at:
-
-| Dataset Name               | Reference                                                                                   | Link                                                                                       |
-|----------------------------|---------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------|
-| OpenSWI-deep-example        | -                                                                                           | [OpenSWI-deep-example.ipynb](../Datasets-Construction/OpenSWI-deep/1s-100s-Aug/00_OpenSWI-deep-example.ipynb) |
-| LITHO1.0                   | Pasyanos et al., 2014                                                                        | [LITHO1.0](../Datasets-Construction/OpenSWI-deep/1s-100s-Aug/12_LITHO1.ipynb) |
-| USTClitho1.0               | Xin et al., 2018                                                                             | [USTClitho1.0](../Datasets-Construction/OpenSWI-deep/1s-100s-Aug/11_USTCLitho1.ipynb) |
-| Central-and-Western US     | Shen et al., 2013                                                                            | [Central-and-Western US](../Datasets-Construction/OpenSWI-deep/1s-100s-Aug/13_Central_and_Western_US_Shen2013.ipynb) |
-| Continental China          | Shen et al., 2016                                                                            | [Continental China](../Datasets-Construction/OpenSWI-deep/1s-100s-Aug/14_Continental_China_Shen2016.ipynb) |
-| US Upper-Mantle            | Xie et al., 2018                                                                              | [US Upper-Mantle](../Datasets-Construction/OpenSWI-deep/1s-100s-Aug/03_US-upper-mantle.ipynb) |
-| EUCrust                    | Lu et al., 2018                                                                               | [EUCrust](../Datasets-Construction/OpenSWI-deep/1s-100s-Aug/05_EUCrust.ipynb) |
-| Alaska                     | Berg et al., 2020                                                                             | [Alaska](../Datasets-Construction/OpenSWI-deep/1s-100s-Aug/04_Alaska.ipynb) |
-| CSEM-Europe                | Blom et al., 2020; Fichtner et al., 2018; Çubuk-Sabuncu et al., 2017                         | [CSEM-Europe](../Datasets-Construction/OpenSWI-deep/1s-100s-Aug/02_CSEM_Europe.ipynb) |
-| CSEM-Eastmed               | Blom et al., 2020; Fichtner et al., 2018                                                     | [CSEM-Eastmed](../Datasets-Construction/OpenSWI-deep/1s-100s-Aug/01_CSEM_Eastmed.ipynb) |
-| CSEM-Iberian               | Fichtner et al., 2018; Fichtner et al., 2015                                                 | [CSEM-Iberian](../Datasets-Construction/OpenSWI-deep/1s-100s-Aug/09_CSEM_lberia.ipynb) |
-| CSEM-South Atlantic        | Fichtner et al., 2018; Colli et al., 2013                                                   | [CSEM-South Atlantic](../Datasets-Construction/OpenSWI-deep/1s-100s-Aug/07_CSEM_North_Atlantic.ipynb) |
-| CSEM-North Atlantic        | Fichtner et al., 2018; Krischer et al., 2018                                                | [CSEM-North Atlantic](../Datasets-Construction/OpenSWI-deep/1s-100s-Aug/07_CSEM_North_Atlantic.ipynb) |
-| CSEM-Japan                 | Fichtner et al., 2018; Simutė et al., 2016                                                 | [CSEM-Japan](../Datasets-Construction/OpenSWI-deep/1s-100s-Aug/08_CSEM_Japan.ipynb) |
-| CSEM-Australasia           | Fichtner et al., 2018; Fichtner et al., 2010                                               | [CSEM-Australasia](../Datasets-Construction/OpenSWI-deep/1s-100s-Aug/10_CSEM_Australasia.ipynb) |
-
-----

SWIDP/diffusion_aug_2d.py

@@ -1,298 +0,0 @@
-import numpy as np
-from SWIDP.process_1d_shallow import combine_same_vs, perturb_vs_depth, smooth_vs_by_node_interp
-from scipy.interpolate import interp1d
-
-# -------------------------------------------------------
-#  extract the 1D profile from the 2D model
-# -------------------------------------------------------
-def extract_1d_profile(vs_model,station_idx=None,method="mean"):
-    """extract the 1D profile from the 2D model
-    Args:
-        vs_model: 2D array [n_depth,n_x]
-            => shear velocity model
-        method: str
-            => method to extract the 1D profile
-    Returns:
-        vs_profile: 2D array [n_sta,n_depth]
-            => shear velocity profile
-    """    
-    if method == "mean":
-        vs_profile = np.mean(vs_model,axis=1)
-        vs_profile = vs_profile.reshape(1,-1)
-    elif method == "st" and isinstance(station_idx,int): # single station
-        vs_profile = vs_model[:,station_idx]
-        vs_profile = vs_profile.reshape(1,-1)
-    elif method == "mt" and isinstance(station_idx,list):
-        vs_profile = vs_model[:,station_idx]
-        vs_profile = vs_profile.T
-    elif method == "random": # random station
-        vs_profile = vs_model[:,np.random.randint(0,vs_model.shape[1])]
-        vs_profile = vs_profile.reshape(1,-1)
-    elif method == "all": # all stations
-        vs_profile = vs_model
-        vs_profile = vs_profile.T
-    else:
-        raise ValueError(f"Invalid method: {method}")
-    return vs_profile
-
-
-# -------------------------------------------------------
-#  normalize & denormalize the shear velocity
-# -------------------------------------------------------
-def max_min_normalize(vs):
-    """Normalize shear velocity.
-    Args:
-        vs: 1D array
-            => shear velocity (km/s)
-    Returns:
-        vs: 1D array
-            => normalized shear velocity (0-1)
-    """
-    vs = np.array(vs)
-    vs = (vs-np.min(vs))/(np.max(vs)-np.min(vs))
-    return vs
-
-def max_min_denormalize(vs, vmin=0.2, vmax=3.2):
-    """Denormalize shear velocity.
-    Args:
-        vs: 1D array
-            => normalized shear velocity (0-1)
-        vmin: float,
-            => minimum shear velocity (km/s)
-        vmax: float,
-            => maximum shear velocity (km/s)
-    Returns:
-        vs: 1D array
-            => shear velocity (km/s)
-    """
-    vs = np.array(vs)
-    # make sure the vs is normalized
-    vs = max_min_normalize(vs)
-
-    # denormalize to [vmin,vmax]
-    vs = vs*(vmax-vmin)+vmin
-    return vs
-
-# -------------------------------------------------------
-#  interpolate the shear velocity
-# -------------------------------------------------------
-def interpolate_vs(vs,depth,depth_interp,kind="previous"):
-    """interpolate the shear velocity
-    Args:
-        vs: 1D array
-            => shear velocity (km/s)
-    """
-    # padding the last layer of depth and vs larger than depth_interp
-    eps = 0.01
-    if depth.max() < depth_interp.max():
-        vs = np.insert(vs,len(vs),vs[-1])
-        depth = np.insert(depth,len(depth),depth_interp[-1]+eps)
-    elif depth.min() > depth_interp.min():
-        vs = np.insert(vs,0,vs[0])
-        depth = np.insert(depth,0,depth[0]-eps)
-    
-    # interpolate the shear velocity
-    f = interp1d(depth,vs,kind=kind)
-    vs_interp = f(depth_interp)
-    return vs_interp
-
-# -------------------------------------------------------
-#  extract 1D profile and interpolation
-# -------------------------------------------------------
-
-def diffusion_extract_process(vs_model,
-                              extract_station_idx=None,
-                              extract_method="mean",
-                              denorm_vmin_range=[0.2,0.5],
-                              denorm_vmax_range=[2.5,3.5],
-                              combine_vel_threshold=0.1,
-                              interp_depth=None,
-                              interp_kind="previous",
-                              smooth_vel=False,
-                              smooth_nodes=10,
-                              smooth_kind="pchip",
-                              ):
-    """diffusion extract process
-    Args:
-        vs_model: 2D array [n_depth,n_x]
-            => shear velocity model
-        extract_station_idx: int,
-            => station index
-        extract_method: str
-            => method to extract the 1D profile
-        denorm_vmin: float
-            => minimum shear velocity (km/s)
-        denorm_vmax: float
-            => maximum shear velocity (km/s)
-        combine_vel_threshold: float
-            => velocity threshold for combining the same vs
-        interp_depth: 1D array
-            => target depth for interpolation
-        interp_kind: str
-            => kind of interpolation
-        smooth_vel: bool
-            => whether to smooth the vs
-        smooth_nodes: int
-            => number of nodes for smoothing
-        smooth_kind: str
-            => kind of smoothing
-    Returns:
-        vs_aug: 2D array [n_sta,n_depth]
-            => extracted shear velocity
-        depth_aug: 2D array [n_sta,n_depth]
-            => extracted depth
-    """
-    # Step 1: extract the 1D profile
-    vs_profiles = extract_1d_profile(vs_model,extract_station_idx,extract_method)
-    depth = np.arange(vs_profiles.shape[-1])*0.04
-
-    if interp_depth is None:
-        interp_depth = depth
-
-    vs_aug,depth_aug = [],[]
-
-    for i in range(vs_profiles.shape[0]):
-        vs_profile = vs_profiles[i,:]
-
-        # Step 2: de-normalize the shear velocity
-        denorm_vmin = np.random.uniform(denorm_vmin_range[0],denorm_vmin_range[1])
-        denorm_vmax = np.random.uniform(denorm_vmax_range[0],denorm_vmax_range[1])
-        vs_denormed = max_min_denormalize(vs_profile,denorm_vmin,denorm_vmax)
-
-        # Step 3: combine the same vs
-        vs_combined,depth_combined = combine_same_vs(vs_denormed,depth,combine_vel_threshold)
-
-        # step 4: smooth the vs
-        if smooth_vel:
-            vs_smooth = smooth_vs_by_node_interp(vs_combined,depth_combined,n_nodes=smooth_nodes,method=smooth_kind)
-        else:
-            vs_smooth = vs_combined
-
-        # Step 5: interpolate the shear velocity
-        vs_interpolated = interpolate_vs(vs_smooth,depth_combined,interp_depth,interp_kind)
-
-        vs_aug.extend(vs_interpolated)
-        depth_aug.extend(interp_depth)
-
-    vs_aug = np.array(vs_aug).reshape(-1,len(interp_depth)) # [n_sta,n_depth]
-    depth_aug = np.array(depth_aug).reshape(-1,len(interp_depth)) # [n_sta,n_depth]
-    return vs_aug,depth_aug
-
-# -------------------------------------------------------
-#  augmentation 1D profile
-# -------------------------------------------------------
-
-def diffusion_aug_extract_process(vs_model,
-                                  extract_station_idx=None,
-                                  extract_method="mean",
-                                  denorm_vmin_range=[0.2,0.5],
-                                  denorm_vmax_range=[2.5,3.5],
-                                  combine_vel_threshold=0.1,
-                                  interp_depth=np.arange(70)*0.04,
-                                  interp_kind="previous",
-                                  smooth_vel=False,
-                                  smooth_nodes=10,
-                                  smooth_kind="pchip",
-                                  aug_nums = 100,
-                                  aug_vs_probility=0.05,
-                                  aug_thickness_probility=0.1,
-                                  aug_vel_threshold=0.1,
-                                  smooth_aug_vel=False,
-                                  smooth_aug_nodes=10,
-                                  smooth_aug_kind="pchip",
-                                  ):
-    """diffusion augmentation extract process
-    Args:
-        vs_model: 2D array [n_depth,n_x]
-            => shear velocity model
-        extract_station_idx: int,
-            => station index
-        extract_method: str
-            => method to extract the 1D profile
-        denorm_vmin: float
-            => minimum shear velocity (km/s)
-        denorm_vmax: float
-            => maximum shear velocity (km/s)
-        combine_vel_threshold: float
-            => velocity threshold for combining the same vs
-        interp_depth: 1D array
-            => target depth for interpolation
-        interp_kind: str
-            => kind of interpolation
-        smooth_vel: bool
-            => whether to smooth the vs
-        smooth_nodes: int
-            => number of nodes for smoothing
-        smooth_kind: str
-            => kind of smoothing
-        aug_nums: int
-            => number of augmentation
-        aug_vs_probility: float
-            => probability of vs perturbation
-        aug_thickness_probility: float
-            => probability of thickness perturbation
-        aug_vel_threshold: float
-            => velocity threshold for removing the thin layers
-        aug_min_layers_num: int
-            => minimum number of layers
-        smooth_aug_vel: bool
-            => whether to smooth the augmented vs
-        smooth_aug_nodes: int
-            => number of nodes for smoothing the augmented vs
-        smooth_aug_kind: str
-            => kind of smoothing the augmented vs
-    Returns:
-        vs_aug: 3D array [n_sta,n_aug,n_depth]
-            => augmented shear velocity
-        depth_aug: 3D array [n_sta,n_aug,n_depth]
-            => augmented depth
-    """
-    # Step 1: extract the 1D profile
-    vs_profiles = extract_1d_profile(vs_model,extract_station_idx,extract_method)
-    depth = np.arange(vs_profiles.shape[-1])*0.04
-
-    vs_aug,depth_aug = [],[]
-
-    for i in range(vs_profiles.shape[0]):
-        vs_profile = vs_profiles[i,:]
-
-        # Step 2: de-normalize the shear velocity
-        denorm_vmin = np.random.uniform(denorm_vmin_range[0],denorm_vmin_range[1])
-        denorm_vmax = np.random.uniform(denorm_vmax_range[0],denorm_vmax_range[1])
-        vs_denormed = max_min_denormalize(vs_profile,denorm_vmin,denorm_vmax)
-
-        # Step 3: combine the same vs
-        vs_combined,depth_combined = combine_same_vs(vs_denormed,depth,combine_vel_threshold)
-
-        # step 4: smooth the vs
-        if smooth_vel:
-            vs_smooth = smooth_vs_by_node_interp(vs_combined,depth_combined,n_nodes=smooth_nodes,method=smooth_kind)
-        else:
-            vs_smooth = vs_combined
-
-        # Step 5: augmentation 1D profile
-        vs_aug_st,depth_aug_st = [],[]
-        for j in range(aug_nums):
-            if j == 0:
-                vs_aug_1d = vs_smooth
-                depth_aug_1d = depth_combined
-            else:
-                vs_aug_1d,depth_aug_1d = perturb_vs_depth(vs_smooth,depth_combined,
-                                                        vs_perturbation=aug_vs_probility,
-                                                        thickness_perturbation=aug_thickness_probility,
-                                                        vel_threshold=aug_vel_threshold)
-            
-            # Step 6: interpolate the shear velocity
-            vs_interpolated = interpolate_vs(vs_aug_1d,depth_aug_1d,interp_depth,interp_kind)
-
-            # step 7: smooth the augmented shear velocity
-            if smooth_aug_vel:
-                vs_interpolated = smooth_vs_by_node_interp(vs_interpolated,interp_depth,n_nodes=smooth_aug_nodes,method=smooth_aug_kind)
-            vs_aug_st.append(vs_interpolated)
-            depth_aug_st.append(interp_depth)
-        vs_aug.append(np.array(vs_aug_st))
-        depth_aug.append(np.array(depth_aug_st))
-
-    vs_aug = np.array(vs_aug) # [n_sta,n_aug,n_depth]
-    depth_aug = np.array(depth_aug) # [n_sta,n_aug,n_depth]
-    return vs_aug,depth_aug

SWIDP/dispersion.py

@@ -1,367 +0,0 @@
-"""This file is used to calculate the dispersion curve based on the given velocity model.
-The original dispersion curve forward modeling procedure is based on the CPS330 software
-    https://www.eas.slu.edu/eqc/ComputerProgramsSeismology/index.html
-The dispersion curve is calculated by the disba package: 
-    https://github.com/keurfonluu/disba
-The transform of velocity model is based on the Brocher (2005) model.
-    [1] T. M. Brocher, “Empirical relations between elastic wavespeeds and density in the earth’s crust,” 
-        Bull. Seismol. Soc. Amer., vol. 95, no. 6, pp. 2081–2092, Dec. 2005, doi: 10.1785/0120050077.
-"""
-
-import numpy as np
-from disba import PhaseDispersion,GroupDispersion
-from scipy.interpolate import interp1d
-
-# -------------------------------------------------------
-#  calculate the dispersion curve
-# -------------------------------------------------------
-def calculate_dispersion(vel_model,t=None,dc=0.001):
-    """calculate the dispersion curve
-    Args:
-        vel_model: 2D numpy array
-            => the velocity model (depth, vp, vs, rho)
-        t: 1D numpy array
-            => the periods (s)
-        dc: float
-            => the sampling interval (km/s) for search the dispersion curve
-    Returns:
-        dispersion_curve: 2D numpy array
-            => the dispersion curve (period, phase velocity, group velocity)
-    """
-    # transform the depth to the thickness
-    depth, vp, vs, rho = vel_model.T
-    thickness = np.diff(depth)
-    thickness = np.append(thickness, thickness[-1])
-    vel_model = np.column_stack((thickness, vp, vs, rho))
-    vel_model = vel_model.astype(np.float64)
-
-    if t is None:
-        # Periods must be sorted starting with low periods
-        t = generate_mixed_samples(num_samples=100,start=0.2,end=10,uniform_num=50,log_num=20,random_num=30)
-
-    # Compute the 3 first Rayleigh- and Love- wave modal dispersion curves
-    try:
-        pd = PhaseDispersion(*vel_model.T, dc=dc)
-        gd = GroupDispersion(*vel_model.T, dc=dc)
-        phase_disp = [pd(t, mode=i, wave="rayleigh") for i in range(1)]
-        group_disp = [gd(t, mode=i, wave='rayleigh') for i in range(1)]
-        
-        phase_period,phase_vel = phase_disp[0].period,phase_disp[0].velocity
-        group_period,group_vel = group_disp[0].period,group_disp[0].velocity
-        
-        if len(phase_period) != len(t) or len(group_period) != len(t):
-            phase_period = np.zeros(len(t))
-            group_period = np.zeros(len(t))
-            phase_vel = np.zeros(len(t))
-            group_vel = np.zeros(len(t))
-            t = np.zeros(len(phase_vel))
-    except Exception as e:
-        # If any error occurs during computation, return arrays of zeros
-        phase_vel = np.zeros(len(t))
-        group_vel = np.zeros(len(t))
-        t         = np.zeros(len(phase_vel))
-    return np.hstack((t.reshape(-1,1),phase_vel.reshape(-1,1),group_vel.reshape(-1,1)))
-
-# -------------------------------------------------------
-#  generate the periods position
-# -------------------------------------------------------
-def generate_mixed_samples(num_samples, start=0.5, end=5, uniform_num=100, log_num=100, random_num=100):
-    """generate periods position
-    Args:
-        num_samples: int
-            => the number of periods
-        start: float
-            => the start period (s)
-        end: float
-            => the end period (s)
-        uniform_num: int
-            => the number of uniform sampling points
-        log_num: int
-            => the number of logarithmic sampling points
-        random_num: int
-            => the number of random sampling points
-    Returns:
-        t_final_sorted: 1D numpy array
-            => the sorted periods (s)
-    """
-    # Uniform sampling
-    t_uniform = np.linspace(start, end, num=uniform_num)
-    # Logarithmic sampling
-    t_log = 1/np.logspace(np.log10(1/end), np.log10(1/start), num=log_num)
-    # Random sampling
-    t_random = np.random.uniform(start, end, size=random_num)
-
-    # Remove duplicates
-    t_uniform_unique = np.unique(t_uniform)
-    t_log_unique = np.unique(t_log)
-    t_random_unique = np.unique(t_random)
-
-    # Combine all unique sampling points
-    t_combined = np.concatenate((t_uniform_unique, t_log_unique, t_random_unique))
-    t_combined_unique = np.unique(t_combined)
-
-    # Adjust final number of sampling points
-    if len(t_combined_unique) > num_samples:
-        t_final = np.random.choice(t_combined_unique, size=num_samples, replace=False)
-    elif len(t_combined_unique) < num_samples:
-        extra_samples = np.random.uniform(start, end, size=num_samples - len(t_combined_unique))
-        t_final = np.concatenate((t_combined_unique, extra_samples))
-        t_final = np.unique(t_final)
-    else:
-        t_final = t_combined_unique
-
-    # Sort
-    t_final_sorted = np.sort(t_final)
-
-    return t_final_sorted
-
-# -------------------------------------------------------
-#  transform the velocity model (Brocher, 2005)
-# -------------------------------------------------------   
-def transform_vp_to_vs(vp):
-    """transform the P-wave velocity to S-wave velocity (Brocher, 2005)
-    Args:
-        vp: 1D/2D numpy array
-            => P-wave velocity (km/s)
-    Returns:
-        vs: 1D/2D numpy array
-            => S-wave velocity (km/s)
-    """
-    vs = 0.7858 - 1.2344*vp + 0.7949*vp**2 - 0.1238*vp**3 + 0.0064*vp**4
-    return vs
-
-def transform_vs_to_vp(vs):
-    """transform the S-wave velocity to P-wave velocity (Brocher, 2005)
-    Args:
-        vs: 1D/2D numpy array
-            => S-wave velocity (km/s)
-    Returns:
-        vp: 1D/2D numpy array
-            => P-wave velocity (km/s)
-    """
-    vp = 0.9409 + 2.0947*vs - 0.8206*vs**2+ 0.2683*vs**3 - 0.0251*vs**4
-    return vp
-
-def transform_vp_to_rho(vp):
-    """transform the P-wave velocity to density (Brocher, 2005)
-    Args:
-        vp: 1D/2D numpy array
-            => P-wave velocity (km/s)
-    Returns:
-        rho: 1D/2D numpy array
-            => density (g/cm^3)
-    """
-    rho = 1.6612*vp - 0.4721*vp**2 + 0.0671*vp**3 - 0.0043*vp**4 + 0.000106*vp**5
-    return rho  
-
-def transform_vs_to_vel_model(vs,depth=None):
-    """transform the S-wave velocity to velocity model (Brocher, 2005)
-    Args:
-        vs: 1D numpy array
-            => S-wave velocity (km/s)
-        depth: 1D numpy array
-            => depth (km)
-    Returns:
-        vel_model: 2D numpy array
-            => the velocity model (depth, vp, vs, rho)
-    """
-    if depth is None:
-        depth       = np.arange(0, vs.shape[-1])*0.04
-    vp          = transform_vs_to_vp(vs)
-
-    # depth > 120 km, the P-wave velocity is equal to the S-wave velocity * 1.79
-    mask = depth>120
-    vp[mask] = vs[mask]*1.79
-    rho         = transform_vp_to_rho(vp)
-    vel_model   = np.column_stack((depth, vp, vs, rho))
-    return vel_model
-
-def transform_vp_to_vel_model(vp,depth=None):
-    """get the velocity model (Brocher, 2005)
-    Args:
-        vp: 1D numpy array
-            => P-wave velocity (km/s)
-        depth: 1D numpy array
-            => depth (km)
-    Returns:
-        vel_model: 2D numpy array
-            => the velocity model (depth, vp, vs, rho)
-    """ 
-    if depth is None:
-        depth       = np.arange(0, vp.shape[-1])*0.04
-    vs          = transform_vp_to_vs(vp)
-    rho         = transform_vp_to_rho(vp)
-    vel_model   = np.column_stack((depth, vp, vs, rho))
-    return vel_model
-
-# -------------------------------------------------------
-#  interpolate the velocity model
-# -------------------------------------------------------
-def interpolate_vel_model(vel_model,depth_new,interp_method="nearest"):
-    """interpolate the velocity model
-    Args:
-        vel_model: 2D numpy array
-            => the velocity model (depth, vp, vs, rho)
-        depth_new: 1D numpy array
-            => the new depth (km)
-        interp_method: str
-            => the interpolation method
-    Returns:
-        vel_model: 2D numpy array
-            => the velocity model (depth, vp, vs, rho)
-    """
-    depth,vp,vs,rho = vel_model.T
-    f_vp  = interp1d(depth,vp,kind=interp_method,fill_value=vp[-1],bounds_error=False)
-    f_vs  = interp1d(depth,vs,kind=interp_method,fill_value=vs[-1],bounds_error=False)
-    f_rho = interp1d(depth,rho,kind=interp_method,fill_value=rho[-1],bounds_error=False)
-    vp_new = f_vp(depth_new)
-    vs_new = f_vs(depth_new)
-    rho_new = f_rho(depth_new)
-    vel_model_new = np.column_stack((depth_new,vp_new,vs_new,rho_new))
-    return vel_model_new
-
-# -------------------------------------------------------
-#  generate the initial model based on empirical formula 
-# -------------------------------------------------------
-def gen_init_model(t,cg_obs,thick,area=False):
-    """
-    generate the initial model based on empirical formula 
-    developed by Thomas M.Brocher (2005).
-    ---------------------
-    Input Parameters:
-        t : 1D numpy array 
-            => period of observaton dispersion points
-        cg_obs: 1D numpy array 
-            => phase velocity of observation dispersion points
-        thick : 1D numpy array 
-            => thickness of each layer
-    Output: the initialize model
-        thick : 1D numpy array 
-            => thickness
-        vs : 1D numpy array 
-            => the shear wave velocity
-        vp : 1D numpy array 
-            => the compress wave velocity
-        rho: 1D numpy array 
-            => the density
-    --------------------
-    Output parameters:
-        model:Dict 
-            => the generated model
-    """
-    wavelength  = t*cg_obs
-    nlayer      = len(thick)
-    lambda2L    = 0.65      # the depth faction 0.63L
-    beta        = 0.92      # the poisson's ratio
-    eqv_lambda = lambda2L*wavelength
-    lay_model = np.zeros((nlayer,2))
-    lay_model[:,0] = thick
-    for i in range(nlayer-1):
-        if i == 0:
-            up_bound = 0
-        else:
-            up_bound = up_bound + lay_model[i-1,0] # the top-layer's depth
-        low_bound = up_bound + lay_model[i,0] # the botton-layer's depth
-        # vs for every layer
-        lambda_idx = np.argwhere((eqv_lambda>up_bound) & (eqv_lambda<low_bound))
-        if len(lambda_idx)>0:
-            lay_model[i,1] = np.max(cg_obs[lambda_idx])/beta # phase velocity -> vs
-        else:
-            lambda_idx = np.argmin(np.abs(eqv_lambda - low_bound))
-            lay_model[i,1] = cg_obs[lambda_idx]/beta
-    # set the last layer
-    lay_model[nlayer-1,0] = 0
-    lay_model[nlayer-1,1] = np.max(cg_obs)*1.1
-    thick = lay_model[:,0]
-    vs = lay_model[:,1]
-    vp = transform_vs_to_vp(vs)
-    depth = np.cumsum(thick)
-    
-    mask = depth>120
-    vp[mask] = vs[mask]*1.79
-    rho = transform_vp_to_rho(vp)
-    
-    model = {
-        "depth":depth,
-        "vp":vp,
-        "vs":vs,
-        "rho":rho
-    }
-    if area:
-        return np.column_stack((depth,vp,vs,rho)) 
-    else:
-        return model
-
-# -------------------------------------------------------
-#  generate the velocity model from the S-wave velocity
-# -------------------------------------------------------
-def gen_model_from_vs(depth,vs,area=False,Brocher=True):
-    """
-    generate the initial model based on empirical formula 
-    developed by Thomas M.Brocher (2005).
-    ---------------------
-    Input Parameters:
-        thick : Array(1D) 
-            => the thickness of layer 
-        vs    : Array(1D)
-            => the shear wave velocity
-        area  : boolen 
-            => the output format
-    --------------------
-    Output parameters:
-        model:Dict 
-            the generated model
-    """
-    depth       = np.array(depth)
-    thickness   = np.diff(depth)
-    thickness   = np.insert(thickness,-1,thickness[-1]) 
-    vs = np.array(vs)
-    if Brocher:
-        vp = transform_vs_to_vp(vs)
-    else:
-        vp = 1.79*vs
-    mask = depth>120
-    vp[mask] = vs[mask]*1.79
-    rho = transform_vp_to_rho(vp)
-    model = {
-        "depth":depth,
-        "vp":vp,
-        "vs":vs,
-        "rho":rho
-    }
-    if area:
-        return np.column_stack((depth, vp, vs, rho))
-    else:
-        return model
-    
-# -------------------------------------------------------
-#  smooth the data
-# -------------------------------------------------------
-def smooth_data(y, window_size=7):
-    """
-    Smooth the input data using a moving average filter, with padding to reduce edge effects.
-    
-    Parameters:
-    y (array-like): The input data to be smoothed.
-    window_size (int): Size of the moving average window (default is 7).
-    
-    Returns:
-    y_smooth (array-like): Smoothed data.
-    """
-
-    # Save the first data point to preserve it after smoothing
-    first_point = y[0]
-
-    # Create a moving average window (a window of ones normalized by the window size)
-    window = np.ones(window_size) / window_size
-
-    # Pad the input data using 'reflect' mode to minimize edge effects during convolution
-    y_padded = np.pad(y, (window_size // 2, window_size // 2), mode='reflect')
-
-    # Apply the convolution between the padded data and the smoothing window
-    y_smooth = np.convolve(y_padded, window, mode='valid')
-
-    # Replace the first point of the smoothed data with the original first point
-    y_smooth[0] = first_point
-    
-    return y_smooth

SWIDP/download_2d_3d_model.py

@@ -1,31 +0,0 @@
-# Notice
-# We provide the following download links for the datasets used in this work.
-# However, we strongly encourage users to properly credit the original studies when using these datasets in any research or derivative work.
-# Please also carefully read the official documentation of each dataset on their corresponding websites to fully understand the data description, quality control, and usage constraints.
-
-# Datasets links
-
-# 1. SWI-shallow from OpenFWI
-# https://openfwi-lanl.github.io/docs/data.html
-    # Flat: https://drive.google.com/drive/folders/1NIdjiYhjWSV9NHn7ZEFYTpJxzvzxqYRb?usp=sharing
-    # Fold: https://drive.google.com/drive/folders/1NGXnVG0gUFHfDcUvJxfozCgiI4WwquVk?usp=sharing
-    # Flat-Fault: https://drive.google.com/drive/folders/1jOB6R_zewuFj5wZam7nDP7GixQnbnRLR?usp=sharing
-    # Fold-Fault: https://drive.google.com/drive/folders/1vqUHJ-iRwp3ozL-e4HhKGpdO0e7NQZE1?usp=sharing
-    # Field: https://drive.google.com/drive/folders/1CQceUL5ITTHV-PRqbIzkyZwCDdUk0XkU?usp=sharing
-
-# 2. OpenSWI-deep from 14 global and regional 3D velocity models
-# LITHO1.0: https://igppweb.ucsd.edu/~gabi/litho1.0.html
-# USTClitho1.0: http://chinageorefmodel.org/wp-content/uploads/china-models-individual/USTClitho1.0.zip
-# Central-and-Western-US: http://ciei.colorado.edu/Models/US_4/WCUS_Shen_2012.zip
-# Continental-China: http://ciei.colorado.edu/Models/China_Shen_2015/China_2015_Vs_v1.0.tar
-# US-Upper-Mantle: http://ds.iris.edu/ds/products/emc-us-upper-mantle-vsxiechuyang2018/
-# Alaska: https://ds.iris.edu/ds/products/emc-alaskajointinversion_rfvphhv-1berg2020/
-# LSP-Eucrust1.0: https://ds.iris.edu/ds/products/emc-lsp_eucrust10/
-# CSRM-Eastern Mediterranean: https://ds.iris.edu/spud/earthmodel/18027082
-# CSEM-Europe: https://ds.iris.edu/spud/earthmodel/18027090
-# CSEM-South-Atlantic: http://ds.iris.edu/ds/products/emc-csem_south_atlantic
-# CSEM-North-Atlantic: http://ds.iris.edu/ds/products/emc-csem_north_atlantic
-# CSEM-japan: http://ds.iris.edu/ds/products/emc-csem_japan
-# CSEM-iberia: http://ds.iris.edu/ds/products/emc-csem_iberia
-# CSEM-Australasia: http://ds.iris.edu/ds/products/emc-csem_australasia
-