Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
274 lignes
12 KiB
Rust
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>"),
|
|
}
|
|
}
|