635 lines
18 KiB
Rust
635 lines
18 KiB
Rust
//! Sample data and configurations for the SeismicAI demo.
|
|
//!
|
|
//! Provides realistic earthquake scenarios, station networks, and velocity models
|
|
//! for demonstration and testing purposes.
|
|
|
|
use seismic_shared::{
|
|
EarthquakeSource, FocalMechanism, GeoLocation, InstrumentType, SimulationConfig, SiteClass,
|
|
StationConfig, VelocityLayer, VelocityModel, WarningConfig,
|
|
};
|
|
|
|
// ============================================================================
|
|
// Sample Earthquake Scenarios
|
|
// ============================================================================
|
|
|
|
/// Create a local shallow earthquake (M4.5, 8km depth).
|
|
/// Representative of typical California small/moderate events.
|
|
pub fn local_earthquake() -> EarthquakeSource {
|
|
let mut source = EarthquakeSource::new(
|
|
37.8044, // Near Berkeley, CA (Hayward Fault)
|
|
-122.2712,
|
|
8.0, // Shallow depth
|
|
4.5, // Moderate magnitude
|
|
FocalMechanism::strike_slip(),
|
|
);
|
|
source.event_id = "NC72345678".to_string();
|
|
source.stress_drop_mpa = Some(5.0);
|
|
source
|
|
}
|
|
|
|
/// Create a regional moderate earthquake (M6.0, 15km depth).
|
|
/// Representative of damaging regional events.
|
|
pub fn regional_earthquake() -> EarthquakeSource {
|
|
let mut source = EarthquakeSource::new(
|
|
36.5, // Central California (San Andreas Fault)
|
|
-121.0,
|
|
15.0, // Mid-crustal depth
|
|
6.0, // Significant magnitude
|
|
FocalMechanism::strike_slip(),
|
|
);
|
|
source.event_id = "NC72456789".to_string();
|
|
source.stress_drop_mpa = Some(10.0);
|
|
source
|
|
}
|
|
|
|
/// Create a major earthquake scenario (M7.0, 10km depth).
|
|
/// Representative of potentially catastrophic events.
|
|
pub fn major_earthquake() -> EarthquakeSource {
|
|
let mut source = EarthquakeSource::new(
|
|
37.4, // Near San Jose (Hayward Fault)
|
|
-122.1,
|
|
10.0,
|
|
7.0, // Major magnitude
|
|
FocalMechanism {
|
|
strike: 150.0,
|
|
dip: 80.0,
|
|
rake: 175.0, // Right-lateral strike-slip
|
|
},
|
|
);
|
|
source.event_id = "NC72567890".to_string();
|
|
source.stress_drop_mpa = Some(8.0);
|
|
source.rupture_duration_s = Some(15.0);
|
|
source
|
|
}
|
|
|
|
/// Create a subduction zone earthquake scenario (M8.0, 20km depth).
|
|
/// Representative of Cascadia-style megathrust events.
|
|
pub fn subduction_earthquake() -> EarthquakeSource {
|
|
let mut source = EarthquakeSource::new(
|
|
44.0, // Offshore Oregon (Cascadia Subduction Zone)
|
|
-125.0,
|
|
20.0,
|
|
8.0, // Great earthquake
|
|
FocalMechanism::reverse(),
|
|
);
|
|
source.event_id = "PW72678901".to_string();
|
|
source.stress_drop_mpa = Some(3.0); // Lower stress drop for subduction
|
|
source.rupture_area_km2 = Some(10000.0);
|
|
source.rupture_duration_s = Some(60.0);
|
|
source
|
|
}
|
|
|
|
/// Create a deep earthquake scenario (M5.5, 100km depth).
|
|
/// Representative of deep intraslab events.
|
|
pub fn deep_earthquake() -> EarthquakeSource {
|
|
let mut source = EarthquakeSource::new(
|
|
47.5, // Puget Sound region
|
|
-122.5,
|
|
100.0, // Deep intraslab
|
|
5.5,
|
|
FocalMechanism::normal(),
|
|
);
|
|
source.event_id = "UW72789012".to_string();
|
|
source.stress_drop_mpa = Some(50.0); // Higher stress drop for deep events
|
|
source
|
|
}
|
|
|
|
// ============================================================================
|
|
// Sample Station Networks
|
|
// ============================================================================
|
|
|
|
/// Create a dense urban seismic network (100 stations in 10x10 grid).
|
|
/// Representative of ShakeAlert-style networks in urban areas.
|
|
pub fn dense_network() -> Vec<StationConfig> {
|
|
let center = GeoLocation::new(37.8, -122.4);
|
|
let grid_spacing = 0.05; // ~5km at this latitude
|
|
|
|
let mut stations = Vec::with_capacity(100);
|
|
|
|
for i in 0..10 {
|
|
for j in 0..10 {
|
|
let lat = center.latitude - 0.25 + i as f64 * grid_spacing;
|
|
let lon = center.longitude - 0.25 + j as f64 * grid_spacing;
|
|
|
|
let mut station = StationConfig::new(&format!("BK{:02}{:02}", i, j), lat, lon);
|
|
station.name = format!("Bay Area Station {:02}-{:02}", i, j);
|
|
station.network = "BK".to_string();
|
|
station.instrument = InstrumentType::Accelerometer;
|
|
|
|
// Vary site classes
|
|
station.site_class = match (i + j) % 5 {
|
|
0 => SiteClass::A,
|
|
1 => SiteClass::B,
|
|
2 => SiteClass::C,
|
|
3 => SiteClass::D,
|
|
_ => SiteClass::E,
|
|
};
|
|
|
|
stations.push(station);
|
|
}
|
|
}
|
|
|
|
stations
|
|
}
|
|
|
|
/// Create a sparse regional seismic network (5 stations).
|
|
/// Representative of USGS/university backbone networks.
|
|
pub fn sparse_network() -> Vec<StationConfig> {
|
|
vec![
|
|
{
|
|
let mut s = StationConfig::new("BK.BKS", 37.8764, -122.2356);
|
|
s.name = "Berkeley Seismic Station".to_string();
|
|
s.network = "BK".to_string();
|
|
s.instrument = InstrumentType::Broadband;
|
|
s.site_class = SiteClass::B;
|
|
s.vs30 = Some(950.0);
|
|
s
|
|
},
|
|
{
|
|
let mut s = StationConfig::new("BK.CMB", 38.0346, -120.3865);
|
|
s.name = "Columbia College".to_string();
|
|
s.network = "BK".to_string();
|
|
s.instrument = InstrumentType::Broadband;
|
|
s.site_class = SiteClass::B;
|
|
s.vs30 = Some(800.0);
|
|
s
|
|
},
|
|
{
|
|
let mut s = StationConfig::new("BK.SAO", 36.7640, -121.4472);
|
|
s.name = "San Andreas Observatory".to_string();
|
|
s.network = "BK".to_string();
|
|
s.instrument = InstrumentType::Broadband;
|
|
s.site_class = SiteClass::C;
|
|
s.vs30 = Some(550.0);
|
|
s
|
|
},
|
|
{
|
|
let mut s = StationConfig::new("NC.FARB", 37.6977, -123.0016);
|
|
s.name = "Farallon Islands".to_string();
|
|
s.network = "NC".to_string();
|
|
s.instrument = InstrumentType::Accelerometer;
|
|
s.site_class = SiteClass::A;
|
|
s.vs30 = Some(1500.0);
|
|
s
|
|
},
|
|
{
|
|
let mut s = StationConfig::new("NC.SF", 37.7749, -122.4194);
|
|
s.name = "San Francisco".to_string();
|
|
s.network = "NC".to_string();
|
|
s.instrument = InstrumentType::Accelerometer;
|
|
s.site_class = SiteClass::D;
|
|
s.vs30 = Some(280.0);
|
|
s.z1_0 = Some(0.5);
|
|
s
|
|
},
|
|
]
|
|
}
|
|
|
|
/// Create a linear array for source characterization.
|
|
pub fn linear_array() -> Vec<StationConfig> {
|
|
let start = GeoLocation::new(37.0, -122.0);
|
|
let end = GeoLocation::new(38.0, -122.0);
|
|
let num_stations = 20;
|
|
|
|
(0..num_stations)
|
|
.map(|i| {
|
|
let t = i as f64 / (num_stations - 1) as f64;
|
|
let lat = start.latitude + t * (end.latitude - start.latitude);
|
|
let lon = start.longitude + t * (end.longitude - start.longitude);
|
|
|
|
let mut station = StationConfig::new(&format!("LA{:02}", i), lat, lon);
|
|
station.name = format!("Linear Array Station {:02}", i);
|
|
station.network = "XX".to_string();
|
|
station.instrument = InstrumentType::ShortPeriod;
|
|
station.site_class = SiteClass::C;
|
|
station
|
|
})
|
|
.collect()
|
|
}
|
|
|
|
/// Create a MEMS network for community early warning.
|
|
pub fn mems_network() -> Vec<StationConfig> {
|
|
let center = GeoLocation::new(34.0522, -118.2437); // Los Angeles
|
|
let num_stations = 50;
|
|
|
|
(0..num_stations)
|
|
.map(|i| {
|
|
// Random-ish distribution
|
|
let angle = i as f64 * 2.4; // Golden angle
|
|
let radius = 0.1 + 0.05 * (i as f64).sqrt();
|
|
let lat = center.latitude + radius * angle.cos();
|
|
let lon = center.longitude + radius * angle.sin();
|
|
|
|
let mut station = StationConfig::new(&format!("ME{:02}", i), lat, lon);
|
|
station.name = format!("MEMS Station {:02}", i);
|
|
station.network = "CE".to_string();
|
|
station.instrument = InstrumentType::Mems;
|
|
station.site_class = if i % 3 == 0 {
|
|
SiteClass::D
|
|
} else {
|
|
SiteClass::C
|
|
};
|
|
station
|
|
})
|
|
.collect()
|
|
}
|
|
|
|
// ============================================================================
|
|
// Sample Velocity Models
|
|
// ============================================================================
|
|
|
|
/// Create California 1D velocity model (SCEC CVM-H based).
|
|
pub fn california_velocity_model() -> VelocityModel {
|
|
let mut model = VelocityModel::new("California CVM-H Simplified");
|
|
model.reference_lat = 35.0;
|
|
model.reference_lon = -118.0;
|
|
|
|
// Layered model from surface to Moho
|
|
model.add_layer(VelocityLayer {
|
|
depth_km: 0.0,
|
|
thickness_km: 1.0,
|
|
vp: 2.5,
|
|
vs: 1.2,
|
|
density: 2.1,
|
|
qp: 100.0,
|
|
qs: 50.0,
|
|
});
|
|
|
|
model.add_layer(VelocityLayer {
|
|
depth_km: 1.0,
|
|
thickness_km: 2.0,
|
|
vp: 4.0,
|
|
vs: 2.3,
|
|
density: 2.4,
|
|
qp: 200.0,
|
|
qs: 100.0,
|
|
});
|
|
|
|
model.add_layer(VelocityLayer {
|
|
depth_km: 3.0,
|
|
thickness_km: 5.0,
|
|
vp: 5.5,
|
|
vs: 3.2,
|
|
density: 2.6,
|
|
qp: 400.0,
|
|
qs: 200.0,
|
|
});
|
|
|
|
model.add_layer(VelocityLayer {
|
|
depth_km: 8.0,
|
|
thickness_km: 7.0,
|
|
vp: 6.3,
|
|
vs: 3.6,
|
|
density: 2.8,
|
|
qp: 600.0,
|
|
qs: 300.0,
|
|
});
|
|
|
|
model.add_layer(VelocityLayer {
|
|
depth_km: 15.0,
|
|
thickness_km: 10.0,
|
|
vp: 6.7,
|
|
vs: 3.9,
|
|
density: 2.9,
|
|
qp: 800.0,
|
|
qs: 400.0,
|
|
});
|
|
|
|
model.add_layer(VelocityLayer {
|
|
depth_km: 25.0,
|
|
thickness_km: 10.0,
|
|
vp: 7.2,
|
|
vs: 4.1,
|
|
density: 3.0,
|
|
qp: 1000.0,
|
|
qs: 500.0,
|
|
});
|
|
|
|
// Moho
|
|
model.add_layer(VelocityLayer {
|
|
depth_km: 35.0,
|
|
thickness_km: 15.0,
|
|
vp: 7.8,
|
|
vs: 4.4,
|
|
density: 3.2,
|
|
qp: 1500.0,
|
|
qs: 750.0,
|
|
});
|
|
|
|
model
|
|
}
|
|
|
|
/// Create Pacific Northwest velocity model (Cascadia).
|
|
pub fn cascadia_velocity_model() -> VelocityModel {
|
|
let mut model = VelocityModel::new("Cascadia Subduction Zone");
|
|
model.reference_lat = 45.0;
|
|
model.reference_lon = -123.0;
|
|
|
|
// Sedimentary basin
|
|
model.add_layer(VelocityLayer::new(0.0, 3.0, 3.5, 2.0, 2.2));
|
|
|
|
// Upper crust
|
|
model.add_layer(VelocityLayer::new(3.0, 12.0, 6.0, 3.5, 2.7));
|
|
|
|
// Lower crust
|
|
model.add_layer(VelocityLayer::new(15.0, 15.0, 6.8, 3.9, 2.9));
|
|
|
|
// Subducting oceanic crust
|
|
model.add_layer(VelocityLayer::new(30.0, 10.0, 7.2, 4.1, 3.1));
|
|
|
|
// Mantle
|
|
model.add_layer(VelocityLayer::new(40.0, 60.0, 8.1, 4.6, 3.3));
|
|
|
|
model
|
|
}
|
|
|
|
/// Create a simple generic velocity model.
|
|
pub fn generic_velocity_model() -> VelocityModel {
|
|
let mut model = VelocityModel::new("Generic");
|
|
model.add_layer(VelocityLayer::new(0.0, 5.0, 5.0, 2.9, 2.5));
|
|
model.add_layer(VelocityLayer::new(5.0, 15.0, 6.5, 3.7, 2.8));
|
|
model.add_layer(VelocityLayer::new(20.0, 15.0, 7.5, 4.3, 3.1));
|
|
model.add_layer(VelocityLayer::new(35.0, 65.0, 8.0, 4.6, 3.3));
|
|
model
|
|
}
|
|
|
|
// ============================================================================
|
|
// Sample Configurations
|
|
// ============================================================================
|
|
|
|
/// High-resolution simulation configuration.
|
|
pub fn high_resolution_config() -> SimulationConfig {
|
|
SimulationConfig {
|
|
dt: 0.005,
|
|
duration: 120.0,
|
|
dx: 0.25,
|
|
domain_size: (200.0, 200.0, 60.0),
|
|
max_frequency: 20.0,
|
|
include_attenuation: true,
|
|
include_site_effects: true,
|
|
use_neural_operator: true,
|
|
fno_modes: 32,
|
|
hidden_dim: 128,
|
|
}
|
|
}
|
|
|
|
/// Standard simulation configuration.
|
|
pub fn standard_config() -> SimulationConfig {
|
|
SimulationConfig::default()
|
|
}
|
|
|
|
/// Fast/coarse simulation configuration.
|
|
pub fn fast_config() -> SimulationConfig {
|
|
SimulationConfig {
|
|
dt: 0.02,
|
|
duration: 60.0,
|
|
dx: 1.0,
|
|
domain_size: (100.0, 100.0, 40.0),
|
|
max_frequency: 5.0,
|
|
include_attenuation: true,
|
|
include_site_effects: true,
|
|
use_neural_operator: true,
|
|
fno_modes: 8,
|
|
hidden_dim: 32,
|
|
}
|
|
}
|
|
|
|
/// Early warning configuration for urban areas.
|
|
pub fn urban_warning_config() -> WarningConfig {
|
|
WarningConfig {
|
|
min_magnitude: 3.5,
|
|
min_stations: 4,
|
|
alert_threshold_seconds: 5.0,
|
|
enable_sound: true,
|
|
enable_notifications: true,
|
|
alert_radius_km: 150.0,
|
|
}
|
|
}
|
|
|
|
/// Early warning configuration for regional networks.
|
|
pub fn regional_warning_config() -> WarningConfig {
|
|
WarningConfig {
|
|
min_magnitude: 4.5,
|
|
min_stations: 3,
|
|
alert_threshold_seconds: 10.0,
|
|
enable_sound: true,
|
|
enable_notifications: true,
|
|
alert_radius_km: 300.0,
|
|
}
|
|
}
|
|
|
|
// ============================================================================
|
|
// Complete Scenarios
|
|
// ============================================================================
|
|
|
|
/// Complete scenario: Hayward Fault rupture affecting Bay Area.
|
|
pub fn hayward_scenario() -> (
|
|
EarthquakeSource,
|
|
Vec<StationConfig>,
|
|
VelocityModel,
|
|
SimulationConfig,
|
|
) {
|
|
(
|
|
major_earthquake(),
|
|
dense_network(),
|
|
california_velocity_model(),
|
|
standard_config(),
|
|
)
|
|
}
|
|
|
|
/// Complete scenario: Small local event for testing.
|
|
pub fn local_test_scenario() -> (
|
|
EarthquakeSource,
|
|
Vec<StationConfig>,
|
|
VelocityModel,
|
|
SimulationConfig,
|
|
) {
|
|
(
|
|
local_earthquake(),
|
|
sparse_network(),
|
|
generic_velocity_model(),
|
|
fast_config(),
|
|
)
|
|
}
|
|
|
|
/// Complete scenario: Cascadia megathrust.
|
|
pub fn cascadia_scenario() -> (
|
|
EarthquakeSource,
|
|
Vec<StationConfig>,
|
|
VelocityModel,
|
|
SimulationConfig,
|
|
) {
|
|
(
|
|
subduction_earthquake(),
|
|
sparse_network(),
|
|
cascadia_velocity_model(),
|
|
high_resolution_config(),
|
|
)
|
|
}
|
|
|
|
// ============================================================================
|
|
// Tests
|
|
// ============================================================================
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn test_local_earthquake() {
|
|
let eq = local_earthquake();
|
|
assert!(eq.magnitude >= 4.0 && eq.magnitude <= 5.0);
|
|
assert!(eq.hypocenter.depth_km < 15.0);
|
|
}
|
|
|
|
#[test]
|
|
fn test_regional_earthquake() {
|
|
let eq = regional_earthquake();
|
|
assert!(eq.magnitude >= 5.5 && eq.magnitude <= 6.5);
|
|
}
|
|
|
|
#[test]
|
|
fn test_major_earthquake() {
|
|
let eq = major_earthquake();
|
|
assert!(eq.magnitude >= 6.5);
|
|
}
|
|
|
|
#[test]
|
|
fn test_subduction_earthquake() {
|
|
let eq = subduction_earthquake();
|
|
assert!(eq.magnitude >= 7.5);
|
|
assert!(eq.hypocenter.depth_km >= 15.0);
|
|
}
|
|
|
|
#[test]
|
|
fn test_deep_earthquake() {
|
|
let eq = deep_earthquake();
|
|
assert!(eq.hypocenter.depth_km >= 50.0);
|
|
}
|
|
|
|
#[test]
|
|
fn test_dense_network() {
|
|
let network = dense_network();
|
|
assert_eq!(network.len(), 100);
|
|
|
|
// Check diversity of site classes
|
|
let site_classes: Vec<_> = network.iter().map(|s| s.site_class).collect();
|
|
assert!(site_classes.contains(&SiteClass::A));
|
|
assert!(site_classes.contains(&SiteClass::E));
|
|
}
|
|
|
|
#[test]
|
|
fn test_sparse_network() {
|
|
let network = sparse_network();
|
|
assert!(network.len() >= 4 && network.len() <= 10);
|
|
|
|
// All should have valid Vs30
|
|
for station in &network {
|
|
assert!(station.get_vs30() > 0.0);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_linear_array() {
|
|
let array = linear_array();
|
|
assert_eq!(array.len(), 20);
|
|
|
|
// Check stations are in a line
|
|
let first_lon = array[0].location.longitude;
|
|
for station in &array {
|
|
assert!((station.location.longitude - first_lon).abs() < 0.01);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_mems_network() {
|
|
let network = mems_network();
|
|
assert_eq!(network.len(), 50);
|
|
|
|
for station in &network {
|
|
assert_eq!(station.instrument, InstrumentType::Mems);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_california_velocity_model() {
|
|
let model = california_velocity_model();
|
|
assert!(!model.layers.is_empty());
|
|
|
|
// Velocity should increase with depth
|
|
for i in 1..model.layers.len() {
|
|
assert!(model.layers[i].vp >= model.layers[i - 1].vp * 0.9);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_cascadia_velocity_model() {
|
|
let model = cascadia_velocity_model();
|
|
assert!(!model.layers.is_empty());
|
|
|
|
// Should have deep layers for subduction
|
|
let max_depth: f64 = model
|
|
.layers
|
|
.iter()
|
|
.map(|l| l.depth_km + l.thickness_km)
|
|
.fold(0.0, f64::max);
|
|
assert!(max_depth >= 50.0);
|
|
}
|
|
|
|
#[test]
|
|
fn test_simulation_configs() {
|
|
let fast = fast_config();
|
|
let standard = standard_config();
|
|
let high = high_resolution_config();
|
|
|
|
// Higher resolution means smaller dx
|
|
assert!(high.dx < standard.dx);
|
|
assert!(standard.dx < fast.dx);
|
|
|
|
// Higher resolution means smaller dt
|
|
assert!(high.dt < standard.dt);
|
|
assert!(standard.dt < fast.dt);
|
|
}
|
|
|
|
#[test]
|
|
fn test_warning_configs() {
|
|
let urban = urban_warning_config();
|
|
let regional = regional_warning_config();
|
|
|
|
// Urban should have lower magnitude threshold
|
|
assert!(urban.min_magnitude <= regional.min_magnitude);
|
|
|
|
// Both should require multiple stations
|
|
assert!(urban.min_stations >= 2);
|
|
assert!(regional.min_stations >= 2);
|
|
}
|
|
|
|
#[test]
|
|
fn test_hayward_scenario() {
|
|
let (source, stations, model, config) = hayward_scenario();
|
|
|
|
assert!(source.magnitude >= 6.5);
|
|
assert!(stations.len() >= 50);
|
|
assert!(!model.layers.is_empty());
|
|
assert!(config.duration > 0.0);
|
|
}
|
|
|
|
#[test]
|
|
fn test_local_test_scenario() {
|
|
let (source, stations, model, config) = local_test_scenario();
|
|
|
|
assert!(source.magnitude < 6.0);
|
|
assert!(stations.len() < 20);
|
|
assert!(config.dt >= 0.01); // Not too fine for testing
|
|
}
|
|
|
|
#[test]
|
|
fn test_cascadia_scenario() {
|
|
let (source, _stations, model, config) = cascadia_scenario();
|
|
|
|
assert!(source.magnitude >= 7.5);
|
|
assert_eq!(model.name, "Cascadia Subduction Zone");
|
|
assert!(config.max_frequency >= 10.0);
|
|
}
|
|
}
|