rt-live: manteau neigeux degre-jour par cellule de 32 m, delta de chunk idempotent, modes climat/meteo/fige
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Cette révision appartient à :
1 Parent
d4e96c6e47
révision
9690961cd0
10 fichiers modifiés
+1600
Aucun fichier ne correspond à votre recherche
@@ -0,0 +1 @@
|
||||
target/
|
||||
Générée
+137
@@ -0,0 +1,137 @@
|
||||
# This file is automatically @generated by Cargo.
|
||||
# It is not intended for manual editing.
|
||||
version = 4
|
||||
|
||||
[[package]]
|
||||
name = "adler2"
|
||||
version = "2.0.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"
|
||||
|
||||
[[package]]
|
||||
name = "bitflags"
|
||||
version = "1.3.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
|
||||
|
||||
[[package]]
|
||||
name = "cfg-if"
|
||||
version = "1.0.5"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "4e7648175b45a9a48536d676f68d918270699102aa8dab5496df06904c914600"
|
||||
|
||||
[[package]]
|
||||
name = "crc32fast"
|
||||
version = "1.5.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "0ba106e844045ddc02c20768ac4b0b7cb45f2cc2ecbd833ac9f5dacb183c2055"
|
||||
dependencies = [
|
||||
"cfg-if",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "fdeflate"
|
||||
version = "0.3.7"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "1e6853b52649d4ac5c0bd02320cddc5ba956bdb407c4b75a2c6b75bf51500f8c"
|
||||
dependencies = [
|
||||
"simd-adler32",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "flate2"
|
||||
version = "1.1.10"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "6e634e2e0ebac1ee034020da1ca582e17ffe4e0f5e985823721e168928136dcb"
|
||||
dependencies = [
|
||||
"crc32fast",
|
||||
"miniz_oxide 0.9.1",
|
||||
"zlib-rs",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "libc"
|
||||
version = "0.2.191"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "65cd87c9a6d60536580b316ad985726104730a5151c99845f2490428ef91240a"
|
||||
|
||||
[[package]]
|
||||
name = "memmap2"
|
||||
version = "0.9.12"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "6b0ca1155a9ecc25aa12e8313a119f32edf0255fea2f44839c4ac0a12b2ac157"
|
||||
dependencies = [
|
||||
"libc",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "miniz_oxide"
|
||||
version = "0.8.9"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316"
|
||||
dependencies = [
|
||||
"adler2",
|
||||
"simd-adler32",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "miniz_oxide"
|
||||
version = "0.9.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "b63fbc4a50860e98e7b2aa7804ded1db5cbc3aff9193adaff57a6931bf7c4b4c"
|
||||
dependencies = [
|
||||
"adler2",
|
||||
"simd-adler32",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "physique"
|
||||
version = "0.1.0"
|
||||
|
||||
[[package]]
|
||||
name = "png"
|
||||
version = "0.17.16"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "82151a2fc869e011c153adc57cf2789ccb8d9906ce52c0b39a6b5697749d7526"
|
||||
dependencies = [
|
||||
"bitflags",
|
||||
"crc32fast",
|
||||
"fdeflate",
|
||||
"flate2",
|
||||
"miniz_oxide 0.8.9",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "rt-core"
|
||||
version = "0.1.0"
|
||||
|
||||
[[package]]
|
||||
name = "rt-live"
|
||||
version = "0.1.0"
|
||||
dependencies = [
|
||||
"physique",
|
||||
"png",
|
||||
"rt-core",
|
||||
"rt-tiles",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "rt-tiles"
|
||||
version = "0.1.0"
|
||||
dependencies = [
|
||||
"crc32fast",
|
||||
"memmap2",
|
||||
"rt-core",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "simd-adler32"
|
||||
version = "0.3.10"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "3a219298ac11a56ea9a6d2120044824d6f01aeb034955e7af7bc16858527deea"
|
||||
|
||||
[[package]]
|
||||
name = "zlib-rs"
|
||||
version = "0.6.8"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "b268e58e7c693d7c271f93ffc4ba3b380412554231c85bf61ca7af91042a4112"
|
||||
@@ -0,0 +1,14 @@
|
||||
[package]
|
||||
name = "rt-live"
|
||||
version = "0.1.0"
|
||||
edition = "2021"
|
||||
license = "GPL-3.0-only"
|
||||
description = "Couche dynamique (neige degre-jour, glace, feuilles, niveau d eau), independante de Pumpkin"
|
||||
|
||||
[dependencies]
|
||||
physique = { path = "../physique" }
|
||||
|
||||
[dev-dependencies]
|
||||
png = "0.17"
|
||||
rt-core = { path = "../relief/rt-core" }
|
||||
rt-tiles = { path = "../relief/rt-tiles" }
|
||||
@@ -0,0 +1,273 @@
|
||||
//! 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>"),
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,78 @@
|
||||
//! Date civile sans dependance (algorithmes de Howard Hinnant).
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
pub struct Date {
|
||||
pub annee: i32,
|
||||
pub mois: u32,
|
||||
pub jour: u32,
|
||||
}
|
||||
|
||||
const CUM: [u32; 12] = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334];
|
||||
|
||||
impl Date {
|
||||
pub fn new(annee: i32, mois: u32, jour: u32) -> Date {
|
||||
Date { annee, mois: mois.clamp(1, 12), jour: jour.clamp(1, 31) }
|
||||
}
|
||||
/// Jours depuis le 1970-01-01.
|
||||
pub fn ordinal(self) -> i64 {
|
||||
let y = (if self.mois <= 2 { self.annee - 1 } else { self.annee }) as i64;
|
||||
let era = y.div_euclid(400);
|
||||
let yoe = y - era * 400;
|
||||
let mp = (self.mois as i64 + 9) % 12;
|
||||
let doy = (153 * mp + 2) / 5 + self.jour as i64 - 1;
|
||||
let doe = yoe * 365 + yoe / 4 - yoe / 100 + doy;
|
||||
era * 146_097 + doe - 719_468
|
||||
}
|
||||
pub fn depuis_ordinal(n: i64) -> Date {
|
||||
let z = n + 719_468;
|
||||
let era = z.div_euclid(146_097);
|
||||
let doe = z - era * 146_097;
|
||||
let yoe = (doe - doe / 1460 + doe / 36_524 - doe / 146_096) / 365;
|
||||
let doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
|
||||
let mp = (5 * doy + 2) / 153;
|
||||
let jour = (doy - (153 * mp + 2) / 5 + 1) as u32;
|
||||
let mois = (if mp < 10 { mp + 3 } else { mp - 9 }) as u32;
|
||||
let annee = (yoe + era * 400) as i32 + if mois <= 2 { 1 } else { 0 };
|
||||
Date { annee, mois, jour }
|
||||
}
|
||||
pub fn plus(self, n: i64) -> Date {
|
||||
Date::depuis_ordinal(self.ordinal() + n)
|
||||
}
|
||||
pub fn bissextile(a: i32) -> bool {
|
||||
(a % 4 == 0 && a % 100 != 0) || a % 400 == 0
|
||||
}
|
||||
/// 1..=366.
|
||||
pub fn jour_annee(self) -> u32 {
|
||||
CUM[(self.mois - 1) as usize] + self.jour + u32::from(self.mois > 2 && Date::bissextile(self.annee))
|
||||
}
|
||||
/// 1..=365, le 29 fevrier compte comme le 28.
|
||||
pub fn jour_annee_365(self) -> u32 {
|
||||
if self.mois == 2 && self.jour >= 29 { 59 } else { CUM[(self.mois - 1) as usize] + self.jour }
|
||||
}
|
||||
/// 1er aout precedent ou egal : debut de l'annee hydrologique (neige nulle).
|
||||
pub fn debut_annee_hydro(self) -> Date {
|
||||
Date::new(if self.mois >= 8 { self.annee } else { self.annee - 1 }, 8, 1)
|
||||
}
|
||||
/// Index 0..365 depuis le 1er aout (annee a 365 jours).
|
||||
pub fn index_hydro(self) -> usize {
|
||||
((self.jour_annee_365() + 365 - 213) % 365) as usize
|
||||
}
|
||||
pub fn parse(s: &str) -> Result<Date, String> {
|
||||
let p: Vec<&str> = s.trim().split('-').collect();
|
||||
if p.len() != 3 {
|
||||
return Err(format!("date invalide '{s}'"));
|
||||
}
|
||||
let n = |x: &str| x.trim().parse::<i32>().map_err(|_| format!("date invalide '{s}'"));
|
||||
let (a, m, j) = (n(p[0])?, n(p[1])?, n(p[2])?);
|
||||
if !(1..=12).contains(&m) || !(1..=31).contains(&j) {
|
||||
return Err(format!("date hors plage '{s}'"));
|
||||
}
|
||||
Ok(Date { annee: a, mois: m as u32, jour: j as u32 })
|
||||
}
|
||||
}
|
||||
|
||||
impl std::fmt::Display for Date {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
write!(f, "{:04}-{:02}-{:02}", self.annee, self.mois, self.jour)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,216 @@
|
||||
//! Calcul idempotent des modifications de blocs d'un chunk.
|
||||
//!
|
||||
//! Principe : pour chaque position concernee, l'etat CIBLE est une fonction pure de
|
||||
//! (date, manteau, entree du chunk). La modification n'est emise que si le bloc ACTUEL (fourni
|
||||
//! par l'appelant) differe de la cible et appartient a la classe modifiable. Appliquer le delta
|
||||
//! puis recalculer donne donc un delta vide. Les blocs poses par un joueur ne sont jamais touches.
|
||||
|
||||
use crate::manteau::{hash01, Manteau};
|
||||
use std::collections::HashSet;
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
|
||||
pub enum Feuille {
|
||||
Verte,
|
||||
Jaune,
|
||||
Rousse,
|
||||
}
|
||||
|
||||
/// Bloc abstrait (converti en bloc Pumpkin par la couche d'integration).
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
|
||||
pub enum Bloc {
|
||||
Air,
|
||||
/// Couches de neige 1..=8.
|
||||
Neige(u8),
|
||||
Glace,
|
||||
Eau,
|
||||
Feuille(Feuille),
|
||||
/// Tout autre bloc : jamais modifie.
|
||||
Autre,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub enum Surface {
|
||||
Sol,
|
||||
Roche,
|
||||
Route,
|
||||
Bati,
|
||||
/// `lac` : eau calme (gele) ; sinon riviere (niveau saisonnier, ne gele pas).
|
||||
Eau { lac: bool },
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
pub struct Colonne {
|
||||
/// y du bloc solide le plus haut (fond pour l'eau).
|
||||
pub sol_y: i32,
|
||||
pub surface: Surface,
|
||||
pub pente_deg: f32,
|
||||
/// Altitude reelle en m (temperature).
|
||||
pub alt_m: f32,
|
||||
/// y nominal du bloc d'eau de surface (surfaces d'eau seulement).
|
||||
pub eau_y: i32,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub enum Essence {
|
||||
Hetre,
|
||||
Chene,
|
||||
Bouleau,
|
||||
Meleze,
|
||||
}
|
||||
|
||||
/// Bloc de feuillage d'un arbre caduc, tel que genere statiquement.
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
pub struct FeuilleEntree {
|
||||
pub x: i32,
|
||||
pub y: i32,
|
||||
pub z: i32,
|
||||
pub essence: Essence,
|
||||
pub alt_m: f32,
|
||||
}
|
||||
|
||||
pub struct ChunkEntree {
|
||||
pub cx: i32,
|
||||
pub cz: i32,
|
||||
/// 256 colonnes, index lz * 16 + lx.
|
||||
pub colonnes: Vec<Colonne>,
|
||||
pub feuilles: Vec<FeuilleEntree>,
|
||||
}
|
||||
|
||||
/// Blocs poses ou casses par un joueur : colonnes entieres (bitset 16x16) et blocs isoles.
|
||||
#[derive(Clone, Debug, Default)]
|
||||
pub struct MasqueJoueur {
|
||||
cols: [u64; 4],
|
||||
blocs: HashSet<(i32, i32, i32)>,
|
||||
}
|
||||
|
||||
impl MasqueJoueur {
|
||||
pub fn marquer_colonne(&mut self, lx: usize, lz: usize) {
|
||||
let i = lz * 16 + lx;
|
||||
self.cols[i / 64] |= 1 << (i % 64);
|
||||
}
|
||||
pub fn marquer_bloc(&mut self, x: i32, y: i32, z: i32) {
|
||||
self.blocs.insert((x, y, z));
|
||||
}
|
||||
pub fn touche(&self, x: i32, y: i32, z: i32) -> bool {
|
||||
let i = (z.rem_euclid(16) * 16 + x.rem_euclid(16)) as usize;
|
||||
self.cols[i / 64] >> (i % 64) & 1 == 1 || self.blocs.contains(&(x, y, z))
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub struct Modif {
|
||||
pub x: i32,
|
||||
pub y: i32,
|
||||
pub z: i32,
|
||||
pub avant: Bloc,
|
||||
pub apres: Bloc,
|
||||
}
|
||||
|
||||
/// Etat atmospherique et saisonnier necessaire au calcul (fourni par `CoucheLive`).
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
pub struct Contexte {
|
||||
pub jour_annee: u32,
|
||||
pub mois: u32,
|
||||
/// Moyenne des minimas journaliers des 7 derniers jours a la station de reference.
|
||||
pub tmin7_ref_c: f32,
|
||||
pub alt_ref_m: f32,
|
||||
}
|
||||
|
||||
/// Decalage du niveau des rivieres (blocs) selon le debit saisonnier relatif.
|
||||
pub fn decalage_niveau_eau(mois: u32) -> i32 {
|
||||
((physique::debit_relatif(mois) - 1.0) * 1.2).round() as i32
|
||||
}
|
||||
|
||||
/// Etat des feuilles d'un caduc : `None` = absente.
|
||||
pub fn etat_feuille(f: &FeuilleEntree, jour_annee: u32) -> Option<Feuille> {
|
||||
let frac = physique::feuillage(jour_annee, f.alt_m);
|
||||
if frac <= 0.0 {
|
||||
return None;
|
||||
}
|
||||
let h = hash01(f.x.wrapping_add(f.y * 31), f.z, 99);
|
||||
if h >= frac {
|
||||
return None; // feuillage clairseme en debut/fin de saison
|
||||
}
|
||||
if jour_annee < 200 {
|
||||
return Some(Feuille::Verte);
|
||||
}
|
||||
Some(if frac > 0.85 {
|
||||
Feuille::Verte
|
||||
} else if frac > 0.45 || matches!(f.essence, Essence::Meleze | Essence::Bouleau) {
|
||||
Feuille::Jaune
|
||||
} else {
|
||||
Feuille::Rousse
|
||||
})
|
||||
}
|
||||
|
||||
impl Manteau {
|
||||
/// Delta du chunk. `actuel(x, y, z)` donne le bloc actuellement dans le monde.
|
||||
pub fn delta_chunk(
|
||||
&self,
|
||||
e: &ChunkEntree,
|
||||
ctx: &Contexte,
|
||||
masque: &MasqueJoueur,
|
||||
actuel: &dyn Fn(i32, i32, i32) -> Bloc,
|
||||
) -> Vec<Modif> {
|
||||
let mut out = Vec::new();
|
||||
let mut maj = |x: i32, y: i32, z: i32, cible: Bloc, modifiables: &[Bloc]| {
|
||||
if masque.touche(x, y, z) {
|
||||
return;
|
||||
}
|
||||
let a = actuel(x, y, z);
|
||||
if a == cible {
|
||||
return;
|
||||
}
|
||||
let ok = modifiables.iter().any(|m| match (m, a) {
|
||||
(Bloc::Neige(0), Bloc::Neige(_)) => true,
|
||||
(Bloc::Feuille(Feuille::Verte), Bloc::Feuille(_)) => true,
|
||||
(m, a) => *m == a,
|
||||
});
|
||||
if ok {
|
||||
out.push(Modif { x, y, z, avant: a, apres: cible });
|
||||
}
|
||||
};
|
||||
let off_eau = decalage_niveau_eau(ctx.mois);
|
||||
for lz in 0..16 {
|
||||
for lx in 0..16 {
|
||||
let c = &e.colonnes[lz * 16 + lx];
|
||||
let (x, z) = (e.cx * 16 + lx as i32, e.cz * 16 + lz as i32);
|
||||
match c.surface {
|
||||
Surface::Sol | Surface::Route => {
|
||||
let mut n = self.couches(x, z, c.pente_deg);
|
||||
if c.surface == Surface::Route {
|
||||
n = n.min(2);
|
||||
}
|
||||
let cible = if n == 0 { Bloc::Air } else { Bloc::Neige(n) };
|
||||
maj(x, c.sol_y + 1, z, cible, &[Bloc::Air, Bloc::Neige(0)]);
|
||||
}
|
||||
Surface::Roche | Surface::Bati => {}
|
||||
Surface::Eau { lac: true } => {
|
||||
let t7 = physique::temp_a_altitude(ctx.tmin7_ref_c, ctx.alt_ref_m, c.alt_m);
|
||||
let cible = if physique::lac_gele(t7) { Bloc::Glace } else { Bloc::Eau };
|
||||
maj(x, c.eau_y, z, cible, &[Bloc::Eau, Bloc::Glace]);
|
||||
}
|
||||
Surface::Eau { lac: false } => {
|
||||
// Niveau saisonnier : seul le bloc de surface nominal et celui du dessus bougent.
|
||||
let haut = c.eau_y + off_eau;
|
||||
if haut > c.sol_y {
|
||||
for y in [c.eau_y, c.eau_y + 1] {
|
||||
let cible = if y <= haut { Bloc::Eau } else { Bloc::Air };
|
||||
maj(x, y, z, cible, &[Bloc::Air, Bloc::Eau]);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
for f in &e.feuilles {
|
||||
let cible = match etat_feuille(f, ctx.jour_annee) {
|
||||
Some(s) => Bloc::Feuille(s),
|
||||
None => Bloc::Air,
|
||||
};
|
||||
maj(f.x, f.y, f.z, cible, &[Bloc::Air, Bloc::Feuille(Feuille::Verte)]);
|
||||
}
|
||||
out.sort_by_key(|m| (m.x, m.y, m.z));
|
||||
out
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,97 @@
|
||||
//! rt-live : couche dynamique du monde (neige degre-jour, glace, feuilles, niveau d'eau).
|
||||
//! Independante de Pumpkin : l'integration fournit les blocs actuels et applique le delta.
|
||||
|
||||
pub mod date;
|
||||
pub mod delta;
|
||||
pub mod manteau;
|
||||
pub mod meteo;
|
||||
|
||||
pub use date::Date;
|
||||
pub use delta::{Bloc, ChunkEntree, Colonne, Contexte, Essence, Feuille, FeuilleEntree, MasqueJoueur, Modif, Surface};
|
||||
pub use manteau::{Cellule, Manteau, Params};
|
||||
pub use meteo::{Climat, Obs, Serie};
|
||||
|
||||
/// Mode de fonctionnement.
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub enum Mode {
|
||||
/// Normales climatiques (annee type synthetique, date reelle).
|
||||
Climat,
|
||||
/// Serie reelle (CSV) ; jours manquants et periode avant la serie : repli sur le climat.
|
||||
Meteo,
|
||||
/// Date imposee, aucune evolution.
|
||||
Fige(Date),
|
||||
}
|
||||
|
||||
pub struct CoucheLive {
|
||||
pub mode: Mode,
|
||||
pub manteau: Manteau,
|
||||
pub climat: Climat,
|
||||
pub serie: Option<Serie>,
|
||||
/// Nombre de jours simules par repli sur le climat en mode Meteo.
|
||||
pub jours_repli: usize,
|
||||
date: Option<Date>,
|
||||
tmin: [f32; 7],
|
||||
}
|
||||
|
||||
impl CoucheLive {
|
||||
pub fn new(mode: Mode, manteau: Manteau, climat: Climat, serie: Option<Serie>) -> CoucheLive {
|
||||
CoucheLive { mode, manteau, climat, serie, jours_repli: 0, date: None, tmin: [0.0; 7] }
|
||||
}
|
||||
pub fn date(&self) -> Option<Date> {
|
||||
self.date
|
||||
}
|
||||
fn obs(&mut self, d: Date) -> Obs {
|
||||
if self.mode == Mode::Meteo {
|
||||
if let Some(o) = self.serie.as_ref().and_then(|s| s.get(d)) {
|
||||
return o;
|
||||
}
|
||||
self.jours_repli += 1;
|
||||
}
|
||||
self.climat.obs(d)
|
||||
}
|
||||
/// Amene l'etat a `date` (ignoree en mode Fige). Un retour en arriere ou un saut de plus d'un an
|
||||
/// re-simule depuis le 1er aout de l'annee hydrologique : le resultat ne depend que de la date.
|
||||
pub fn avancer_a(&mut self, date: Date) {
|
||||
let cible = if let Mode::Fige(d) = self.mode { d } else { date };
|
||||
let depart = match self.date {
|
||||
Some(d) if d <= cible && cible.ordinal() - d.ordinal() <= 366 => d.plus(1),
|
||||
_ => {
|
||||
self.manteau.reinitialiser();
|
||||
self.jours_repli = 0;
|
||||
cible.debut_annee_hydro()
|
||||
}
|
||||
};
|
||||
if self.date == Some(cible) {
|
||||
return;
|
||||
}
|
||||
let mut d = depart;
|
||||
while d <= cible {
|
||||
let o = self.obs(d);
|
||||
let amp = self.manteau.p.amplitude_c(d.jour_annee_365());
|
||||
self.manteau.pas_jour(d, o.temp_c, o.precip_mm);
|
||||
self.tmin.rotate_left(1);
|
||||
self.tmin[6] = o.temp_c - amp;
|
||||
d = d.plus(1);
|
||||
}
|
||||
self.date = Some(cible);
|
||||
}
|
||||
pub fn contexte(&self) -> Option<Contexte> {
|
||||
let d = self.date?;
|
||||
Some(Contexte {
|
||||
jour_annee: d.jour_annee(),
|
||||
mois: d.mois,
|
||||
tmin7_ref_c: self.tmin.iter().sum::<f32>() / 7.0,
|
||||
alt_ref_m: self.manteau.p.alt_ref_m,
|
||||
})
|
||||
}
|
||||
/// Delta d'un chunk a la date courante (apres `avancer_a`).
|
||||
pub fn delta_chunk(&self, e: &ChunkEntree, masque: &MasqueJoueur, actuel: &dyn Fn(i32, i32, i32) -> Bloc) -> Vec<Modif> {
|
||||
match self.contexte() {
|
||||
Some(ctx) => self.manteau.delta_chunk(e, &ctx, masque, actuel),
|
||||
None => Vec::new(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests;
|
||||
@@ -0,0 +1,257 @@
|
||||
//! Manteau neigeux degre-jour par cellule (32 m) : accumulation, fonte, effet adret/ubac.
|
||||
|
||||
use crate::date::Date;
|
||||
|
||||
/// Description statique d'une cellule (moyennes sur 32x32 blocs).
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
pub struct Cellule {
|
||||
pub alt_m: f32,
|
||||
pub pente_deg: f32,
|
||||
/// Azimut de la descente de pente (0 = nord, 90 = est, 180 = sud : versant sud = adret).
|
||||
pub aspect_deg: f32,
|
||||
}
|
||||
|
||||
/// Parametres du modele. Valeurs recalees sur le Veymont (voir rapport 12b) [A VERIFIER].
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
pub struct Params {
|
||||
pub alt_ref_m: f32,
|
||||
pub lat_deg: f32,
|
||||
/// Facteur degre-jour de la neige, mm par degre-jour (Alpes : 3 a 6).
|
||||
pub ddf_mm: f32,
|
||||
/// Poids du terme de rayonnement dans la fonte (0 = pas d'effet d'exposition).
|
||||
pub k_rad: f32,
|
||||
/// Temperature (moyenne du jour, a la cellule) sous laquelle tout est neige.
|
||||
pub t_neige_c: f32,
|
||||
/// Temperature au-dessus de laquelle tout est pluie.
|
||||
pub t_pluie_c: f32,
|
||||
/// Gain relatif de precipitation par 100 m (effet orographique).
|
||||
pub gain_precip_100m: f32,
|
||||
pub gain_precip_max: f32,
|
||||
/// Fonte basale (chaleur du sol) en mm/jour en automne, puis `fonte_sol_hiver_mm`.
|
||||
pub fonte_sol_automne_mm: f32,
|
||||
pub fonte_sol_hiver_mm: f32,
|
||||
/// Amplitude diurne (demi-ecart) hiver / ete, C.
|
||||
pub amp_hiver_c: f32,
|
||||
pub amp_ete_c: f32,
|
||||
}
|
||||
|
||||
impl Default for Params {
|
||||
fn default() -> Self {
|
||||
Params {
|
||||
alt_ref_m: 1000.0,
|
||||
lat_deg: 44.9,
|
||||
ddf_mm: 5.0,
|
||||
k_rad: 0.6,
|
||||
t_neige_c: 0.0,
|
||||
t_pluie_c: 2.0,
|
||||
gain_precip_100m: 0.02,
|
||||
gain_precip_max: 1.6,
|
||||
fonte_sol_automne_mm: 4.0,
|
||||
fonte_sol_hiver_mm: 0.3,
|
||||
amp_hiver_c: 3.0,
|
||||
amp_ete_c: 6.0,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Params {
|
||||
pub fn amplitude_c(&self, doy365: u32) -> f32 {
|
||||
let s = 0.5 - 0.5 * (std::f32::consts::TAU * (doy365 as f32 - 20.0) / 365.0).cos(); // 0 hiver, 1 ete
|
||||
self.amp_hiver_c + (self.amp_ete_c - self.amp_hiver_c) * s
|
||||
}
|
||||
}
|
||||
|
||||
/// Moyenne sur la journee de max(T, 0) pour T = tm + a sin(theta) (degres-jours positifs).
|
||||
pub fn degres_jours_positifs(tm: f32, a: f32) -> f32 {
|
||||
if a <= 1e-4 {
|
||||
return tm.max(0.0);
|
||||
}
|
||||
if tm >= a {
|
||||
return tm;
|
||||
}
|
||||
if tm <= -a {
|
||||
return 0.0;
|
||||
}
|
||||
let al = (tm / a).asin();
|
||||
(tm * (std::f32::consts::PI + 2.0 * al) + 2.0 * a * al.cos()) / std::f32::consts::TAU
|
||||
}
|
||||
|
||||
/// Facteur d'accumulation selon la pente (la neige glisse sur les pentes raides).
|
||||
pub fn facteur_pente(pente_deg: f32) -> f32 {
|
||||
if pente_deg <= 30.0 {
|
||||
1.0
|
||||
} else if pente_deg <= 40.0 {
|
||||
1.0 - 0.5 * (pente_deg - 30.0) / 10.0
|
||||
} else if pente_deg <= 55.0 {
|
||||
0.5 * (55.0 - pente_deg) / 15.0
|
||||
} else {
|
||||
0.0
|
||||
}
|
||||
}
|
||||
|
||||
/// Facteur de hauteur selon la pente locale d'une colonne : parois > 50 deg nues, demi-epaisseur > 35 deg
|
||||
/// (meme convention que `physique::couche_neige`).
|
||||
pub fn facteur_pente_colonne(pente_deg: f32) -> f32 {
|
||||
if pente_deg > 50.0 { 0.0 } else if pente_deg > 35.0 { 0.5 } else { 1.0 }
|
||||
}
|
||||
|
||||
/// Hauteur de neige (m) pour un equivalent en eau (mm) : densite 0,10 (fraiche) a 0,35 (tassee).
|
||||
pub fn hauteur_m(swe_mm: f32) -> f32 {
|
||||
let rho = 0.10 + 0.25 * (1.0 - (-swe_mm / 300.0).exp());
|
||||
swe_mm / 1000.0 / rho
|
||||
}
|
||||
|
||||
pub fn hash01(x: i32, z: i32, graine: u32) -> f32 {
|
||||
let mut h = (x as u32).wrapping_mul(0x9E37_79B1) ^ (z as u32).wrapping_mul(0x85EB_CA77) ^ graine.wrapping_mul(0xC2B2_AE3D);
|
||||
h ^= h >> 15;
|
||||
h = h.wrapping_mul(0x2C1B_3C6D);
|
||||
h ^= h >> 12;
|
||||
h = h.wrapping_mul(0x297A_2D39);
|
||||
h ^= h >> 15;
|
||||
(h >> 8) as f32 / (1u32 << 24) as f32
|
||||
}
|
||||
|
||||
pub struct Manteau {
|
||||
pub p: Params,
|
||||
pub cellule_m: i32,
|
||||
pub x0: i32,
|
||||
pub z0: i32,
|
||||
pub w: usize,
|
||||
pub h: usize,
|
||||
/// Equivalent en eau, dixiemes de mm (u16 : 6 553 mm max).
|
||||
swe: Vec<u16>,
|
||||
infos: Vec<Cellule>,
|
||||
/// cos(pente), sin(pente), cos(aspect) precalcules.
|
||||
geo: Vec<[f32; 3]>,
|
||||
derniere: Option<Date>,
|
||||
}
|
||||
|
||||
impl Manteau {
|
||||
/// `cellule(ix, iz)` decrit la cellule dont le coin nord-ouest est (x0 + 32 ix, z0 + 32 iz).
|
||||
pub fn nouveau(p: Params, cellule_m: i32, x0: i32, z0: i32, w: usize, h: usize, cellule: impl Fn(usize, usize) -> Cellule) -> Manteau {
|
||||
let mut infos = Vec::with_capacity(w * h);
|
||||
for iz in 0..h {
|
||||
for ix in 0..w {
|
||||
infos.push(cellule(ix, iz));
|
||||
}
|
||||
}
|
||||
let geo = infos
|
||||
.iter()
|
||||
.map(|c| {
|
||||
let s = c.pente_deg.to_radians();
|
||||
[s.cos(), s.sin(), c.aspect_deg.to_radians().cos()]
|
||||
})
|
||||
.collect();
|
||||
Manteau { p, cellule_m, x0, z0, w, h, swe: vec![0; w * h], infos, geo, derniere: None }
|
||||
}
|
||||
pub fn reinitialiser(&mut self) {
|
||||
self.swe.iter_mut().for_each(|s| *s = 0);
|
||||
self.derniere = None;
|
||||
}
|
||||
pub fn derniere(&self) -> Option<Date> {
|
||||
self.derniere
|
||||
}
|
||||
pub fn cellule(&self, ix: usize, iz: usize) -> Cellule {
|
||||
self.infos[iz * self.w + ix]
|
||||
}
|
||||
pub fn swe_cellule_mm(&self, ix: usize, iz: usize) -> f32 {
|
||||
self.swe[iz * self.w + ix] as f32 / 10.0
|
||||
}
|
||||
pub fn fixer_swe_mm(&mut self, ix: usize, iz: usize, mm: f32) {
|
||||
self.swe[iz * self.w + ix] = (mm * 10.0).round().clamp(0.0, 65535.0) as u16;
|
||||
}
|
||||
|
||||
/// Facteur de fonte lie au rayonnement direct a midi solaire (1 = terrain plat) :
|
||||
/// cos(incidence) sur la pente / sin(hauteur du soleil), borne.
|
||||
pub fn facteur_rayonnement(&self, g: [f32; 3], doy: u32) -> f32 {
|
||||
let decl = 23.44f32.to_radians() * ((360.0 / 365.0 * (doy as f32 - 81.0)).to_radians()).sin();
|
||||
let haut = std::f32::consts::FRAC_PI_2 - self.p.lat_deg.to_radians() + decl;
|
||||
let (sh, ch) = (haut.sin().max(0.05), haut.cos());
|
||||
let cos_i = g[0] * sh - g[1] * ch * g[2];
|
||||
let rf = cos_i.max(0.0) / sh;
|
||||
(1.0 + self.p.k_rad * (rf - 1.0)).clamp(0.25, 2.2)
|
||||
}
|
||||
|
||||
/// Un jour de simulation. Idempotent : une date deja appliquee (ou anterieure) est ignoree.
|
||||
/// Renvoie `false` si ignoree.
|
||||
pub fn pas_jour(&mut self, date: Date, temp_ref_c: f32, precip_ref_mm: f32) -> bool {
|
||||
if let Some(d) = self.derniere {
|
||||
if date <= d {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
let doy = date.jour_annee_365();
|
||||
let amp = self.p.amplitude_c(doy);
|
||||
let jh = ((doy + 365 - 213) % 365) as f32; // jours depuis le 1er aout
|
||||
let sol = if jh <= 90.0 {
|
||||
self.p.fonte_sol_automne_mm
|
||||
} else if jh < 150.0 {
|
||||
self.p.fonte_sol_automne_mm + (self.p.fonte_sol_hiver_mm - self.p.fonte_sol_automne_mm) * (jh - 90.0) / 60.0
|
||||
} else {
|
||||
self.p.fonte_sol_hiver_mm
|
||||
};
|
||||
for i in 0..self.swe.len() {
|
||||
let c = self.infos[i];
|
||||
let tm = physique::temp_a_altitude(temp_ref_c, self.p.alt_ref_m, c.alt_m);
|
||||
let mut s = self.swe[i] as f32 / 10.0;
|
||||
// Accumulation
|
||||
let gain = (1.0 + self.p.gain_precip_100m * (c.alt_m - self.p.alt_ref_m) / 100.0).clamp(0.5, self.p.gain_precip_max);
|
||||
let frac_neige = ((self.p.t_pluie_c - tm) / (self.p.t_pluie_c - self.p.t_neige_c)).clamp(0.0, 1.0);
|
||||
s += precip_ref_mm * gain * frac_neige * facteur_pente(c.pente_deg);
|
||||
// Fonte degre-jour modulee par l'exposition, plus fonte basale
|
||||
if s > 0.0 {
|
||||
let fr = self.facteur_rayonnement(self.geo[i], doy);
|
||||
let fonte = self.p.ddf_mm * fr * degres_jours_positifs(tm, amp) + sol;
|
||||
s = (s - fonte).max(0.0);
|
||||
}
|
||||
self.swe[i] = (s * 10.0).round().clamp(0.0, 65535.0) as u16;
|
||||
}
|
||||
self.derniere = Some(date);
|
||||
true
|
||||
}
|
||||
|
||||
/// Equivalent en eau (mm) interpole bilineairement entre centres de cellules.
|
||||
pub fn swe_mm_a(&self, bx: i32, bz: i32) -> f32 {
|
||||
let c = self.cellule_m as f32;
|
||||
let fx = ((bx - self.x0) as f32 + 0.5) / c - 0.5;
|
||||
let fz = ((bz - self.z0) as f32 + 0.5) / c - 0.5;
|
||||
let (ix, iz) = (fx.floor(), fz.floor());
|
||||
let (tx, tz) = (fx - ix, fz - iz);
|
||||
let g = |x: f32, z: f32| {
|
||||
let xi = (x as i64).clamp(0, self.w as i64 - 1) as usize;
|
||||
let zi = (z as i64).clamp(0, self.h as i64 - 1) as usize;
|
||||
self.swe[zi * self.w + xi] as f32 / 10.0
|
||||
};
|
||||
let a = g(ix, iz) * (1.0 - tx) + g(ix + 1.0, iz) * tx;
|
||||
let b = g(ix, iz + 1.0) * (1.0 - tx) + g(ix + 1.0, iz + 1.0) * tx;
|
||||
a * (1.0 - tz) + b * tz
|
||||
}
|
||||
|
||||
/// Couches de neige Minecraft (0..=8) sur la colonne, selon la pente locale (blocs).
|
||||
/// Dithering deterministe par colonne pour des limites naturelles.
|
||||
pub fn couches(&self, bx: i32, bz: i32, pente_deg: f32) -> u8 {
|
||||
let swe = self.swe_mm_a(bx, bz);
|
||||
if swe < 3.0 {
|
||||
return 0;
|
||||
}
|
||||
let f = hauteur_m(swe) / 0.125 * facteur_pente_colonne(pente_deg);
|
||||
if f < 0.25 {
|
||||
return 0;
|
||||
}
|
||||
((f + hash01(bx, bz, 7)).floor() as i64).clamp(0, 8) as u8
|
||||
}
|
||||
|
||||
/// Part de cellules couvertes (>= 8 mm d'equivalent en eau, soit ~3 cm) dans [alt_min, alt_max[.
|
||||
pub fn fraction_enneigee(&self, alt_min: f32, alt_max: f32) -> f32 {
|
||||
let (mut n, mut tot) = (0usize, 0usize);
|
||||
for (i, c) in self.infos.iter().enumerate() {
|
||||
if c.alt_m >= alt_min && c.alt_m < alt_max {
|
||||
tot += 1;
|
||||
if self.swe[i] >= 80 {
|
||||
n += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
if tot == 0 { 0.0 } else { n as f32 / tot as f32 }
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,145 @@
|
||||
//! Series meteo d'entree : CSV reel/synthetique et generateur climatique (normales + variabilite).
|
||||
|
||||
use crate::date::Date;
|
||||
use std::collections::BTreeMap;
|
||||
|
||||
/// Observation journaliere a la station de reference.
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub struct Obs {
|
||||
pub temp_c: f32,
|
||||
pub precip_mm: f32,
|
||||
}
|
||||
|
||||
/// Serie journaliere. Format CSV : `date,temp,precip` (YYYY-MM-DD ; degres C moyens du jour ;
|
||||
/// mm/jour), separateur `,` ou `;`, en-tete et lignes `#` ignorees.
|
||||
#[derive(Clone, Debug, Default)]
|
||||
pub struct Serie {
|
||||
pub jours: BTreeMap<Date, Obs>,
|
||||
}
|
||||
|
||||
impl Serie {
|
||||
pub fn depuis_csv(texte: &str) -> Result<Serie, String> {
|
||||
let mut jours = BTreeMap::new();
|
||||
for (i, l) in texte.lines().enumerate() {
|
||||
let l = l.trim();
|
||||
if l.is_empty() || l.starts_with('#') {
|
||||
continue;
|
||||
}
|
||||
let c: Vec<&str> = l.split(|ch| ch == ',' || ch == ';').map(str::trim).collect();
|
||||
let Ok(d) = Date::parse(c[0]) else {
|
||||
if jours.is_empty() {
|
||||
continue; // en-tete
|
||||
}
|
||||
return Err(format!("ligne {} : date invalide", i + 1));
|
||||
};
|
||||
let nb = |k: usize| -> Result<f32, String> {
|
||||
match c.get(k) {
|
||||
None => Err(format!("ligne {} : champ {} manquant", i + 1, k + 1)),
|
||||
Some(s) if s.is_empty() => Ok(0.0),
|
||||
Some(s) => s.parse::<f32>().map_err(|_| format!("ligne {} : nombre invalide '{s}'", i + 1)),
|
||||
}
|
||||
};
|
||||
jours.insert(d, Obs { temp_c: nb(1)?, precip_mm: nb(2)?.max(0.0) });
|
||||
}
|
||||
if jours.is_empty() {
|
||||
return Err("serie vide".into());
|
||||
}
|
||||
Ok(Serie { jours })
|
||||
}
|
||||
pub fn vers_csv(&self) -> String {
|
||||
let mut s = String::from("date,temp,precip\n");
|
||||
for (d, o) in &self.jours {
|
||||
s += &format!("{d},{:.1},{:.1}\n", o.temp_c, o.precip_mm);
|
||||
}
|
||||
s
|
||||
}
|
||||
pub fn get(&self, d: Date) -> Option<Obs> {
|
||||
self.jours.get(&d).copied()
|
||||
}
|
||||
}
|
||||
|
||||
/// Precipitations mensuelles a 1000 m (Hauts-Plateaux nord, ~1 470 mm/an) [A VERIFIER].
|
||||
pub const PRECIP_MM_1000M: [f32; 12] = [120.0, 105.0, 115.0, 125.0, 135.0, 120.0, 90.0, 110.0, 125.0, 150.0, 145.0, 130.0];
|
||||
const JOURS_MOIS: [f32; 12] = [31.0, 28.0, 31.0, 30.0, 31.0, 30.0, 31.0, 31.0, 30.0, 31.0, 30.0, 31.0];
|
||||
|
||||
struct Rng(u64);
|
||||
impl Rng {
|
||||
fn u64(&mut self) -> u64 {
|
||||
self.0 = self.0.wrapping_add(0x9E37_79B9_7F4A_7C15);
|
||||
let mut z = self.0;
|
||||
z = (z ^ (z >> 30)).wrapping_mul(0xBF58_476D_1CE4_E5B9);
|
||||
z = (z ^ (z >> 27)).wrapping_mul(0x94D0_49BB_1331_11EB);
|
||||
z ^ (z >> 31)
|
||||
}
|
||||
fn u01(&mut self) -> f32 {
|
||||
(self.u64() >> 40) as f32 / (1u64 << 24) as f32
|
||||
}
|
||||
fn normal(&mut self) -> f32 {
|
||||
let (a, b) = (self.u01().max(1e-7), self.u01());
|
||||
(-2.0 * a.ln()).sqrt() * (std::f32::consts::TAU * b).cos()
|
||||
}
|
||||
}
|
||||
|
||||
/// Temperature normale du jour (interpolation entre milieux de mois), station a 1000 m.
|
||||
pub fn temp_normale(doy365: u32) -> f32 {
|
||||
let mut mid = [0f32; 12];
|
||||
let mut cum = 0.0;
|
||||
for m in 0..12 {
|
||||
mid[m] = cum + JOURS_MOIS[m] / 2.0;
|
||||
cum += JOURS_MOIS[m];
|
||||
}
|
||||
let d = doy365 as f32 - 0.5;
|
||||
let t = |m: usize| physique::temp_moyenne_1000m(m as u32 + 1);
|
||||
let dd = if d < mid[0] { d + 365.0 } else { d };
|
||||
for m in 0..12 {
|
||||
let m2 = (m + 1) % 12;
|
||||
let a = mid[m];
|
||||
let b = if m2 == 0 { mid[0] + 365.0 } else { mid[m2] };
|
||||
if dd >= a && dd <= b {
|
||||
return t(m) + (t(m2) - t(m)) * (dd - a) / (b - a);
|
||||
}
|
||||
}
|
||||
t(0)
|
||||
}
|
||||
|
||||
/// Annee type de 365 jours (indexee depuis le 1er aout), identique chaque annee civile.
|
||||
/// `variabilite` = 0 : normales lissees (temps uniforme) ; 1 : temps synthetique (anomalie AR(1)
|
||||
/// d ecart-type 3,0 C, jours humides en chaine de Markov, pluies exponentielles).
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct Climat {
|
||||
pub seed: u64,
|
||||
pub variabilite: f32,
|
||||
tab: Vec<Obs>,
|
||||
}
|
||||
|
||||
impl Climat {
|
||||
pub fn nouveau(seed: u64, variabilite: f32) -> Climat {
|
||||
let mut r = Rng(seed ^ 0xC11A_7000);
|
||||
let mut tab = Vec::with_capacity(365);
|
||||
let (mut anom, mut humide) = (0.0f32, false);
|
||||
let phi = 0.7f32;
|
||||
for idx in 0..365u32 {
|
||||
let doy = (idx + 213 - 1) % 365 + 1;
|
||||
let mois = (0..12)
|
||||
.rev()
|
||||
.find(|&m| doy as f32 > JOURS_MOIS[..m].iter().sum::<f32>())
|
||||
.unwrap_or(0);
|
||||
let jm = JOURS_MOIS[mois];
|
||||
let p_h = if humide { 0.60 } else { 0.25 };
|
||||
humide = r.u01() < p_h;
|
||||
anom = phi * anom + 3.0 * (1.0 - phi * phi).sqrt() * r.normal();
|
||||
let mu = PRECIP_MM_1000M[mois] / (jm * 0.385);
|
||||
let expo = -(1.0 - r.u01()).max(1e-6).ln();
|
||||
let v = variabilite;
|
||||
let p_var = if humide { mu * expo } else { 0.0 };
|
||||
let p_uni = PRECIP_MM_1000M[mois] / jm;
|
||||
let precip = p_uni + (p_var - p_uni) * v;
|
||||
let temp = temp_normale(doy) + v * (anom - if humide { 1.0 } else { 0.0 });
|
||||
tab.push(Obs { temp_c: temp, precip_mm: precip.max(0.0) });
|
||||
}
|
||||
Climat { seed, variabilite, tab }
|
||||
}
|
||||
pub fn obs(&self, d: Date) -> Obs {
|
||||
self.tab[d.index_hydro()]
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,382 @@
|
||||
use super::*;
|
||||
use std::collections::HashMap;
|
||||
|
||||
fn champ(alts: &[f32], pente: f32, aspect: f32) -> Manteau {
|
||||
let a = alts.to_vec();
|
||||
Manteau::nouveau(Params::default(), 32, 0, 0, a.len(), 1, move |ix, _| Cellule { alt_m: a[ix], pente_deg: pente, aspect_deg: aspect })
|
||||
}
|
||||
|
||||
fn veymont_synth() -> Vec<f32> {
|
||||
// Altitudes 1660..2320 m par pas de 20 m, pente moderee (comme le Veymont, 1659-2322 m)
|
||||
// Distribution proche de la tuile reelle (beaucoup de surface entre 1650 et 1950 m)
|
||||
(0..34).map(|i| 1660.0 + 660.0 * (i as f32 / 33.0).powf(1.6)).collect()
|
||||
}
|
||||
|
||||
fn fraction(seed: u64, d: Date, mode_aspect: f32) -> f32 {
|
||||
let m = champ(&veymont_synth(), 20.0, mode_aspect);
|
||||
let mut c = CoucheLive::new(Mode::Climat, m, Climat::nouveau(seed, 1.0), None);
|
||||
c.avancer_a(d);
|
||||
c.manteau.fraction_enneigee(0.0, 9000.0)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn dates() {
|
||||
let d = Date::new(2026, 10, 30);
|
||||
assert_eq!(Date::depuis_ordinal(d.ordinal()), d);
|
||||
assert_eq!(Date::new(1970, 1, 1).ordinal(), 0);
|
||||
assert_eq!(d.plus(2), Date::new(2026, 11, 1));
|
||||
assert_eq!(Date::new(2028, 3, 1).plus(-1), Date::new(2028, 2, 29));
|
||||
assert_eq!(Date::parse("2026-10-30").unwrap(), d);
|
||||
assert_eq!(Date::new(2027, 2, 3).debut_annee_hydro(), Date::new(2026, 8, 1));
|
||||
assert_eq!(Date::new(2026, 8, 1).index_hydro(), 0);
|
||||
assert_eq!(Date::new(2026, 7, 31).index_hydro(), 364);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn csv() {
|
||||
let s = Serie::depuis_csv("date,temp,precip\n# c\n2026-10-01,3.5,12\n2026-10-02;-1;0.5\n").unwrap();
|
||||
assert_eq!(s.jours.len(), 2);
|
||||
assert_eq!(s.get(Date::new(2026, 10, 2)).unwrap().temp_c, -1.0);
|
||||
assert!(Serie::depuis_csv("date,temp,precip\n").is_err());
|
||||
assert!(Serie::depuis_csv("2026-10-01,abc,1\n").is_err());
|
||||
let s2 = Serie::depuis_csv(&s.vers_csv()).unwrap();
|
||||
assert_eq!(s2.jours.len(), 2);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn degres_jours() {
|
||||
assert!((manteau::degres_jours_positifs(10.0, 5.0) - 10.0).abs() < 1e-4);
|
||||
assert_eq!(manteau::degres_jours_positifs(-6.0, 5.0), 0.0);
|
||||
// tm = 0 : A / pi
|
||||
assert!((manteau::degres_jours_positifs(0.0, 5.0) - 5.0 / std::f32::consts::PI).abs() < 1e-4);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn accumulation_selon_altitude_et_temperature() {
|
||||
let mut m = champ(&[1000.0, 1500.0, 2000.0, 2500.0], 10.0, 0.0);
|
||||
// Reference a 1000 m : -1 C => 1000 m -1, 1500 m -4.25, 2000 -7.5 : 30 mm de precipitation
|
||||
m.pas_jour(Date::new(2026, 12, 1), -1.0, 30.0);
|
||||
let s: Vec<f32> = (0..4).map(|i| m.swe_cellule_mm(i, 0)).collect();
|
||||
assert!(s[0] > 25.0 && s[3] > s[0], "{s:?}"); // l'effet orographique renforce le haut
|
||||
// Pluie : +6 C a 1000 m => 1000 m pluie, 2500 m neige (-3.75)
|
||||
let mut m2 = champ(&[1000.0, 2500.0], 10.0, 0.0);
|
||||
m2.pas_jour(Date::new(2026, 12, 1), 6.0, 30.0);
|
||||
assert_eq!(m2.swe_cellule_mm(0, 0), 0.0);
|
||||
assert!(m2.swe_cellule_mm(1, 0) > 20.0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn pas_jour_idempotent() {
|
||||
let mut m = champ(&[2000.0], 10.0, 0.0);
|
||||
assert!(m.pas_jour(Date::new(2026, 12, 1), -5.0, 20.0));
|
||||
let a = m.swe_cellule_mm(0, 0);
|
||||
assert!(!m.pas_jour(Date::new(2026, 12, 1), -5.0, 20.0));
|
||||
assert!(!m.pas_jour(Date::new(2026, 11, 30), -5.0, 20.0));
|
||||
assert_eq!(m.swe_cellule_mm(0, 0), a);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fonte_degre_jour() {
|
||||
// Cellule plate a 1000 m (= station), mi-avril, 12 C moyens : fonte ~ ddf * (12 + ..) par jour
|
||||
let mut m = champ(&[1000.0], 0.0, 0.0);
|
||||
m.fixer_swe_mm(0, 0, 200.0);
|
||||
let mut prec = 200.0;
|
||||
let mut d = Date::new(2027, 4, 15);
|
||||
for _ in 0..5 {
|
||||
m.pas_jour(d, 12.0, 0.0);
|
||||
let s = m.swe_cellule_mm(0, 0);
|
||||
assert!(s < prec || s == 0.0, "la neige doit fondre");
|
||||
prec = s;
|
||||
d = d.plus(1);
|
||||
}
|
||||
// 5 j x (5 mm/C x ~12 C + sol 0.3) = ~300 mm > 200 mm => plus rien
|
||||
assert!(prec < 5.0, "reste {prec}");
|
||||
// Pas de fonte sous 0 C
|
||||
let mut g = champ(&[1000.0], 0.0, 0.0);
|
||||
g.fixer_swe_mm(0, 0, 100.0);
|
||||
g.pas_jour(Date::new(2027, 1, 10), -10.0, 0.0);
|
||||
assert!(g.swe_cellule_mm(0, 0) > 99.0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn adret_ubac_fonte_et_accumulation() {
|
||||
// Meme altitude, meme pente (30 deg), versant sud (180) contre nord (0), fin mars
|
||||
let mut m = Manteau::nouveau(Params::default(), 32, 0, 0, 2, 1, |ix, _| Cellule {
|
||||
alt_m: 1800.0,
|
||||
pente_deg: 30.0,
|
||||
aspect_deg: if ix == 0 { 180.0 } else { 0.0 },
|
||||
});
|
||||
m.fixer_swe_mm(0, 0, 500.0);
|
||||
m.fixer_swe_mm(1, 0, 500.0);
|
||||
let mut d = Date::new(2027, 3, 20);
|
||||
for _ in 0..25 {
|
||||
m.pas_jour(d, 8.0, 0.0); // ~ 2.8 C a 1800 m
|
||||
d = d.plus(1);
|
||||
}
|
||||
let (adret, ubac) = (m.swe_cellule_mm(0, 0), m.swe_cellule_mm(1, 0));
|
||||
assert!(ubac > adret + 40.0, "adret {adret} ubac {ubac}");
|
||||
// Accumulation identique (le soleil n'intervient pas dans les chutes)
|
||||
let mut n = Manteau::nouveau(Params::default(), 32, 0, 0, 2, 1, |ix, _| Cellule {
|
||||
alt_m: 1800.0,
|
||||
pente_deg: 30.0,
|
||||
aspect_deg: if ix == 0 { 180.0 } else { 0.0 },
|
||||
});
|
||||
n.pas_jour(Date::new(2026, 12, 20), -6.0, 20.0);
|
||||
assert_eq!(n.swe_cellule_mm(0, 0), n.swe_cellule_mm(1, 0));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn facteur_rayonnement_saison() {
|
||||
let m = Manteau::nouveau(Params::default(), 32, 0, 0, 1, 1, |_, _| Cellule { alt_m: 1800.0, pente_deg: 30.0, aspect_deg: 180.0 });
|
||||
let g = |a: f32| {
|
||||
let s = 30f32.to_radians();
|
||||
[s.cos(), s.sin(), a.to_radians().cos()]
|
||||
};
|
||||
// En decembre l'ecart adret/ubac est bien plus grand qu'en juin
|
||||
let ecart = |doy| m.facteur_rayonnement(g(180.0), doy) - m.facteur_rayonnement(g(0.0), doy);
|
||||
assert!(ecart(355) > ecart(172) + 0.3);
|
||||
assert!(m.facteur_rayonnement(g(180.0), 355) > 1.0 && m.facteur_rayonnement(g(0.0), 355) < 1.0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn couches_et_pente() {
|
||||
let mut m = champ(&[2000.0], 10.0, 0.0);
|
||||
m.fixer_swe_mm(0, 0, 400.0);
|
||||
let n = m.couches(5, 5, 10.0);
|
||||
assert_eq!(n, 8);
|
||||
assert_eq!(m.couches(5, 5, 60.0), 0); // paroi
|
||||
m.fixer_swe_mm(0, 0, 40.0);
|
||||
let n2 = m.couches(5, 5, 10.0);
|
||||
assert!((1..=4).contains(&n2), "{n2}");
|
||||
m.fixer_swe_mm(0, 0, 1.0);
|
||||
assert_eq!(m.couches(5, 5, 10.0), 0);
|
||||
}
|
||||
|
||||
// ---------- modes ----------
|
||||
|
||||
#[test]
|
||||
fn modes_climat_fige_meteo() {
|
||||
let d = Date::new(2027, 1, 15);
|
||||
let mk = |mode, serie| CoucheLive::new(mode, champ(&[1800.0], 10.0, 0.0), Climat::nouveau(3, 1.0), serie);
|
||||
let mut a = mk(Mode::Climat, None);
|
||||
let mut b = mk(Mode::Fige(d), None);
|
||||
a.avancer_a(d);
|
||||
b.avancer_a(Date::new(2030, 7, 1)); // la date demandee est ignoree en mode fige
|
||||
assert_eq!(a.manteau.swe_cellule_mm(0, 0), b.manteau.swe_cellule_mm(0, 0));
|
||||
assert_eq!(b.date(), Some(d));
|
||||
// Reproductible
|
||||
let mut a2 = mk(Mode::Climat, None);
|
||||
a2.avancer_a(d);
|
||||
assert_eq!(a.manteau.swe_cellule_mm(0, 0), a2.manteau.swe_cellule_mm(0, 0));
|
||||
// Avancer par etapes == aller directement ; revenir en arriere == recalculer
|
||||
let mut c = mk(Mode::Climat, None);
|
||||
for k in 0..30 {
|
||||
c.avancer_a(Date::new(2026, 12, 16).plus(k));
|
||||
}
|
||||
let mut dd = mk(Mode::Climat, None);
|
||||
dd.avancer_a(Date::new(2027, 1, 14));
|
||||
assert_eq!(c.manteau.swe_cellule_mm(0, 0), dd.manteau.swe_cellule_mm(0, 0));
|
||||
c.avancer_a(Date::new(2026, 11, 20));
|
||||
let mut e = mk(Mode::Climat, None);
|
||||
e.avancer_a(Date::new(2026, 11, 20));
|
||||
assert_eq!(c.manteau.swe_cellule_mm(0, 0), e.manteau.swe_cellule_mm(0, 0));
|
||||
// Meteo : une chute de neige reelle (serie) bat le climat
|
||||
let mut csv = String::from("date,temp,precip\n");
|
||||
for k in 0..10 {
|
||||
csv += &format!("{},{},{}\n", Date::new(2026, 10, 1).plus(k), -8, 15);
|
||||
}
|
||||
let serie = Serie::depuis_csv(&csv).unwrap();
|
||||
let mut mt = mk(Mode::Meteo, Some(serie));
|
||||
mt.avancer_a(Date::new(2026, 10, 10));
|
||||
let mut cl = mk(Mode::Climat, None);
|
||||
cl.avancer_a(Date::new(2026, 10, 10));
|
||||
assert!(mt.manteau.swe_cellule_mm(0, 0) > cl.manteau.swe_cellule_mm(0, 0) + 50.0);
|
||||
assert!(mt.jours_repli > 0); // aout-septembre : repli sur le climat
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn hiver_synthetique_abaisse_la_limite_et_mars_doux_la_releve() {
|
||||
let alts: Vec<f32> = (0..30).map(|i| 600.0 + 80.0 * i as f32).collect();
|
||||
let limite = |c: &CoucheLive| {
|
||||
(0..alts.len()).find(|&i| c.manteau.swe_cellule_mm(i, 0) >= 8.0).map(|i| alts[i]).unwrap_or(9999.0)
|
||||
};
|
||||
let mut c = CoucheLive::new(Mode::Climat, champ(&alts, 10.0, 0.0), Climat::nouveau(5, 1.0), None);
|
||||
c.avancer_a(Date::new(2026, 10, 1));
|
||||
let l_oct = limite(&c);
|
||||
c.avancer_a(Date::new(2027, 1, 20));
|
||||
let l_jan = limite(&c);
|
||||
assert!(l_jan < l_oct, "janvier {l_jan} octobre {l_oct}");
|
||||
assert!(l_jan <= 1100.0, "{l_jan}");
|
||||
// Mars tres doux (serie) : la limite remonte
|
||||
let mut csv = String::new();
|
||||
for k in 0..40 {
|
||||
csv += &format!("{},{},{}\n", Date::new(2027, 2, 20).plus(k), 14, 2);
|
||||
}
|
||||
let mut m = CoucheLive::new(Mode::Meteo, champ(&alts, 10.0, 0.0), Climat::nouveau(5, 1.0), Some(Serie::depuis_csv(&csv).unwrap()));
|
||||
m.avancer_a(Date::new(2027, 2, 19));
|
||||
let l_avant = limite(&m);
|
||||
m.avancer_a(Date::new(2027, 3, 31));
|
||||
assert!(limite(&m) > l_avant + 400.0, "{} {}", limite(&m), l_avant);
|
||||
}
|
||||
|
||||
// ---------- calibrage : neige d'octobre au Veymont ----------
|
||||
|
||||
#[test]
|
||||
fn calibrage_octobre_veymont() {
|
||||
let moy = |d: Date| (1..=40).map(|s| fraction(s, d, 90.0)).sum::<f32>() / 40.0;
|
||||
let (o1, o15, o31) = (moy(Date::new(2026, 10, 1)), moy(Date::new(2026, 10, 15)), moy(Date::new(2026, 10, 31)));
|
||||
let (n15, d15, j15) = (moy(Date::new(2026, 11, 15)), moy(Date::new(2026, 12, 15)), moy(Date::new(2027, 1, 15)));
|
||||
let (a1, jn, ao) = (moy(Date::new(2027, 4, 1)), moy(Date::new(2027, 6, 15)), moy(Date::new(2027, 8, 1)));
|
||||
eprintln!("1 oct {o1:.2} 15 oct {o15:.2} 31 oct {o31:.2} 15 nov {n15:.2} 15 dec {d15:.2} 15 jan {j15:.2} 1 avr {a1:.2} 15 juin {jn:.2} 1 aout {ao:.2}");
|
||||
// Le modele climatologique de physique donnait 54 % toute la fin d'octobre (limite 2000 m)
|
||||
assert!(o1 < 0.20, "1 oct {o1}");
|
||||
assert!(o15 < 0.30, "15 oct {o15}");
|
||||
assert!(o31 < 0.50 && o31 > 0.15, "31 oct {o31}");
|
||||
assert!(n15 > 0.40, "15 nov {n15}");
|
||||
assert!(j15 > 0.85, "15 jan {j15}");
|
||||
assert!(a1 > 0.75, "1 avr {a1}");
|
||||
assert!(jn < 0.40, "15 juin {jn}");
|
||||
assert!(ao < 0.01, "1 aout {ao}");
|
||||
}
|
||||
|
||||
// ---------- delta de chunk ----------
|
||||
|
||||
fn chunk_test(surface: Surface, alt: f32) -> ChunkEntree {
|
||||
let col = Colonne { sol_y: 700, surface, pente_deg: 5.0, alt_m: alt, eau_y: 700 };
|
||||
let mut feuilles = Vec::new();
|
||||
for i in 0..30 {
|
||||
feuilles.push(FeuilleEntree { x: i % 16, y: 710 + i / 16, z: 3, essence: Essence::Hetre, alt_m: 1000.0 });
|
||||
}
|
||||
ChunkEntree { cx: 0, cz: 0, colonnes: vec![col; 256], feuilles }
|
||||
}
|
||||
|
||||
struct Monde(HashMap<(i32, i32, i32), Bloc>);
|
||||
impl Monde {
|
||||
fn lire(&self, x: i32, y: i32, z: i32) -> Bloc {
|
||||
*self.0.get(&(x, y, z)).unwrap_or(&Bloc::Air)
|
||||
}
|
||||
fn appliquer(&mut self, d: &[Modif]) {
|
||||
for m in d {
|
||||
self.0.insert((m.x, m.y, m.z), m.apres);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn couche_hiver(alt: f32) -> CoucheLive {
|
||||
let mut c = CoucheLive::new(Mode::Climat, champ(&[alt, alt, alt], 5.0, 0.0), Climat::nouveau(2, 1.0), None);
|
||||
c.manteau = Manteau::nouveau(Params::default(), 32, 0, 0, 2, 2, |_, _| Cellule { alt_m: alt, pente_deg: 5.0, aspect_deg: 0.0 });
|
||||
c.avancer_a(Date::new(2027, 1, 25));
|
||||
c
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn delta_idempotent_neige_glace_feuilles() {
|
||||
let c = couche_hiver(1800.0);
|
||||
let mut e = chunk_test(Surface::Sol, 1800.0);
|
||||
// Un lac sur la moitie du chunk
|
||||
for i in 0..128 {
|
||||
e.colonnes[i] = Colonne { sol_y: 695, surface: Surface::Eau { lac: true }, pente_deg: 0.0, alt_m: 1800.0, eau_y: 700 };
|
||||
}
|
||||
let mut monde = Monde(HashMap::new());
|
||||
for i in 0..128 {
|
||||
monde.0.insert((i % 16, 700, i / 16), Bloc::Eau);
|
||||
}
|
||||
for f in &e.feuilles {
|
||||
monde.0.insert((f.x, f.y, f.z), Bloc::Feuille(Feuille::Verte));
|
||||
}
|
||||
let masque = MasqueJoueur::default();
|
||||
let d1 = c.delta_chunk(&e, &masque, &|x, y, z| monde.lire(x, y, z));
|
||||
let d1b = c.delta_chunk(&e, &masque, &|x, y, z| monde.lire(x, y, z));
|
||||
assert_eq!(d1, d1b, "meme entree, memes modifications");
|
||||
assert!(d1.iter().any(|m| matches!(m.apres, Bloc::Neige(_))), "neige attendue a 1800 m en janvier");
|
||||
assert!(d1.iter().any(|m| m.apres == Bloc::Glace), "lac gele attendu");
|
||||
assert!(d1.iter().any(|m| m.apres == Bloc::Air && matches!(m.avant, Bloc::Feuille(_))), "feuilles tombees en hiver");
|
||||
monde.appliquer(&d1);
|
||||
let d2 = c.delta_chunk(&e, &masque, &|x, y, z| monde.lire(x, y, z));
|
||||
assert!(d2.is_empty(), "2e application : {d2:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn delta_fonte_retire_la_neige_et_remet_les_feuilles() {
|
||||
let mut c = couche_hiver(1800.0);
|
||||
let e = chunk_test(Surface::Sol, 1800.0);
|
||||
let mut monde = Monde(HashMap::new());
|
||||
for f in &e.feuilles {
|
||||
monde.0.insert((f.x, f.y, f.z), Bloc::Feuille(Feuille::Verte));
|
||||
}
|
||||
let masque = MasqueJoueur::default();
|
||||
let d = c.delta_chunk(&e, &masque, &|x, y, z| monde.lire(x, y, z));
|
||||
monde.appliquer(&d);
|
||||
assert!(monde.0.values().any(|b| matches!(b, Bloc::Neige(_))));
|
||||
// Plein ete : plus de neige, feuilles vertes
|
||||
c.avancer_a(Date::new(2027, 7, 15));
|
||||
let d = c.delta_chunk(&e, &masque, &|x, y, z| monde.lire(x, y, z));
|
||||
monde.appliquer(&d);
|
||||
assert!(!monde.0.values().any(|b| matches!(b, Bloc::Neige(_))));
|
||||
assert!(e.feuilles.iter().all(|f| monde.lire(f.x, f.y, f.z) == Bloc::Feuille(Feuille::Verte)));
|
||||
assert!(c.delta_chunk(&e, &masque, &|x, y, z| monde.lire(x, y, z)).is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn delta_ne_touche_jamais_un_bloc_de_joueur() {
|
||||
let c = couche_hiver(1800.0);
|
||||
let e = chunk_test(Surface::Sol, 1800.0);
|
||||
let mut monde = Monde(HashMap::new());
|
||||
for f in &e.feuilles {
|
||||
monde.0.insert((f.x, f.y, f.z), Bloc::Feuille(Feuille::Verte));
|
||||
}
|
||||
// Un joueur a pose de la pierre sur (2,701,2) et un bloc d'eau; colonne (5,5) protegee; feuille (1,710,3) protegee
|
||||
monde.0.insert((2, 701, 2), Bloc::Autre);
|
||||
let mut masque = MasqueJoueur::default();
|
||||
masque.marquer_bloc(2, 701, 2);
|
||||
masque.marquer_colonne(5, 5);
|
||||
masque.marquer_bloc(1, 710, 3);
|
||||
let d = c.delta_chunk(&e, &masque, &|x, y, z| monde.lire(x, y, z));
|
||||
assert!(!d.iter().any(|m| (m.x, m.z) == (5, 5)));
|
||||
assert!(!d.iter().any(|m| (m.x, m.y, m.z) == (2, 701, 2) || (m.x, m.y, m.z) == (1, 710, 3)));
|
||||
assert!(d.iter().any(|m| (m.x, m.z) == (6, 5))); // les voisins sont traites
|
||||
// Meme sans masque, un bloc non modifiable (plante, tronc, pierre) n'est jamais remplace
|
||||
let d2 = c.delta_chunk(&e, &MasqueJoueur::default(), &|x, y, z| monde.lire(x, y, z));
|
||||
assert!(!d2.iter().any(|m| (m.x, m.y, m.z) == (2, 701, 2)));
|
||||
// Un joueur qui a casse la neige : si la colonne est dans le masque, elle n'est jamais re-posee
|
||||
assert!(!d.iter().any(|m| m.x == 5 && m.z == 5));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn riviere_niveau_saisonnier() {
|
||||
let mut e = chunk_test(Surface::Eau { lac: false }, 800.0);
|
||||
e.feuilles.clear();
|
||||
e.colonnes.iter_mut().for_each(|c| c.sol_y = 695);
|
||||
let ctx = |mois| Contexte { jour_annee: 120, mois, tmin7_ref_c: 5.0, alt_ref_m: 1000.0 };
|
||||
let m = Manteau::nouveau(Params::default(), 32, 0, 0, 1, 1, |_, _| Cellule { alt_m: 800.0, pente_deg: 0.0, aspect_deg: 0.0 });
|
||||
let mut monde = Monde(HashMap::new());
|
||||
for i in 0..256 {
|
||||
monde.0.insert((i % 16, 700, i / 16), Bloc::Eau);
|
||||
}
|
||||
// Mai : crue de fonte => un bloc d'eau de plus
|
||||
let d = m.delta_chunk(&e, &ctx(5), &MasqueJoueur::default(), &|x, y, z| monde.lire(x, y, z));
|
||||
assert_eq!(d.len(), 256);
|
||||
monde.appliquer(&d);
|
||||
assert!(m.delta_chunk(&e, &ctx(5), &MasqueJoueur::default(), &|x, y, z| monde.lire(x, y, z)).is_empty());
|
||||
// Aout : etiage => retour au niveau nominal ou en dessous
|
||||
assert!(decalage_niveau_eau_test(8) <= 0);
|
||||
let d = m.delta_chunk(&e, &ctx(8), &MasqueJoueur::default(), &|x, y, z| monde.lire(x, y, z));
|
||||
monde.appliquer(&d);
|
||||
assert_eq!(monde.lire(0, 701, 0), Bloc::Air);
|
||||
}
|
||||
|
||||
fn decalage_niveau_eau_test(mois: u32) -> i32 {
|
||||
delta::decalage_niveau_eau(mois)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn feuilles_saison() {
|
||||
let f = FeuilleEntree { x: 1, y: 2, z: 3, essence: Essence::Hetre, alt_m: 900.0 };
|
||||
assert_eq!(delta::etat_feuille(&f, 10), None);
|
||||
assert_eq!(delta::etat_feuille(&f, 190), Some(Feuille::Verte));
|
||||
assert_eq!(delta::etat_feuille(&f, 350), None);
|
||||
// Fin octobre (doy ~ 300) : couleurs d'automne ou absence, jamais verte franche en plein automne tardif
|
||||
let teintes: Vec<_> = (0..200).map(|i| delta::etat_feuille(&FeuilleEntree { x: i, y: 5, z: i * 7, essence: Essence::Hetre, alt_m: 900.0 }, 305)).collect();
|
||||
assert!(teintes.iter().any(|t| *t == Some(Feuille::Rousse) || *t == Some(Feuille::Jaune)));
|
||||
assert!(teintes.iter().any(|t| t.is_none()));
|
||||
}
|
||||
Référencer dans un nouveau ticket
Bloquer un utilisateur