Mål grunnmuren over bakken fra overkant mur

Høyden ble målt fra gulvet i etasjen over, så dekkets egen tykkelse ble regnet som mur over
bakken. Nå måles den fra overkant av selve muren, som geometrien gir den. For Nordhusstykket
5 går høyden fra 1,11–1,50 m til 0,76–1,24 m, i snitt 0,98 m.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_015GeH3y8fwTaTudaD88P57o

Cargo.lock

@@ -222,7 +222,7 @@ dependencies = [
 
 [[package]]
 name = "enok"
-version = "0.4.4"
+version = "0.4.6"
 dependencies = [
  "anyhow",
  "approx",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "enok"
-version = "0.4.4"
+version = "0.4.6"
 edition = "2021"
 description = "Årlig energiberegning og energirapport for boliger etter NS 3031 (timesmetode, ISO 52016-1)"
 license = "MIT"

src/inndata/ifc.rs

@@ -186,6 +186,7 @@ pub fn fra_tekst_med(tekst: &str, standardnavn: &str, valg: &Importvalg) -> Resu
             areal: flate.map(|f| f.areal).unwrap_or(0.0),
             normal: flate.map(|f| f.normal),
             z: plass.map(|p| p.2).unwrap_or(0.0) + flate.map(|f| f.hoyde).unwrap_or(0.0),
+            topp: plass.map(|p| p.2).unwrap_or(0.0) + flate.map(|f| f.topp).unwrap_or(0.0),
         });
     }
 
@@ -363,12 +364,13 @@ pub fn fra_tekst_med(tekst: &str, standardnavn: &str, valg: &Importvalg) -> Resu
         }
         // Terrengmodellen sier hvor høyt bakken ligger akkurat der denne veggen står, så en
         // skrånende tomt gir forskjellig høyde over bakken på hver side av huset.
+        // Høyden måles fra overkant mur, ikke fra gulvet over: dekket selv står ikke i bakken.
         let over_bakken = d
             .plass
             .and_then(|(x, y, _, _, _)| terreng_ved(&terrengmodell, x, y))
-            .map(|z| (etasjekontekst.forste_over_hoyde.unwrap_or(0.0) - z).clamp(0.0, kjellerdybde))
+            .map(|z| (d.topp - z).clamp(0.0, kjellerdybde))
             .unwrap_or(kjeller_over_terreng);
-        if i_kjeller && mot == Mot::Grunn {
+        if i_kjeller && mot == Mot::Grunn && typ == FlateType::Vegg {
             grunnmurshoyder.push(over_bakken);
         }
         let mal = if i_kjeller {
@@ -1316,6 +1318,8 @@ struct Del {
     normal: Option<[f64; 3]>,
     /// Delens høyde over byggets nullpunkt, av geometrien, m.
     z: f64,
+    /// Overkanten av delen over byggets nullpunkt, m. For en kjellervegg er det overkant mur.
+    topp: f64,
 }
 
 /// Oversetter en fritekstverdi fra modellen til en bygningskategori.
@@ -1504,20 +1508,15 @@ fn klassifiser(
         if d.ytre == Some(true) {
             return Some((FlateType::Gulv, Mot::Ute));
         }
-        // Mot grunnen i det nederste planet, eller når navnet sier det. Høyden av geometrien
+        // Høyden av geometrien avgjør, siden etasjetilknytningen i en eksport kan være feil.
-        // avgjør, siden etasjetilknytningen i en eksport kan være feil.
+        // Et dekke som ligger på bakken sier det i navnet. Ellers er et dekke like under
-        let paa_grunnen = [
+        // gulvet i første etasje himlingen over kjelleren, og det nederste dekket ligger mot
-            "kjellergulv",
+        // grunnen. «Kjellergulv» er ikke nok til å si at dekket ligger på bakken: dekket over
-            "on grade",
+        // kjelleren bærer ofte det samme navnet.
-            "på grunn",
+        let paa_grunnen = ["on grade", "på grunn", "paa grunn", "såle", "sale"];
-            "paa grunn",
+        if paa_grunnen.iter().any(|o| navn.contains(o)) {
-            "såle",
-            "sale",
-        ];
-        if (d.z - laveste).abs() < 0.5 || paa_grunnen.iter().any(|o| navn.contains(o)) {
             return Some((FlateType::Gulv, Mot::Grunn));
         }
-        // Dekket i laveste etasje over en kjeller er grensen mot den uoppvarmede sonen.
         if e.kjeller.is_some() {
             let ved_forste_over = e
                 .forste_over_hoyde
@@ -1527,6 +1526,9 @@ fn klassifiser(
                 return Some((FlateType::Gulv, Mot::Uoppvarmet));
             }
         }
+        if (d.z - laveste).abs() < 0.5 {
+            return Some((FlateType::Gulv, Mot::Grunn));
+        }
         // Dekker lenger opp er etasjeskillere inne i bygningen.
         return None;
     }

src/inndata/ifcgeom.rs

@@ -30,6 +30,8 @@ pub struct Hovedflate {
     /// Midlere høyde over delens eget nullpunkt, m. Sier hvilken etasje delen ligger i når
     /// plasseringen i filen ikke gjør det.
     pub hoyde: f64,
+    /// Øverste punkt over delens eget nullpunkt, m. For en kjellervegg er det overkant mur.
+    pub topp: f64,
 }
 
 impl Nett {
@@ -103,11 +105,18 @@ impl Nett {
         } else {
             self.punkter.iter().map(|p| p[2]).sum::<f64>() / self.punkter.len() as f64 * skala
         };
+        let topp = self
+            .punkter
+            .iter()
+            .map(|p| p[2])
+            .fold(f64::NEG_INFINITY, f64::max)
+            * skala;
         Some(Hovedflate {
             areal: sum / 2.0,
             normal,
             plan: self.utstrekning(normal, skala),
             hoyde,
+            topp: if topp.is_finite() { topp } else { 0.0 },
         })
     }
 
@@ -189,9 +198,14 @@ pub fn samlet_hovedflate(deler: &[Nett], skala: f64) -> Option<Hovedflate> {
     } else {
         grupper[0].hoyde
     };
+    let topp = grupper
+        .iter()
+        .map(|g| g.topp)
+        .fold(f64::NEG_INFINITY, f64::max);
     Some(Hovedflate {
         areal,
         hoyde,
+        topp,
         ..grupper[0]
     })
 }
@@ -562,6 +576,9 @@ mod tester {
         let h = n.hovedflate(1.0).unwrap();
         assert!((h.areal - 12.0).abs() < 1e-9, "areal ble {}", h.areal);
         assert!(h.normal[2].abs() > 0.99, "normal ble {:?}", h.normal);
+        // Midlere høyde er halve tykkelsen, og overkanten er tykkelsen.
+        assert!((h.hoyde - z / 2.0).abs() < 1e-9, "høyde ble {}", h.hoyde);
+        assert!((h.topp - z).abs() < 1e-9, "topp ble {}", h.topp);
     }
 
     /// Et hull i flaten skal trekkes fra, siden hullet mangler trekanter.