Fichiers
moteur-terrain/rt-live/examples/veymont.rs
T

274 lignes
12 KiB
Rust

//! Simulation d'une saison sur la tuile Veymont.
//! Usage : cargo run --release --example veymont -- saison <dossier tuiles> <dossier sortie>
//! cargo run --release --example veymont -- calibrage <dossier tuiles>
use rt_core::TileId;
use rt_live::*;
use rt_tiles::TileStore;
use std::path::PathBuf;
const X0: i32 = -4000;
const Z0: i32 = 28900;
const N: i32 = 1000;
struct Terrain {
alt: Vec<f32>,
pente: Vec<f32>,
aspect: Vec<f32>,
ok: Vec<bool>,
}
fn charger(dir: &str) -> Terrain {
let store = TileStore::new(PathBuf::from(dir));
let n = (N * N) as usize;
let mut t = Terrain { alt: vec![0.0; n], pente: vec![0.0; n], aspect: vec![0.0; n], ok: vec![false; n] };
for z in 0..N {
for x in 0..N {
let (bx, bz) = (X0 + x, Z0 + z);
let id = TileId::of_block(bx, bz);
let Ok(tile) = store.get(id) else { continue };
let s = tile.sample(bx - id.tx * TileId::SIZE, bz - id.tz * TileId::SIZE);
if s.ground_dm == 0 {
continue;
}
let i = (z * N + x) as usize;
t.alt[i] = s.ground_dm as f32 / 10.0 + tile.origin().alt_zero_dm() as f32;
t.pente[i] = s.slope_deg as f32;
t.aspect[i] = s.aspect as f32 * 360.0 / 256.0;
t.ok[i] = true;
}
}
t
}
fn params() -> Params {
// Surcharges pour le calibrage : RT_P="ddf=4,krad=0.6,..."
let mut p = Params::default();
if let Ok(s) = std::env::var("RT_P") {
for kv in s.split(',') {
if let Some((k, v)) = kv.split_once('=') {
let v: f32 = v.parse().unwrap();
match k {
"ddf" => p.ddf_mm = v,
"krad" => p.k_rad = v,
"tn" => p.t_neige_c = v,
"tp" => p.t_pluie_c = v,
"gp" => p.gain_precip_100m = v,
"sola" => p.fonte_sol_automne_mm = v,
"solh" => p.fonte_sol_hiver_mm = v,
_ => panic!("param {k}"),
}
}
}
}
p
}
fn manteau(t: &Terrain) -> Manteau {
let nc = (N / 32) as usize;
Manteau::nouveau(params(), 32, X0, Z0, nc, nc, |ix, iz| {
let (mut a, mut p, mut sx, mut sz, mut k) = (0.0, 0.0, 0.0, 0.0, 0.0);
for z in 0..32 {
for x in 0..32 {
let i = ((iz as i32 * 32 + z) * N + ix as i32 * 32 + x) as usize;
if t.ok[i] {
let w = t.pente[i].max(1.0);
a += t.alt[i];
p += t.pente[i];
sx += w * t.aspect[i].to_radians().sin();
sz += w * t.aspect[i].to_radians().cos();
k += 1.0;
}
}
}
let k = f32::max(k, 1.0);
Cellule { alt_m: a / k, pente_deg: p / k, aspect_deg: sx.atan2(sz).to_degrees().rem_euclid(360.0) }
})
}
fn graine() -> u64 {
std::env::var("RT_SEED").ok().and_then(|s| s.parse().ok()).unwrap_or(11)
}
fn pct(v: &mut Vec<f32>, q: f32) -> f32 {
v.sort_by(|a, b| a.partial_cmp(b).unwrap());
v[((v.len() - 1) as f32 * q).round() as usize]
}
fn calibrage(dir: &str) {
let t = charger(dir);
let dates = [
Date::new(2026, 9, 15), Date::new(2026, 10, 1), Date::new(2026, 10, 15), Date::new(2026, 10, 31),
Date::new(2026, 11, 15), Date::new(2026, 12, 1), Date::new(2027, 1, 15), Date::new(2027, 3, 1),
Date::new(2027, 4, 15), Date::new(2027, 5, 15), Date::new(2027, 6, 1), Date::new(2027, 6, 15), Date::new(2027, 7, 1),
];
println!("Fraction du Veymont enneigee (>= 8 mm d'equivalent en eau), 60 annees synthetiques (graines 1..=60)");
println!("date moyenne p10 p90 | 1650-1900 | 1900-2100 | 2100-2400 (moyenne)");
let mut res: Vec<Vec<[f32; 4]>> = vec![vec![]; dates.len()];
for seed in 1..=60u64 {
let mut c = CoucheLive::new(Mode::Climat, manteau(&t), Climat::nouveau(seed, 1.0), None);
for (k, d) in dates.iter().enumerate() {
c.avancer_a(*d);
let m = &c.manteau;
res[k].push([m.fraction_enneigee(0.0, 9000.0), m.fraction_enneigee(0.0, 1900.0), m.fraction_enneigee(1900.0, 2100.0), m.fraction_enneigee(2100.0, 9000.0)]);
}
}
// Jours d'enneigement par bande (annee hydrologique complete)
let mut jours = [0f32; 4];
for seed in 1..=60u64 {
let mut c = CoucheLive::new(Mode::Climat, manteau(&t), Climat::nouveau(seed, 1.0), None);
for k in 0..365 {
c.avancer_a(Date::new(2026, 8, 1).plus(k));
for (j, (a, b)) in [(0.0, 1900.0), (1900.0, 2100.0), (2100.0, 9000.0), (0.0, 9000.0)].iter().enumerate() {
jours[j] += c.manteau.fraction_enneigee(*a, *b);
}
}
}
println!("jours d'enneigement moyens : 1650-1900 m {:.0} j ; 1900-2100 m {:.0} j ; > 2100 m {:.0} j ; tout {:.0} j (physique::jours_enneigement(2000 m) = {:.0})", jours[0] / 60.0, jours[1] / 60.0, jours[2] / 60.0, jours[3] / 60.0, physique::jours_enneigement(2000.0));
for (k, d) in dates.iter().enumerate() {
let mean = |j: usize| res[k].iter().map(|r| r[j]).sum::<f32>() / res[k].len() as f32;
let mut v: Vec<f32> = res[k].iter().map(|r| r[0]).collect();
println!("{d} {:5.1} % {:5.1} {:5.1} | {:5.1} % | {:5.1} % | {:5.1} %", 100.0 * mean(0), 100.0 * pct(&mut v.clone(), 0.1), 100.0 * pct(&mut v, 0.9), 100.0 * mean(1), 100.0 * mean(2), 100.0 * mean(3));
}
}
fn hillshade(t: &Terrain, x: i32, z: i32) -> f32 {
let g = |dx: i32, dz: i32| t.alt[((z + dz).clamp(0, N - 1) * N + (x + dx).clamp(0, N - 1)) as usize];
let (dzdx, dzdz) = ((g(4, 0) - g(-4, 0)) / 8.0, (g(0, 4) - g(0, -4)) / 8.0);
// soleil au nord-ouest, 40 deg
let (sl, asp) = (dzdx.hypot(dzdz).atan(), (-dzdx).atan2(dzdz));
let az = 315f32.to_radians();
let h = 40f32.to_radians();
(h.sin() * sl.cos() + h.cos() * sl.sin() * (az - asp - std::f32::consts::FRAC_PI_2).cos()).clamp(0.0, 1.0)
}
fn png(path: &PathBuf, w: u32, h: u32, rgb: &[u8]) {
let f = std::fs::File::create(path).unwrap();
let mut e = png::Encoder::new(std::io::BufWriter::new(f), w, h);
e.set_color(png::ColorType::Rgb);
e.set_depth(png::BitDepth::Eight);
e.write_header().unwrap().write_image_data(rgb).unwrap();
}
fn rendre(t: &Terrain, c: &CoucheLive, path: &PathBuf) -> f32 {
let mut img = vec![0u8; (N * N * 3) as usize];
let (mut couv, mut tot) = (0usize, 0usize);
for z in 0..N {
for x in 0..N {
let i = (z * N + x) as usize;
let px = &mut img[i * 3..i * 3 + 3];
if !t.ok[i] {
px.copy_from_slice(&[30, 30, 30]);
continue;
}
let sh = 0.45 + 0.75 * hillshade(t, x, z);
let base: [f32; 3] = if t.pente[i] > 42.0 { [128.0, 126.0, 120.0] } else if t.alt[i] < 1900.0 { [66.0, 110.0, 50.0] } else { [118.0, 150.0, 76.0] };
let n = c.manteau.couches(X0 + x, Z0 + z, t.pente[i]);
tot += 1;
let k = (n as f32 / 2.0).min(1.0);
if n > 0 {
couv += 1;
}
for j in 0..3 {
let v = base[j] * (1.0 - k) + 246.0 * k;
px[j] = (v * sh).clamp(0.0, 255.0) as u8;
}
}
}
png(path, N as u32, N as u32, &img);
couv as f32 / tot as f32
}
fn courbe(path: &PathBuf, series: &[(&str, [u8; 3], &Vec<f32>)]) {
let (w, h) = (730usize, 260usize);
let mut img = vec![245u8; w * h * 3];
let mut px = |x: usize, y: usize, c: [u8; 3]| {
if x < w && y < h {
img[(y * w + x) * 3..(y * w + x) * 3 + 3].copy_from_slice(&c);
}
};
for k in 0..=4 {
let y = 10 + (h - 30) * k / 4;
for x in 0..w {
px(x, y, [215, 215, 215]);
}
}
for m in 0..12 {
for y in 10..h - 20 {
px(5 + m * 61, y, [225, 225, 225]);
}
}
for (_, col, v) in series {
for (d, f) in v.iter().enumerate() {
let x = 5 + d * 2;
let y = 10 + ((1.0 - f) * (h - 30) as f32) as usize;
for dy in 0..2 {
px(x, y + dy, *col);
}
}
}
png(path, w as u32, h as u32, &img);
}
fn saison(dir: &str, out: &str) {
let t = charger(dir);
let out = PathBuf::from(out);
std::fs::create_dir_all(&out).unwrap();
// Serie synthetique pour le mode Meteo : annee type seed 11 + coup de froid precoce le 11-14 octobre
let clim = Climat::nouveau(graine(), 1.0);
let mut serie = Serie::default();
let debut = Date::new(2026, 8, 1);
for k in 0..365 {
let d = debut.plus(k);
let mut o = clim.obs(d);
if d >= Date::new(2026, 10, 11) && d <= Date::new(2026, 10, 14) {
o.temp_c = -3.0;
o.precip_mm = 30.0;
}
serie.jours.insert(d, o);
}
std::fs::write(out.join("meteo_synthetique.csv"), serie.vers_csv()).unwrap();
let serie = Serie::depuis_csv(&std::fs::read_to_string(out.join("meteo_synthetique.csv")).unwrap()).unwrap();
let mut stats = String::from("date,climat_pct,meteo_pct,climat_1650_1900,climat_1900_2100,climat_2100_2400\n");
let mut cl = CoucheLive::new(Mode::Climat, manteau(&t), Climat::nouveau(graine(), 1.0), None);
let mut me = CoucheLive::new(Mode::Meteo, manteau(&t), Climat::nouveau(graine(), 1.0), Some(serie));
let (mut vc, mut vm) = (vec![], vec![]);
let rendus = [(2026, 9, 1), (2026, 10, 1), (2026, 10, 15), (2026, 10, 31), (2026, 11, 1), (2026, 12, 1), (2027, 1, 1), (2027, 2, 1), (2027, 3, 1), (2027, 4, 1), (2027, 5, 1), (2027, 6, 1), (2027, 7, 1)];
for k in 0..365 {
let d = debut.plus(k);
cl.avancer_a(d);
me.avancer_a(d);
let (fc, fm) = (cl.manteau.fraction_enneigee(0.0, 9000.0), me.manteau.fraction_enneigee(0.0, 9000.0));
vc.push(fc);
vm.push(fm);
stats += &format!("{d},{:.1},{:.1},{:.1},{:.1},{:.1}\n", 100.0 * fc, 100.0 * fm, 100.0 * cl.manteau.fraction_enneigee(0.0, 1900.0), 100.0 * cl.manteau.fraction_enneigee(1900.0, 2100.0), 100.0 * cl.manteau.fraction_enneigee(2100.0, 9000.0));
if rendus.contains(&(d.annee, d.mois, d.jour)) {
let cv = rendre(&t, &cl, &out.join(format!("climat_{d}.png")));
println!("{d} climat : {:.1} % des colonnes avec au moins 1 couche", 100.0 * cv);
if d.mois == 10 {
let cv = rendre(&t, &me, &out.join(format!("meteo_{d}.png")));
println!("{d} meteo : {:.1} %", 100.0 * cv);
}
}
}
std::fs::write(out.join("stats_saison.csv"), stats).unwrap();
courbe(&out.join("courbe_saison.png"), &[("climat", [30, 90, 200], &vc), ("meteo", [210, 80, 40], &vm)]);
}
fn main() {
let a: Vec<String> = std::env::args().collect();
match a.get(1).map(String::as_str) {
Some("saison") => saison(&a[2], &a[3]),
Some("graines") => {
let t = charger(&a[2]);
for seed in 1..=30u64 {
let mut c = CoucheLive::new(Mode::Climat, manteau(&t), Climat::nouveau(seed, 1.0), None);
let f = |c: &mut CoucheLive, d: Date| { c.avancer_a(d); c.manteau.fraction_enneigee(0.0, 9000.0) };
println!("seed {seed}: 15 oct {:.2} 31 oct {:.2} 15 nov {:.2} 1 jan {:.2} 1 avr {:.2} 15 juin {:.2}", f(&mut c, Date::new(2026,10,15)), f(&mut c, Date::new(2026,10,31)), f(&mut c, Date::new(2026,11,15)), f(&mut c, Date::new(2027,1,1)), f(&mut c, Date::new(2027,4,1)), f(&mut c, Date::new(2027,6,15)));
}
}
Some("calibrage") => calibrage(&a[2]),
_ => eprintln!("usage : saison <tuiles> <sortie> | calibrage <tuiles>"),
}
}