blandClaude Opus 5
133152742f
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
2199 lines
82 KiB
Rust
2199 lines
82 KiB
Rust
//! Import fra IFC (IFC2x3 og IFC4), som er formatet Vectorworks eksporterer med
|
||
//! «Export IFC Project».
|
||
//!
|
||
//! Importen henter klimaskjermen: yttervegger, tak, gulv, vinduer og dører, med areal,
|
||
//! U-verdi og himmelretning. Areal og U-verdi hentes fra mengder (`IfcElementQuantity`) og
|
||
//! egenskapssett (`Pset_WallCommon.ThermalTransmittance` m.fl.) når modellen har dem, ellers
|
||
//! av geometriske attributter. Himmelretningen utledes av elementets plassering: veggens
|
||
//! lokale x-akse gir planet, og ytre normal velges som den som peker bort fra bygningens
|
||
//! tyngdepunkt. Prosjektets sanne nord (`IfcGeometricRepresentationContext.TrueNorth`)
|
||
//! legges til.
|
||
|
||
use crate::inndata::ifcgeom;
|
||
use crate::inndata::step::{self, Arg, Entitet, Fil};
|
||
use crate::inndata::toml_inn::Importvalg;
|
||
use crate::klima::geo;
|
||
use crate::modell::*;
|
||
use crate::Result;
|
||
use anyhow::Context;
|
||
use std::collections::HashMap;
|
||
use std::path::Path;
|
||
|
||
pub struct Importrapport {
|
||
pub bygning: Bygning,
|
||
pub merknader: Vec<String>,
|
||
/// Bygningsdeler som ikke er tatt med i klimaskjermen: navn, areal og U-verdi.
|
||
pub utelatt: Vec<(String, f64, Option<f64>)>,
|
||
}
|
||
|
||
/// Konstruksjonsnavn og avrundet plassering, som skiller én bygningsdel fra en annen.
|
||
type Dublettnokkel = (String, i64, i64, i64, i64);
|
||
|
||
const VEGGTYPER: [&str; 3] = ["IFCWALL", "IFCWALLSTANDARDCASE", "IFCCURTAINWALL"];
|
||
const PLATETYPER: [&str; 3] = ["IFCSLAB", "IFCROOF", "IFCSLABSTANDARDCASE"];
|
||
|
||
pub fn les(sti: &Path) -> Result<Importrapport> {
|
||
les_med(sti, &Importvalg::default())
|
||
}
|
||
|
||
pub fn les_med(sti: &Path, valg: &Importvalg) -> Result<Importrapport> {
|
||
let raa = std::fs::read(sti).with_context(|| format!("leser {}", sti.display()))?;
|
||
let tekst = String::from_utf8_lossy(&raa);
|
||
fra_tekst_med(
|
||
&tekst,
|
||
sti.file_stem()
|
||
.and_then(|s| s.to_str())
|
||
.unwrap_or("Bygning"),
|
||
valg,
|
||
)
|
||
}
|
||
|
||
pub fn fra_tekst(tekst: &str, standardnavn: &str) -> Result<Importrapport> {
|
||
fra_tekst_med(tekst, standardnavn, &Importvalg::default())
|
||
}
|
||
|
||
pub fn fra_tekst_med(tekst: &str, standardnavn: &str, valg: &Importvalg) -> Result<Importrapport> {
|
||
let fil = step::les(tekst);
|
||
let mut merknader = Vec::new();
|
||
|
||
let skala = ifcgeom::lengdeenhet(&fil);
|
||
let sant_nord = sant_nord(&fil);
|
||
let egenskaper = samle_egenskaper(&fil);
|
||
let mengder = samle_mengder(&fil);
|
||
let (vindu_vert, dor_vert) = samle_apninger(&fil);
|
||
let (etasjer, etasje_for) = les_etasjer(&fil, skala);
|
||
|
||
// En eksport uten bygningsdeler gir ingen klimaskjerm å regne på. Det skjer typisk når
|
||
// designlagene ikke er knyttet til etasjer i eksportdialogen, og da er det bedre å stoppe
|
||
// enn å skrive en tom bygningsbeskrivelse.
|
||
let antall_deler: usize = [
|
||
"IFCWALL",
|
||
"IFCWALLSTANDARDCASE",
|
||
"IFCCURTAINWALL",
|
||
"IFCSLAB",
|
||
"IFCROOF",
|
||
"IFCWINDOW",
|
||
"IFCDOOR",
|
||
"IFCSPACE",
|
||
]
|
||
.iter()
|
||
.map(|t| fil.av_type(t).count())
|
||
.sum();
|
||
if antall_deler == 0 {
|
||
anyhow::bail!(
|
||
"IFC-filen har ingen bygningsdeler: ingen vegger, dekker, tak, vinduer, dører eller rom. \
|
||
Den inneholder bare prosjektstrukturen{}. I Vectorworks skjer dette gjerne når designlagene \
|
||
ikke er med under «Layer Mapping» i «Export IFC Project».",
|
||
if etasjer.is_empty() {
|
||
String::new()
|
||
} else {
|
||
format!(" med {} etasjer", etasjer.len())
|
||
}
|
||
);
|
||
}
|
||
|
||
// ── oppvarmet areal fra rommene ─────────────────────────────────
|
||
// Rom i en etasje under terreng hører til kjelleren og ikke til oppvarmet BRA.
|
||
let mut bra = 0.0;
|
||
let mut volum = 0.0;
|
||
let mut kjellerareal = 0.0;
|
||
let mut kjellervolum = 0.0;
|
||
let mut rom: Vec<(String, f64)> = Vec::new();
|
||
let mut kjellerrom: Vec<(String, f64)> = Vec::new();
|
||
let mut mistenkelige: Vec<String> = Vec::new();
|
||
let mut uoppvarmede: Vec<String> = Vec::new();
|
||
for (r, e) in fil.av_type("IFCSPACE") {
|
||
let navn = romnavn(e);
|
||
let areal = mengder.get(&r).map(arealmengde).unwrap_or(0.0);
|
||
// Rom som beskriver bebygget areal eller bruttoareal er ikke gulvareal.
|
||
let maalerom = matches!(navn.to_uppercase().as_str(), n if n.starts_with("BYA") || n.starts_with("BTA"));
|
||
if areal <= 0.0 || maalerom {
|
||
continue;
|
||
}
|
||
let romvolum = mengder
|
||
.get(&r)
|
||
.and_then(|m| m.get("NetVolume").or_else(|| m.get("GrossVolume")).copied())
|
||
.unwrap_or(0.0);
|
||
let under = etasje_for
|
||
.get(&r)
|
||
.and_then(|i| etasjer.get(*i))
|
||
.map(|e| e.under_terreng)
|
||
.unwrap_or(false);
|
||
if under {
|
||
kjellerrom.push((navn, areal));
|
||
kjellerareal += areal;
|
||
kjellervolum += romvolum;
|
||
} else {
|
||
let lavt = navn.to_lowercase();
|
||
if valg
|
||
.uoppvarmede_rom
|
||
.iter()
|
||
.any(|u| lavt.contains(&u.to_lowercase()))
|
||
{
|
||
uoppvarmede.push(format!("{navn} {areal:.1} m²"));
|
||
continue;
|
||
}
|
||
if ["kott", "bod", "loft", "garasje", "carport", "uoppvarmet"]
|
||
.iter()
|
||
.any(|o| lavt.contains(o))
|
||
{
|
||
mistenkelige.push(format!("{navn} {areal:.1} m²"));
|
||
}
|
||
rom.push((navn, areal));
|
||
bra += areal;
|
||
volum += romvolum;
|
||
}
|
||
}
|
||
rom.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap_or(std::cmp::Ordering::Equal));
|
||
if !rom.is_empty() {
|
||
let liste: Vec<String> = rom.iter().map(|(n, a)| format!("{n} {a:.1}")).collect();
|
||
merknader.push(format!(
|
||
"Oppvarmet BRA er satt til {bra:.1} m², summen av rommene i etasjene over terreng. Rom [m²]: {}.",
|
||
liste.join(", ")
|
||
));
|
||
}
|
||
if !mistenkelige.is_empty() {
|
||
merknader.push(format!(
|
||
"Disse rommene er regnet som oppvarmet, men navnet tyder på at de ikke er det: {}. Trekk dem fra oppvarmet_bra om de står uoppvarmet.",
|
||
mistenkelige.join(", ")
|
||
));
|
||
}
|
||
if !uoppvarmede.is_empty() {
|
||
merknader.push(format!(
|
||
"Disse rommene er uoppvarmet etter tilleggsfilen og holdt utenfor oppvarmet BRA: {}.",
|
||
uoppvarmede.join(", ")
|
||
));
|
||
}
|
||
|
||
// ── plassering og geometri for alle bygningsdeler ───────────────
|
||
let typer: Vec<&str> = VEGGTYPER.iter().chain(PLATETYPER.iter()).copied().collect();
|
||
let mut deler: Vec<Del> = Vec::new();
|
||
for (r, e) in fil.av_typer(&typer) {
|
||
let plass = e
|
||
.arg(5)
|
||
.and_then(|a| a.som_ref())
|
||
.and_then(|p| global_plassering(&fil, p, skala));
|
||
let netter = ifcgeom::netter_for_produkt(&fil, e.arg(6).and_then(|a| a.som_ref()));
|
||
let flate = ifcgeom::samlet_hovedflate(&netter, skala);
|
||
deler.push(Del {
|
||
nr: r,
|
||
typ: e.typ.clone(),
|
||
navn: navn_av(e, r, standardnavn_for(&e.typ)),
|
||
etasje: etasje_for.get(&r).copied(),
|
||
ytre: er_ytre(&egenskaper, r),
|
||
u_verdi: u_verdi(&egenskaper, r),
|
||
plass,
|
||
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),
|
||
});
|
||
}
|
||
|
||
// Noen eksporter legger den samme bygningsdelen i flere etasjer. To deler med samme
|
||
// konstruksjon, samme areal og samme plassering er den samme veggen eller det samme
|
||
// dekket. Kopiene blir stående, slik at vinduene i dem finner veggen sin, men de telles
|
||
// ikke med i klimaskjermen. Av kopiene beholdes den som ligger i den etasjen høyden
|
||
// tilsier, slik at en kjellervegg havner i kjelleren.
|
||
let konstruksjon = |navn: &str| navn.split(" #").next().unwrap_or(navn).trim().to_string();
|
||
let mut grupper: Vec<(Dublettnokkel, Vec<u64>)> = Vec::new();
|
||
for d in &deler {
|
||
let Some((x, y, _, _, _)) = d.plass else {
|
||
continue;
|
||
};
|
||
let cm = |v: f64| (v * 50.0).round() as i64;
|
||
let nokkel = (
|
||
konstruksjon(&d.navn),
|
||
cm(x),
|
||
cm(y),
|
||
cm(d.z),
|
||
(d.areal * 100.0).round() as i64,
|
||
);
|
||
match grupper.iter_mut().find(|(k, _)| *k == nokkel) {
|
||
Some((_, medlemmer)) => medlemmer.push(d.nr),
|
||
None => grupper.push((nokkel, vec![d.nr])),
|
||
}
|
||
}
|
||
let mut dublett_av: HashMap<u64, u64> = HashMap::new();
|
||
for (_, medlemmer) in grupper.iter().filter(|(_, m)| m.len() > 1) {
|
||
let avstand_til_etasjen = |nr: u64| {
|
||
let d = deler.iter().find(|d| d.nr == nr)?;
|
||
let hoyde = d.etasje.and_then(|i| etasjer.get(i)).map(|e| e.hoyde)?;
|
||
Some((d.z - hoyde).abs())
|
||
};
|
||
let beholdt = *medlemmer
|
||
.iter()
|
||
.min_by(|a, b| {
|
||
let (fa, fb) = (avstand_til_etasjen(**a), avstand_til_etasjen(**b));
|
||
match (fa, fb) {
|
||
(Some(x), Some(y)) => x.total_cmp(&y).then(a.cmp(b)),
|
||
(Some(_), None) => std::cmp::Ordering::Less,
|
||
(None, Some(_)) => std::cmp::Ordering::Greater,
|
||
(None, None) => a.cmp(b),
|
||
}
|
||
})
|
||
.unwrap_or(&medlemmer[0]);
|
||
for nr in medlemmer.iter().filter(|nr| **nr != beholdt) {
|
||
dublett_av.insert(*nr, beholdt);
|
||
}
|
||
}
|
||
let dubletter = dublett_av.len();
|
||
|
||
// Tyngdepunkt av de ytre veggene bestemmer hvilken vei normalen peker.
|
||
let ytre_deler: Vec<&Del> = deler
|
||
.iter()
|
||
.filter(|d| VEGGTYPER.contains(&d.typ.as_str()) && d.ytre.unwrap_or(false))
|
||
.collect();
|
||
let referanse: Vec<&Del> = if ytre_deler.is_empty() {
|
||
deler
|
||
.iter()
|
||
.filter(|d| VEGGTYPER.contains(&d.typ.as_str()))
|
||
.collect()
|
||
} else {
|
||
ytre_deler
|
||
};
|
||
let (mut cx, mut cy, mut n) = (0.0, 0.0, 0.0);
|
||
for d in &referanse {
|
||
if let Some((x, y, _, _, _)) = d.plass {
|
||
cx += x;
|
||
cy += y;
|
||
n += 1.0;
|
||
}
|
||
}
|
||
if n > 0.0 {
|
||
cx /= n;
|
||
cy /= n;
|
||
}
|
||
|
||
// ── kjeller som egen sone ───────────────────────────────────────
|
||
// Finnes det en etasje under terreng med rom, er den nesten alltid uoppvarmet.
|
||
// Bygningsdelene der hører til kjellerens klimaskjerm, og etasjeskilleren over blir
|
||
// grensen mellom den oppvarmede delen og sonen.
|
||
let kjelleretasje = (!kjellerrom.is_empty())
|
||
.then(|| etasjer.iter().position(|e| e.under_terreng))
|
||
.flatten();
|
||
let kjellernavn = kjelleretasje
|
||
.and_then(|i| etasjer.get(i))
|
||
.map(|e| e.navn.clone())
|
||
.unwrap_or_default();
|
||
// Etasjehøyden gir hvor dypt kjelleren ligger.
|
||
let kjellerdybde = kjelleretasje
|
||
.and_then(|i| {
|
||
let denne = etasjer.get(i)?.hoyde;
|
||
let over = etasjer.get(i + 1).map(|e| e.hoyde).unwrap_or(denne + 2.4);
|
||
Some(over - denne)
|
||
})
|
||
.unwrap_or(0.0);
|
||
// Den laveste etasjen over terreng, der etasjeskilleren mot kjelleren ligger.
|
||
let forste_over = etasjer.iter().position(|e| !e.under_terreng);
|
||
// Terrenghøyden på IfcBuilding sier hvor mye av grunnmuren som står over bakken.
|
||
let terrengmodell = terrengpunkter(&fil, skala);
|
||
let terreng = terrenghoyder(&fil, skala);
|
||
// Ligger terrengmodellen over gulvet i første etasje, er den ikke lagt i bakkenivå, og da
|
||
// sier den ingenting om hvor mye av grunnmuren som er nedgravd.
|
||
let terreng_over_gulvet = match (terreng, forste_over.and_then(|i| etasjer.get(i))) {
|
||
(Some((referanse, terrengnivaa)), Some(forste)) => {
|
||
terrengnivaa > referanse + forste.hoyde + 0.5
|
||
}
|
||
_ => false,
|
||
};
|
||
let kjeller_over_terreng = match (terreng, forste_over.and_then(|i| etasjer.get(i))) {
|
||
(Some((referanse, terrengnivaa)), Some(forste)) if !terreng_over_gulvet => {
|
||
over_terreng_for_kjeller(referanse, terrengnivaa, forste.hoyde, kjellerdybde)
|
||
}
|
||
_ => 0.0,
|
||
};
|
||
|
||
// ── klimaskjerm ─────────────────────────────────────────────────
|
||
let mut kjellerflater: Vec<Flate> = Vec::new();
|
||
let mut flater: Vec<Flate> = Vec::new();
|
||
let mut utelatt: Vec<(String, f64, Option<f64>)> = Vec::new();
|
||
let mut uten_uverdi: Vec<String> = Vec::new();
|
||
let mut uten_geometri = 0usize;
|
||
let mut grunnmurshoyder: Vec<f64> = Vec::new();
|
||
let mut asimut_for_vegg: HashMap<u64, f64> = HashMap::new();
|
||
|
||
// Laveste etasje og laveste gulvnivå skiller dekke mot grunn fra etasjeskillere.
|
||
let etasjekontekst = Etasjekontekst {
|
||
kjeller: kjelleretasje,
|
||
forste_over,
|
||
forste_over_hoyde: forste_over.and_then(|i| etasjer.get(i)).map(|e| e.hoyde),
|
||
};
|
||
let laveste = deler
|
||
.iter()
|
||
.filter(|d| PLATETYPER.contains(&d.typ.as_str()))
|
||
.map(|d| d.z)
|
||
.fold(f64::INFINITY, f64::min);
|
||
|
||
for d in &deler {
|
||
let er_vegg = VEGGTYPER.contains(&d.typ.as_str());
|
||
let (asimut, helning) = retning_av(d, cx, cy, sant_nord);
|
||
if er_vegg {
|
||
asimut_for_vegg.insert(d.nr, asimut);
|
||
}
|
||
if d.areal <= 0.05 {
|
||
uten_geometri += 1;
|
||
continue;
|
||
}
|
||
if dublett_av.contains_key(&d.nr) {
|
||
continue;
|
||
}
|
||
let i_kjeller = kjelleretasje.is_some() && d.etasje == kjelleretasje;
|
||
let Some((typ, mot)) = klassifiser(d, laveste, helning, &etasjekontekst) else {
|
||
utelatt.push((d.navn.clone(), d.areal, d.u_verdi));
|
||
continue;
|
||
};
|
||
// En etasjeskiller like over kjelleren er grensen mot den uoppvarmede sonen. Høyden
|
||
// avgjør, ikke etasjetilknytningen, som kan være feil i eksporten.
|
||
let ved_kjellertaket = etasjekontekst
|
||
.forste_over_hoyde
|
||
.map(|h| (d.z - h).abs() < 0.6)
|
||
.unwrap_or(false);
|
||
let (mot, sone) = if kjelleretasje.is_some()
|
||
&& !i_kjeller
|
||
&& ved_kjellertaket
|
||
&& typ == FlateType::Gulv
|
||
&& mot != Mot::Grunn
|
||
{
|
||
(Mot::Uoppvarmet, Some(kjellernavn.clone()))
|
||
} else {
|
||
(mot, None)
|
||
};
|
||
if d.u_verdi.is_none() {
|
||
uten_uverdi.push(d.navn.clone());
|
||
}
|
||
// 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| (d.topp - z).clamp(0.0, kjellerdybde))
|
||
.unwrap_or(kjeller_over_terreng);
|
||
if i_kjeller && mot == Mot::Grunn && typ == FlateType::Vegg {
|
||
grunnmurshoyder.push(over_bakken);
|
||
}
|
||
let mal = if i_kjeller {
|
||
&mut kjellerflater
|
||
} else {
|
||
&mut flater
|
||
};
|
||
mal.push(Flate {
|
||
navn: d.navn.clone(),
|
||
typ,
|
||
areal: d.areal,
|
||
orientering: if typ == FlateType::Vegg { asimut } else { 0.0 },
|
||
helning: Some(helning),
|
||
u_verdi: d.u_verdi,
|
||
lag: None,
|
||
masseklasse: masseklasse_av_materialer(&fil, d.nr),
|
||
masseplassering: Masseplassering::Fordelt,
|
||
mot,
|
||
b_faktor: None,
|
||
absorptans: None,
|
||
omkrets: None,
|
||
dybde: (i_kjeller && mot == Mot::Grunn).then_some(kjellerdybde - over_bakken),
|
||
over_terreng: (i_kjeller && mot == Mot::Grunn).then_some(over_bakken),
|
||
sone,
|
||
kommentar: d
|
||
.etasje
|
||
.and_then(|i| etasjer.get(i))
|
||
.map(|e| format!("{}, importert fra IFC", e.navn))
|
||
.or_else(|| Some("importert fra IFC".into())),
|
||
});
|
||
}
|
||
|
||
slaa_sammen(&mut flater);
|
||
slaa_sammen(&mut kjellerflater);
|
||
|
||
// ── vinduer og dører ────────────────────────────────────────────
|
||
let mut vinduer: Vec<Vindu> = Vec::new();
|
||
let mut sette_vinduer: std::collections::HashSet<(String, (i64, i64, i64), i64)> =
|
||
Default::default();
|
||
let mut vindusdubletter = 0usize;
|
||
for (r, e) in fil.av_type("IFCWINDOW").chain(fil.av_type("IFCDOOR")) {
|
||
let dor = e.typ == "IFCDOOR";
|
||
let hoyde = e.arg(8).and_then(|a| a.som_tall()).unwrap_or(0.0) * skala;
|
||
let bredde = e.arg(9).and_then(|a| a.som_tall()).unwrap_or(0.0) * skala;
|
||
let areal = mengder
|
||
.get(&r)
|
||
.map(arealmengde)
|
||
.filter(|a| *a > 0.05)
|
||
.unwrap_or(hoyde * bredde);
|
||
if areal <= 0.05 {
|
||
continue;
|
||
}
|
||
let vert = if dor {
|
||
dor_vert.get(&r)
|
||
} else {
|
||
vindu_vert.get(&r)
|
||
}
|
||
.map(|v| dublett_av.get(v).copied().unwrap_or(*v));
|
||
let vert = vert.as_ref();
|
||
// Vinduer i innervegger hører ikke til klimaskjermen.
|
||
let i_ytre_vegg = vert
|
||
.and_then(|v| deler.iter().find(|d| d.nr == *v))
|
||
.map(|d| d.ytre.unwrap_or(true))
|
||
.unwrap_or(true);
|
||
if !i_ytre_vegg {
|
||
utelatt.push((
|
||
format!("{} (i innervegg)", navn_av(e, r, "Vindu")),
|
||
areal,
|
||
u_verdi(&egenskaper, r),
|
||
));
|
||
continue;
|
||
}
|
||
// Det samme vinduet i to kopier av den samme veggen er ett vindu.
|
||
let sted = e
|
||
.arg(5)
|
||
.and_then(|a| a.som_ref())
|
||
.and_then(|p| global_plassering(&fil, p, skala))
|
||
.map(|(x, y, z, _, _)| {
|
||
let cm = |v: f64| (v * 50.0).round() as i64;
|
||
(cm(x), cm(y), cm(z))
|
||
})
|
||
.unwrap_or_default();
|
||
let nokkel = (
|
||
konstruksjon(&navn_av(e, r, if dor { "Dør" } else { "Vindu" })),
|
||
sted,
|
||
(areal * 100.0).round() as i64,
|
||
);
|
||
if !sette_vinduer.insert(nokkel) {
|
||
vindusdubletter += 1;
|
||
continue;
|
||
}
|
||
let asimut = vert
|
||
.and_then(|v| asimut_for_vegg.get(v))
|
||
.copied()
|
||
.unwrap_or(0.0);
|
||
// Uten U-verdi i modellen lar vi feltet stå tomt, slik at beregningen bruker en
|
||
// typisk verdi for byggeåret i stedet for en fast standardverdi.
|
||
let u = u_verdi(&egenskaper, r);
|
||
if u.is_none() {
|
||
uten_uverdi.push(navn_av(e, r, if dor { "Dør" } else { "Vindu" }));
|
||
}
|
||
vinduer.push(Vindu {
|
||
navn: navn_av(e, r, if dor { "Dør" } else { "Vindu" }),
|
||
areal,
|
||
antall: 1.0,
|
||
orientering: asimut,
|
||
helning: 90.0,
|
||
u_verdi: u,
|
||
g_verdi: egenskap(&egenskaper, r, "SolarHeatGainTransmittance")
|
||
.or_else(|| egenskap(&egenskaper, r, "SolarTransmittance")),
|
||
karmandel: egenskap(&egenskaper, r, "GlazingAreaFraction").map(|g| 1.0 - g),
|
||
solskjerming: None,
|
||
horisont: None,
|
||
dor,
|
||
kommentar: Some("importert fra IFC".into()),
|
||
});
|
||
}
|
||
|
||
// Vindus- og dørarealet trekkes fra veggene de sitter i, dersom geometrien ikke
|
||
// allerede har hull der åpningene er.
|
||
let mut apning_per_vegg: HashMap<u64, f64> = HashMap::new();
|
||
for (a, vegg) in vindu_vert.iter().chain(dor_vert.iter()) {
|
||
let e = fil.hent(*a);
|
||
let h = e
|
||
.and_then(|e| e.arg(8))
|
||
.and_then(|x| x.som_tall())
|
||
.unwrap_or(0.0)
|
||
* skala;
|
||
let b = e
|
||
.and_then(|e| e.arg(9))
|
||
.and_then(|x| x.som_tall())
|
||
.unwrap_or(0.0)
|
||
* skala;
|
||
*apning_per_vegg.entry(*vegg).or_default() += h * b;
|
||
}
|
||
let mut trukket_fra = 0usize;
|
||
for d in &deler {
|
||
let Some(ap) = apning_per_vegg.get(&d.nr) else {
|
||
continue;
|
||
};
|
||
let Some(f) = flater.iter_mut().find(|f| f.navn == d.navn) else {
|
||
continue;
|
||
};
|
||
// Ligger veggarealet nær bruttoarealet, har geometrien ikke hull, og åpningene trekkes fra.
|
||
if f.areal > *ap * 1.5 && d.normal.is_some() {
|
||
let netto = (f.areal - ap).max(0.0);
|
||
if netto > 0.05 {
|
||
f.areal = netto;
|
||
trukket_fra += 1;
|
||
}
|
||
}
|
||
}
|
||
if trukket_fra > 0 {
|
||
merknader.push(format!(
|
||
"Vindus- og dørareal er trukket fra {trukket_fra} vegger. Kontroller veggarealene mot tegningen."
|
||
));
|
||
}
|
||
|
||
// Tilleggsfiler og scenarioer viser til flatene med navn, så navnene må være entydige.
|
||
unike_navn(&mut flater);
|
||
unike_navn(&mut kjellerflater);
|
||
|
||
// ── merknader ───────────────────────────────────────────────────
|
||
if bra <= 0.0 {
|
||
bra = flater
|
||
.iter()
|
||
.filter(|f| f.typ == FlateType::Gulv)
|
||
.map(|f| f.areal)
|
||
.sum::<f64>();
|
||
merknader.push(if bra > 0.0 {
|
||
format!("IFC-modellen mangler romarealer; oppvarmet BRA er anslått til {bra:.0} m² av gulvflatene. Kontroller verdien.")
|
||
} else {
|
||
"IFC-modellen har verken romarealer eller gulvflater; fyll inn oppvarmet_bra.".into()
|
||
});
|
||
}
|
||
if uten_geometri > 0 {
|
||
merknader.push(format!(
|
||
"{uten_geometri} bygningsdeler er utelatt fordi geometrien ikke ga noe areal."
|
||
));
|
||
}
|
||
if !utelatt.is_empty() {
|
||
// Gruppert per konstruksjon, slik at listen er til å lese.
|
||
let mut grupper: Vec<(String, usize, f64)> = Vec::new();
|
||
for (navn, areal, _) in &utelatt {
|
||
let kort = navn.split(" #").next().unwrap_or(navn).trim().to_string();
|
||
match grupper.iter_mut().find(|(n, _, _)| *n == kort) {
|
||
Some((_, antall, sum)) => {
|
||
*antall += 1;
|
||
*sum += areal;
|
||
}
|
||
None => grupper.push((kort, 1, *areal)),
|
||
}
|
||
}
|
||
grupper.sort_by(|a, b| b.2.total_cmp(&a.2));
|
||
let liste: Vec<String> = grupper
|
||
.iter()
|
||
.take(10)
|
||
.map(|(navn, antall, sum)| {
|
||
if *antall > 1 {
|
||
format!("{navn} ×{antall} ({sum:.0} m²)")
|
||
} else {
|
||
format!("{navn} ({sum:.0} m²)")
|
||
}
|
||
})
|
||
.collect();
|
||
merknader.push(format!(
|
||
"{} bygningsdeler er ikke regnet med i klimaskjermen, som innervegger og dekker inne i bygningen: {}{}.",
|
||
utelatt.len(),
|
||
liste.join(", "),
|
||
if grupper.len() > liste.len() { " …" } else { "" }
|
||
));
|
||
}
|
||
if dubletter + vindusdubletter > 0 {
|
||
merknader.push(format!(
|
||
"{} bygningsdeler ligger dobbelt i modellen, samme konstruksjon på samme sted, og er telt én gang. Det skjer når eksporten legger de samme delene i flere etasjer.",
|
||
dubletter + vindusdubletter
|
||
));
|
||
}
|
||
if !uten_uverdi.is_empty() {
|
||
// Navnene gjør det tydelig hva som må rettes i modellen. Flere elementer av samme
|
||
// konstruksjon nevnes én gang, med antallet.
|
||
let mut antall: Vec<(String, usize)> = Vec::new();
|
||
for navn in &uten_uverdi {
|
||
let kort = navn.split(" #").next().unwrap_or(navn).trim().to_string();
|
||
match antall.iter_mut().find(|(n, _)| *n == kort) {
|
||
Some((_, a)) => *a += 1,
|
||
None => antall.push((kort, 1)),
|
||
}
|
||
}
|
||
let liste: Vec<String> = antall
|
||
.iter()
|
||
.map(|(n, a)| {
|
||
if *a > 1 {
|
||
format!("{n} ×{a}")
|
||
} else {
|
||
n.clone()
|
||
}
|
||
})
|
||
.collect();
|
||
merknader.push(format!(
|
||
"{} bygningsdeler mangler U-verdi i IFC-filen: {}. Legg inn U-verdier i modellen, eller la enok bruke typiske verdier for byggeåret.",
|
||
uten_uverdi.len(),
|
||
liste.join(", ")
|
||
));
|
||
}
|
||
merknader.push(
|
||
"Arealene er regnet av geometrien: trekantene er gruppert etter retning, og den største gruppen er delens hovedflate. Himmelretningene følger flatenormalen. Kontroller begge mot tegningen."
|
||
.into(),
|
||
);
|
||
merknader.push(
|
||
"IFC beskriver ikke drift, lekkasjetall eller energiforsyning. Fyll inn [ventilasjon], [infiltrasjon], [oppvarming], [tappevann] og [klima] før beregning."
|
||
.into(),
|
||
);
|
||
|
||
let (data, funnet) = les_byggdata(&fil, &egenskaper);
|
||
if !funnet.is_empty() {
|
||
merknader.push(format!(
|
||
"Modellen har egenskaper for drift og forsyning, og disse er tatt i bruk: {}.",
|
||
funnet.join(", ")
|
||
));
|
||
} else {
|
||
merknader.push(
|
||
"Modellen har ingen egenskaper for byggeår, tetthet, ventilasjon eller varmekilde. \
|
||
Festes et postformat med slike felter på bygningen i BIM-verktøyet og knyttes til et \
|
||
IFC-egenskapssett, kommer de med hit. Se «Egenskaper enok leser» i enoks dokumentasjon."
|
||
.into(),
|
||
);
|
||
}
|
||
|
||
let ubrukelig = |s: &str| {
|
||
let s = s.trim();
|
||
s.is_empty() || s == "Default Building" || s == "Vectorworks Project"
|
||
};
|
||
// Bygningens navn, ellers prosjektets langnavn eller navn, ellers filnavnet.
|
||
let navn = fil
|
||
.av_type("IFCBUILDING")
|
||
.next()
|
||
.and_then(|(_, e)| e.navn().map(|s| s.to_string()))
|
||
.filter(|s| !ubrukelig(s))
|
||
.or_else(|| {
|
||
fil.av_type("IFCPROJECT").next().and_then(|(_, p)| {
|
||
[p.arg(5), p.arg(2)]
|
||
.into_iter()
|
||
.flatten()
|
||
.filter_map(|a| a.som_tekst())
|
||
.find(|s| !ubrukelig(s))
|
||
.map(|s| s.trim().to_string())
|
||
})
|
||
})
|
||
.unwrap_or_else(|| standardnavn.to_string());
|
||
|
||
// Vernede bygninger er unntatt plikten til å ha energiattest.
|
||
let vernet = fil
|
||
.av_type("IFCBUILDING")
|
||
.next()
|
||
.and_then(|(r, _)| egenskaper.get(&r))
|
||
.and_then(|e| e.get("IsLandmarked"))
|
||
.map(|a| matches!(a.som_tekst(), Some("T") | Some("TRUE") | Some("true")))
|
||
.unwrap_or(false);
|
||
if vernet {
|
||
merknader.push(
|
||
"Bygningen er merket som vernet i modellen. Vernede bygninger etter kulturminneloven og \
|
||
plan- og bygningsloven er unntatt plikten til å ha energiattest, men beregningen kan \
|
||
fortsatt brukes til å vurdere tiltak."
|
||
.into(),
|
||
);
|
||
}
|
||
|
||
// Kjellersonen settes sammen av flatene i etasjen under terreng.
|
||
let mut soner: Vec<Sone> = Vec::new();
|
||
if let Some(i) = kjelleretasje {
|
||
if !kjellerflater.is_empty() {
|
||
let volum = if kjellervolum > 0.0 {
|
||
kjellervolum
|
||
} else {
|
||
kjellerareal * kjellerdybde.max(2.0)
|
||
};
|
||
let rom: Vec<String> = kjellerrom
|
||
.iter()
|
||
.map(|(n, a)| format!("{n} {a:.1}"))
|
||
.collect();
|
||
soner.push(Sone {
|
||
navn: kjellernavn.clone(),
|
||
volum: (volum > 0.0).then_some(volum),
|
||
luftveksling: None,
|
||
flater: kjellerflater,
|
||
andel_distribusjonstap: None,
|
||
andel_tappevannstap: None,
|
||
fast_effekt: 0.0,
|
||
kommentar: Some(format!(
|
||
"Etasje «{}» ligger {:.2} m under referansenivået. Rom [m²]: {}",
|
||
etasjer[i].navn,
|
||
-etasjer[i].hoyde,
|
||
rom.join(", ")
|
||
)),
|
||
});
|
||
let grunnmur = if !grunnmurshoyder.is_empty() && !terrengmodell.is_empty() {
|
||
let laveste = grunnmurshoyder
|
||
.iter()
|
||
.copied()
|
||
.fold(f64::INFINITY, f64::min);
|
||
let hoyeste = grunnmurshoyder
|
||
.iter()
|
||
.copied()
|
||
.fold(f64::NEG_INFINITY, f64::max);
|
||
let snitt = grunnmurshoyder.iter().sum::<f64>() / grunnmurshoyder.len() as f64;
|
||
format!(
|
||
"Terrengmodellen i filen gir hver kjellervegg sin egen høyde over bakken: \
|
||
{laveste:.2}–{hoyeste:.2} m, i snitt {snitt:.2} m. Resten av veggen er regnet nedgravd."
|
||
)
|
||
} else if terreng_over_gulvet {
|
||
format!(
|
||
"Terrengmodellen ligger over gulvet i første etasje, så den er ikke brukt. \
|
||
Kjellerveggene er regnet {kjellerdybde:.1} m under terreng uten noe over. Legg \
|
||
terrengmodellen i bakkenivå, eller sett `over_terreng` i meter på veggene."
|
||
)
|
||
} else if terreng.is_some() {
|
||
format!(
|
||
"Etter terrenghøyden i modellen står grunnmuren {kjeller_over_terreng:.2} m over bakken og \
|
||
{:.2} m under.",
|
||
kjellerdybde - kjeller_over_terreng
|
||
)
|
||
} else {
|
||
format!(
|
||
"Kjellerveggene er regnet {kjellerdybde:.1} m under terreng uten noe over. Står en del av \
|
||
grunnmuren over bakken, sett `over_terreng` i meter på veggene, eller sett terrenghøyden \
|
||
på bygningen i modellen. Utslaget er lite, om lag én prosent per meter."
|
||
)
|
||
};
|
||
merknader.push(format!(
|
||
"Etasjen «{}» ligger under terreng og er satt opp som en uoppvarmet sone med {:.0} m² gulv. \
|
||
{grunnmur}",
|
||
etasjer[i].navn, kjellerareal
|
||
));
|
||
merknader.push("Er kjelleren oppvarmet likevel, slett [[sone]] og legg flatene inn i klimaskjermen. \
|
||
Går det uisolerte varmerør der, sett `andel_distribusjonstap = 1.0` på sonen.".to_string());
|
||
}
|
||
}
|
||
|
||
let klimaposisjon = match posisjon(&fil) {
|
||
Some(p) if p.er_standardplassering() => {
|
||
merknader.push(
|
||
"Modellen står på Vectorworks' standardplassering i Washington, så posisjonen er ikke \
|
||
brukt. Georefereres tegningen eller settes prosjektstedet, velger beregningen \
|
||
klimasted ut fra den."
|
||
.into(),
|
||
);
|
||
None
|
||
}
|
||
Some(p) if !p.i_norge() => {
|
||
merknader.push(format!(
|
||
"Modellen oppgir posisjon {:.4}° nord, {:.4}° øst, som ligger utenfor Norge. \
|
||
Posisjonen er ikke brukt til å velge klimasted.",
|
||
p.bredde, p.lengde
|
||
));
|
||
None
|
||
}
|
||
Some(p) => {
|
||
merknader.push(format!(
|
||
"Modellen oppgir posisjon {:.4}° nord, {:.4}° øst. Uten kommune velger beregningen \
|
||
klimastedet nærmest denne.",
|
||
p.bredde, p.lengde
|
||
));
|
||
Some([p.bredde, p.lengde])
|
||
}
|
||
None => {
|
||
merknader.push(
|
||
"Modellen oppgir ingen posisjon. Georefereres tegningen eller settes prosjektstedet, \
|
||
velger beregningen klimasted ut fra den."
|
||
.into(),
|
||
);
|
||
None
|
||
}
|
||
};
|
||
|
||
vinduer.sort_by(|a, b| a.navn.cmp(&b.navn));
|
||
|
||
let bygning = Bygning {
|
||
bygning: BygningInfo {
|
||
navn,
|
||
kategori: data
|
||
.kategori
|
||
.as_deref()
|
||
.and_then(kategori_av_tekst)
|
||
.unwrap_or(Kategori::Smaahus),
|
||
byggeaar: data
|
||
.byggeaar
|
||
.unwrap_or(crate::modell::kontroll::IMPORTERT_BYGGEAAR),
|
||
oppvarmet_bra: data.oppvarmet_bra.unwrap_or(bra),
|
||
oppvarmet_volum: (volum > 0.0).then_some(volum),
|
||
antall_boenheter: 1,
|
||
bygningens_oppvarmede_bra: None,
|
||
adresse: adresse(&fil),
|
||
gnr_bnr: None,
|
||
beskrivelse: Some("Importert fra IFC".into()),
|
||
energiraadgiver: forfatter(&fil),
|
||
oppdragsgiver: None,
|
||
},
|
||
klima: Klima {
|
||
kommune: data.kommune.clone(),
|
||
posisjon: klimaposisjon,
|
||
..Klima::default()
|
||
},
|
||
flate: flater,
|
||
sone: soner,
|
||
grunn: Grunn::default(),
|
||
vindu: vinduer,
|
||
kuldebroer: Kuldebroer::default(),
|
||
infiltrasjon: Infiltrasjon {
|
||
n50: data.n50,
|
||
..Infiltrasjon::default()
|
||
},
|
||
ventilasjon: Ventilasjon {
|
||
typ: data
|
||
.ventilasjon
|
||
.as_deref()
|
||
.and_then(ventilasjon_av_tekst)
|
||
.unwrap_or_default(),
|
||
gjenvinning: data
|
||
.gjenvinning
|
||
.map(|v| if v > 1.0 { v / 100.0 } else { v }),
|
||
..Ventilasjon::default()
|
||
},
|
||
tappevann: Tappevann::default(),
|
||
oppvarming: Oppvarming {
|
||
kilde: data
|
||
.varmekilde
|
||
.as_deref()
|
||
.and_then(varmekilde_av_tekst)
|
||
.map(|t| {
|
||
vec![Varmekilde {
|
||
typ: t,
|
||
andel_rom: 1.0,
|
||
andel_ventilasjon: None,
|
||
andel_tappevann: 1.0,
|
||
spf: None,
|
||
turtemperatur: None,
|
||
lukket: true,
|
||
kommentar: Some("fra egenskap i IFC-modellen".into()),
|
||
}]
|
||
})
|
||
.unwrap_or_default(),
|
||
..Oppvarming::default()
|
||
},
|
||
distribusjon: Distribusjon::default(),
|
||
solcelle: None,
|
||
kjoling: Kjoling::default(),
|
||
lufting: Lufting::default(),
|
||
drift: Drift::default(),
|
||
scenario: Vec::new(),
|
||
rapport: Rapport::default(),
|
||
};
|
||
Ok(Importrapport {
|
||
bygning,
|
||
merknader,
|
||
utelatt,
|
||
})
|
||
}
|
||
|
||
/// Slår sammen flater med samme konstruksjon, type og himmelretning til én oppføring.
|
||
///
|
||
/// En BIM-modell deler gjerne den samme veggen i mange elementer, ett per rom eller etasje.
|
||
/// For en energiberegning er det konstruksjonen og himmelretningen som teller, så oppføringene
|
||
/// summeres. Himmelretningen rundes til nærmeste 45 grader før sammenligningen.
|
||
fn slaa_sammen(flater: &mut Vec<Flate>) {
|
||
let nokkel = |f: &Flate| {
|
||
let navn = f.navn.split(" #").next().unwrap_or(&f.navn).to_string();
|
||
let sektor = ((f.orientering / 45.0).round() as i64).rem_euclid(8);
|
||
let u = (f.u_verdi.unwrap_or(-1.0) * 100.0).round() as i64;
|
||
(navn, f.typ, f.mot, sektor, u)
|
||
};
|
||
let mut samlet: Vec<Flate> = Vec::new();
|
||
for f in flater.drain(..) {
|
||
match samlet.iter_mut().find(|g| nokkel(g) == nokkel(&f)) {
|
||
Some(g) => {
|
||
// Arealvektet himmelretning og helning, slik at summen peker riktig vei og ikke
|
||
// avhenger av rekkefølgen elementene kommer i.
|
||
let sum = g.areal + f.areal;
|
||
g.orientering = (g.orientering * g.areal + f.orientering * f.areal) / sum;
|
||
if let (Some(a), Some(b)) = (g.helning, f.helning) {
|
||
g.helning = Some((a * g.areal + b * f.areal) / sum);
|
||
}
|
||
g.areal = sum;
|
||
}
|
||
None => samlet.push(f),
|
||
}
|
||
}
|
||
for f in &mut samlet {
|
||
f.navn = f
|
||
.navn
|
||
.split(" #")
|
||
.next()
|
||
.unwrap_or(&f.navn)
|
||
.trim()
|
||
.to_string();
|
||
f.orientering = (f.orientering / 45.0).round() * 45.0;
|
||
}
|
||
*flater = samlet;
|
||
}
|
||
|
||
/// Gjør flatenavnene entydige. Vegger får himmelretningen etter konstruksjonsnavnet, og andre
|
||
/// flater som fortsatt deler navn, nummereres.
|
||
fn unike_navn(flater: &mut [Flate]) {
|
||
// Fast rekkefølge, slik at samme modell alltid gir samme fil og samme nummerering.
|
||
flater.sort_by(|a, b| {
|
||
(a.typ as u8, &a.navn)
|
||
.cmp(&(b.typ as u8, &b.navn))
|
||
.then(a.orientering.total_cmp(&b.orientering))
|
||
.then(b.areal.total_cmp(&a.areal))
|
||
});
|
||
for f in flater.iter_mut().filter(|f| f.typ == FlateType::Vegg) {
|
||
f.navn = format!("{}, {}", f.navn, himmelretning(f.orientering));
|
||
}
|
||
let mut antall: HashMap<String, usize> = HashMap::new();
|
||
for f in flater.iter_mut() {
|
||
let n = antall.entry(f.navn.clone()).or_insert(0);
|
||
*n += 1;
|
||
if *n > 1 {
|
||
f.navn = format!("{} ({n})", f.navn);
|
||
}
|
||
}
|
||
}
|
||
|
||
fn himmelretning(grader: f64) -> &'static str {
|
||
const RETNINGER: [&str; 8] = [
|
||
"nord", "nordøst", "øst", "sørøst", "sør", "sørvest", "vest", "nordvest",
|
||
];
|
||
RETNINGER[((grader / 45.0).round() as i64).rem_euclid(8) as usize]
|
||
}
|
||
|
||
/// En etasje i modellen, med navn og høyde over byggets referansenivå.
|
||
#[derive(Clone, Debug)]
|
||
pub struct Etasje {
|
||
pub navn: String,
|
||
/// Høyde over byggets referansenivå, m. Negativ for kjeller.
|
||
pub hoyde: f64,
|
||
/// Ligger etasjen under terreng, slik navn eller høyde tyder på?
|
||
pub under_terreng: bool,
|
||
}
|
||
|
||
/// Leser etasjene og hvilken etasje hver bygningsdel og hvert rom hører til.
|
||
///
|
||
/// Etasjeinndelingen er den sikreste opplysningen en BIM-modell har om hva som er hva.
|
||
/// En etasje som heter «Kjeller» og ligger under referansenivået er nesten alltid
|
||
/// uoppvarmet, og bygningsdelene der hører til kjellerens klimaskjerm og ikke husets.
|
||
fn les_etasjer(fil: &Fil, skala: f64) -> (Vec<Etasje>, HashMap<u64, usize>) {
|
||
let mut etasjer: Vec<(u64, Etasje)> = fil
|
||
.av_type("IFCBUILDINGSTOREY")
|
||
.map(|(r, e)| {
|
||
let navn = e
|
||
.navn()
|
||
.filter(|s| !s.is_empty())
|
||
.unwrap_or("etasje")
|
||
.to_string();
|
||
let hoyde = e.arg(9).and_then(|a| a.som_tall()).unwrap_or(0.0) * skala;
|
||
let lavt = navn.to_lowercase();
|
||
let under_terreng = hoyde < -0.5
|
||
|| ["kjeller", "basement", "souterreng", "underetasje"]
|
||
.iter()
|
||
.any(|o| lavt.contains(o));
|
||
(
|
||
r,
|
||
Etasje {
|
||
navn,
|
||
hoyde,
|
||
under_terreng,
|
||
},
|
||
)
|
||
})
|
||
.collect();
|
||
etasjer.sort_by(|a, b| {
|
||
a.1.hoyde
|
||
.partial_cmp(&b.1.hoyde)
|
||
.unwrap_or(std::cmp::Ordering::Equal)
|
||
});
|
||
|
||
let indeks: HashMap<u64, usize> = etasjer
|
||
.iter()
|
||
.enumerate()
|
||
.map(|(i, (r, _))| (*r, i))
|
||
.collect();
|
||
let mut for_element: HashMap<u64, usize> = HashMap::new();
|
||
|
||
// Bygningsdeler knyttes til etasjen med IfcRelContainedInSpatialStructure.
|
||
for (_, rel) in fil.av_type("IFCRELCONTAINEDINSPATIALSTRUCTURE") {
|
||
let Some(etasje) = rel
|
||
.arg(5)
|
||
.and_then(|a| a.som_ref())
|
||
.and_then(|r| indeks.get(&r))
|
||
else {
|
||
continue;
|
||
};
|
||
for e in rel.arg(4).map(|a| a.som_liste()).unwrap_or(&[]) {
|
||
if let Some(r) = e.som_ref() {
|
||
for_element.insert(r, *etasje);
|
||
}
|
||
}
|
||
}
|
||
// Rom knyttes til etasjen med IfcRelAggregates.
|
||
for (_, rel) in fil.av_type("IFCRELAGGREGATES") {
|
||
let Some(etasje) = rel
|
||
.arg(4)
|
||
.and_then(|a| a.som_ref())
|
||
.and_then(|r| indeks.get(&r))
|
||
else {
|
||
continue;
|
||
};
|
||
for e in rel.arg(5).map(|a| a.som_liste()).unwrap_or(&[]) {
|
||
if let Some(r) = e.som_ref() {
|
||
for_element.insert(r, *etasje);
|
||
}
|
||
}
|
||
}
|
||
(etasjer.into_iter().map(|(_, e)| e).collect(), for_element)
|
||
}
|
||
|
||
/// Masseklasse ut fra materialnavnene i konstruksjonen.
|
||
///
|
||
/// IFC-filer fra Vectorworks oppgir materialene som andeler uten tykkelse, så U-verdien
|
||
/// kan ikke regnes av dem. Navnene sier likevel nok om massen: betong og tegl er tungt,
|
||
/// bindingsverk og isolasjon er lett.
|
||
fn masseklasse_av_materialer(fil: &Fil, element: u64) -> Option<Masseklasse> {
|
||
let mut navn: Vec<String> = Vec::new();
|
||
for (_, rel) in fil.av_type("IFCRELASSOCIATESMATERIAL") {
|
||
let treff = rel
|
||
.arg(4)
|
||
.map(|a| a.som_liste())
|
||
.unwrap_or(&[])
|
||
.iter()
|
||
.any(|o| o.som_ref() == Some(element));
|
||
if !treff {
|
||
continue;
|
||
}
|
||
let Some(m) = rel
|
||
.arg(5)
|
||
.and_then(|a| a.som_ref())
|
||
.and_then(|r| fil.hent(r))
|
||
else {
|
||
continue;
|
||
};
|
||
samle_materialnavn(fil, m, &mut navn, 0);
|
||
}
|
||
if navn.is_empty() {
|
||
return None;
|
||
}
|
||
let tekst = navn.join(" ").to_lowercase();
|
||
let tungt = [
|
||
"concrete", "betong", "brick", "tegl", "masonry", "mur", "stone", "stein", "screed",
|
||
];
|
||
let lett = [
|
||
"insulat",
|
||
"isolasjon",
|
||
"timber",
|
||
"wood",
|
||
"tre",
|
||
"panel",
|
||
"gypsum",
|
||
"gips",
|
||
"air",
|
||
];
|
||
let t = tungt.iter().filter(|o| tekst.contains(**o)).count();
|
||
let l = lett.iter().filter(|o| tekst.contains(**o)).count();
|
||
Some(match (t, l) {
|
||
(0, 0) => return None,
|
||
(t, l) if t > l => Masseklasse::Tung,
|
||
(t, l) if t == l && t > 0 => Masseklasse::Middels,
|
||
_ => Masseklasse::Lett,
|
||
})
|
||
}
|
||
|
||
fn samle_materialnavn(fil: &Fil, e: &Entitet, ut: &mut Vec<String>, dybde: u32) {
|
||
if dybde > 4 {
|
||
return;
|
||
}
|
||
if e.typ == "IFCMATERIAL" {
|
||
if let Some(n) = e.arg(0).and_then(|a| a.som_tekst()) {
|
||
ut.push(n.to_string());
|
||
}
|
||
return;
|
||
}
|
||
for a in &e.args {
|
||
match a {
|
||
Arg::Ref(r) => {
|
||
if let Some(n) = fil.hent(*r) {
|
||
samle_materialnavn(fil, n, ut, dybde + 1);
|
||
}
|
||
}
|
||
Arg::Liste(l) => {
|
||
for x in l {
|
||
if let Some(n) = x.som_ref().and_then(|r| fil.hent(r)) {
|
||
samle_materialnavn(fil, n, ut, dybde + 1);
|
||
}
|
||
}
|
||
}
|
||
_ => {}
|
||
}
|
||
}
|
||
}
|
||
|
||
/// Opplysninger om drift og forsyning som IFC ikke har noen fast plass til.
|
||
///
|
||
/// IFC beskriver geometri og konstruksjon, men ikke byggeår, tetthet, ventilasjon eller
|
||
/// hvordan huset varmes opp. Det er nettopp de opplysningene som skiller en god
|
||
/// energiberegning fra en middelmådig. De kan likevel følge med modellen: i Vectorworks
|
||
/// lager man et postformat, fester det på bygningen og knytter det til et IFC-egenskapssett.
|
||
/// Feltnavnene under leses fra et hvilket som helst egenskapssett på `IfcBuilding`,
|
||
/// `IfcSite` eller `IfcProject`, på norsk eller engelsk.
|
||
#[derive(Default, Debug)]
|
||
pub struct Byggdata {
|
||
pub byggeaar: Option<i32>,
|
||
pub kategori: Option<String>,
|
||
pub kommune: Option<String>,
|
||
pub n50: Option<f64>,
|
||
pub ventilasjon: Option<String>,
|
||
pub gjenvinning: Option<f64>,
|
||
pub varmekilde: Option<String>,
|
||
pub oppvarmet_bra: Option<f64>,
|
||
}
|
||
|
||
/// Leser `Byggdata` fra egenskapssettene på bygningen, tomta eller prosjektet.
|
||
fn les_byggdata(fil: &Fil, egenskaper: &Egenskaper) -> (Byggdata, Vec<String>) {
|
||
let mut d = Byggdata::default();
|
||
let mut funnet = Vec::new();
|
||
let baerere: Vec<u64> = ["IFCBUILDING", "IFCSITE", "IFCPROJECT"]
|
||
.iter()
|
||
.flat_map(|t| fil.av_type(t).map(|(r, _)| r).collect::<Vec<_>>())
|
||
.collect();
|
||
|
||
let mut hent = |navn: &[&str]| -> Option<Arg> {
|
||
for b in &baerere {
|
||
let Some(sett) = egenskaper.get(b) else {
|
||
continue;
|
||
};
|
||
for n in navn {
|
||
if let Some((nokkel, v)) = sett.iter().find(|(k, _)| {
|
||
k.eq_ignore_ascii_case(n) || k.replace(' ', "").eq_ignore_ascii_case(n)
|
||
}) {
|
||
funnet.push(nokkel.clone());
|
||
return Some(v.clone());
|
||
}
|
||
}
|
||
}
|
||
None
|
||
};
|
||
|
||
let tall = |a: Option<Arg>| -> Option<f64> {
|
||
let a = a?;
|
||
a.som_tall().or_else(|| {
|
||
a.som_tekst()
|
||
.and_then(|s| s.replace(',', ".").trim().parse().ok())
|
||
})
|
||
};
|
||
let tekst = |a: Option<Arg>| -> Option<String> {
|
||
a.and_then(|x| x.som_tekst().map(|s| s.trim().to_string()))
|
||
.filter(|s| !s.is_empty())
|
||
};
|
||
|
||
d.byggeaar = tall(hent(&[
|
||
"Byggeaar",
|
||
"Byggeår",
|
||
"YearOfConstruction",
|
||
"ConstructionYear",
|
||
]))
|
||
.map(|v| v as i32);
|
||
d.kategori = tekst(hent(&["Bygningskategori", "Kategori", "BuildingCategory"]));
|
||
d.kommune = tekst(hent(&["Kommune", "Municipality", "Klimasted"]));
|
||
d.n50 = tall(hent(&[
|
||
"Lekkasjetall",
|
||
"n50",
|
||
"AirPermeability",
|
||
"AirTightness",
|
||
]));
|
||
d.ventilasjon = tekst(hent(&[
|
||
"Ventilasjonstype",
|
||
"Ventilasjon",
|
||
"VentilationType",
|
||
]));
|
||
d.gjenvinning = tall(hent(&[
|
||
"Varmegjenvinning",
|
||
"Gjenvinning",
|
||
"HeatRecoveryEfficiency",
|
||
"TemperaturVirkningsgrad",
|
||
]));
|
||
d.varmekilde = tekst(hent(&[
|
||
"Varmekilde",
|
||
"Oppvarming",
|
||
"HeatingSource",
|
||
"HeatSource",
|
||
]));
|
||
d.oppvarmet_bra = tall(hent(&["OppvarmetBRA", "Oppvarmet BRA", "HeatedFloorArea"]));
|
||
(d, funnet)
|
||
}
|
||
|
||
/// Byggets posisjon.
|
||
///
|
||
/// Georeferering gjennom `IfcMapConversion` og `IfcProjectedCRS` brukes først, siden den er
|
||
/// mest presis. Ellers brukes breddegrad og lengdegrad på `IfcSite`. Vectorworks fyller begge
|
||
/// med en standardplassering i Washington når ingenting er satt, og den velges bare når ingen
|
||
/// annen posisjon finnes, slik at den kan kjennes igjen og oversees.
|
||
fn posisjon(fil: &Fil) -> Option<geo::Posisjon> {
|
||
let fra_kart = fil.av_type("IFCMAPCONVERSION").next().and_then(|(_, m)| {
|
||
let crs = m
|
||
.arg(1)
|
||
.and_then(|a| a.som_ref())
|
||
.and_then(|r| fil.hent(r))?;
|
||
let navn = crs.arg(0).and_then(|a| a.som_tekst())?;
|
||
let x = m.arg(2).and_then(|a| a.som_tall())?;
|
||
let y = m.arg(3).and_then(|a| a.som_tall())?;
|
||
geo::fra_koordinatsystem(navn, x, y)
|
||
});
|
||
let fra_tomt = fil.av_type("IFCSITE").next().and_then(|(_, e)| {
|
||
let grad = |a: Option<&Arg>| -> Option<f64> {
|
||
let l = a?.som_liste();
|
||
if l.is_empty() {
|
||
return None;
|
||
}
|
||
let g = |i: usize| l.get(i).and_then(|x| x.som_tall()).unwrap_or(0.0);
|
||
let verdi = g(0).abs() + g(1).abs() / 60.0 + g(2).abs() / 3600.0 + g(3).abs() / 3.6e9;
|
||
Some(if g(0) < 0.0 { -verdi } else { verdi })
|
||
};
|
||
Some(geo::Posisjon {
|
||
bredde: grad(e.arg(9))?,
|
||
lengde: grad(e.arg(10))?,
|
||
})
|
||
});
|
||
[fra_kart, fra_tomt]
|
||
.into_iter()
|
||
.flatten()
|
||
.find(|p| !p.er_standardplassering())
|
||
.or(fra_kart)
|
||
.or(fra_tomt)
|
||
}
|
||
|
||
/// Referansehøyden og terrenghøyden på bygningen, begge over havet, m.
|
||
fn terrenghoyder(fil: &Fil, skala: f64) -> Option<(f64, f64)> {
|
||
let (_, e) = fil.av_type("IFCBUILDING").next()?;
|
||
let referanse = e.arg(9).and_then(|a| a.som_tall())? * skala;
|
||
let terreng = e.arg(10).and_then(|a| a.som_tall())? * skala;
|
||
Some((referanse, terreng))
|
||
}
|
||
|
||
/// Punktene i terrengmodellen, i byggets koordinater, m.
|
||
///
|
||
/// Vectorworks legger terrenget som et `IfcGeographicElement` med typen TERRAIN, eller på
|
||
/// tomta. Punktene brukes til å finne bakkenivået ved hver enkelt kjellervegg.
|
||
fn terrengpunkter(fil: &Fil, skala: f64) -> Vec<[f64; 3]> {
|
||
let mut ut = Vec::new();
|
||
for (_, e) in fil
|
||
.av_type("IFCGEOGRAPHICELEMENT")
|
||
.chain(fil.av_type("IFCSITE"))
|
||
{
|
||
let (px, py, pz) = e
|
||
.arg(5)
|
||
.and_then(|a| a.som_ref())
|
||
.and_then(|p| global_plassering(fil, p, skala))
|
||
.map(|(x, y, z, _, _)| (x, y, z))
|
||
.unwrap_or((0.0, 0.0, 0.0));
|
||
for nett in ifcgeom::netter_for_produkt(fil, e.arg(6).and_then(|a| a.som_ref())) {
|
||
for p in &nett.punkter {
|
||
ut.push([p[0] * skala + px, p[1] * skala + py, p[2] * skala + pz]);
|
||
}
|
||
}
|
||
}
|
||
ut
|
||
}
|
||
|
||
/// Bakkenivået ved et punkt, som snittet av de nærmeste punktene i terrengmodellen, m.
|
||
fn terreng_ved(punkter: &[[f64; 3]], x: f64, y: f64) -> Option<f64> {
|
||
if punkter.is_empty() {
|
||
return None;
|
||
}
|
||
let mut avstand: Vec<(f64, f64)> = punkter
|
||
.iter()
|
||
.map(|p| ((p[0] - x).powi(2) + (p[1] - y).powi(2), p[2]))
|
||
.collect();
|
||
avstand.sort_by(|a, b| a.0.total_cmp(&b.0));
|
||
let antall = avstand.len().min(8);
|
||
Some(avstand[..antall].iter().map(|(_, z)| z).sum::<f64>() / antall as f64)
|
||
}
|
||
|
||
/// Hvor mye av grunnmuren som står over bakken, m.
|
||
///
|
||
/// Toppen av grunnmuren ligger ved gulvet i første etasje over kjelleren. Den står over
|
||
/// terrenget med differansen mellom etasjens høyde over havet og terrengets, begrenset til
|
||
/// kjellerens høyde.
|
||
fn over_terreng_for_kjeller(
|
||
referanse: f64,
|
||
terreng: f64,
|
||
forste_etasje: f64,
|
||
kjellerdybde: f64,
|
||
) -> f64 {
|
||
((referanse + forste_etasje) - terreng).clamp(0.0, kjellerdybde.max(0.0))
|
||
}
|
||
|
||
/// En bygningsdel slik den er lest av IFC-filen.
|
||
struct Del {
|
||
nr: u64,
|
||
typ: String,
|
||
navn: String,
|
||
etasje: Option<usize>,
|
||
ytre: Option<bool>,
|
||
u_verdi: Option<f64>,
|
||
plass: Option<(f64, f64, f64, f64, f64)>,
|
||
areal: f64,
|
||
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.
|
||
fn kategori_av_tekst(s: &str) -> Option<Kategori> {
|
||
let t = s.to_lowercase();
|
||
Some(match t.as_str() {
|
||
x if x.contains("småhus") || x.contains("smaahus") || x.contains("enebolig") => {
|
||
Kategori::Smaahus
|
||
}
|
||
x if x.contains("boligblokk") || x.contains("leilighet") => Kategori::Boligblokk,
|
||
x if x.contains("kontor") => Kategori::Kontorbygg,
|
||
x if x.contains("skole") => Kategori::Skolebygg,
|
||
x if x.contains("barnehage") => Kategori::Barnehage,
|
||
x if x.contains("hotell") => Kategori::Hotell,
|
||
x if x.contains("sykehus") => Kategori::Sykehus,
|
||
x if x.contains("sykehjem") => Kategori::Sykehjem,
|
||
x if x.contains("idrett") => Kategori::Idrettsbygg,
|
||
x if x.contains("forretning") || x.contains("butikk") => Kategori::Forretningsbygg,
|
||
x if x.contains("kultur") => Kategori::Kulturbygg,
|
||
x if x.contains("industri") || x.contains("verksted") => Kategori::Industribygg,
|
||
_ => return None,
|
||
})
|
||
}
|
||
|
||
fn ventilasjon_av_tekst(s: &str) -> Option<VentilasjonType> {
|
||
let t = s.to_lowercase();
|
||
Some(match t.as_str() {
|
||
x if x.contains("balansert") || x.contains("balanced") || x.contains("mekanisk til") => {
|
||
VentilasjonType::Balansert
|
||
}
|
||
x if x.contains("avtrekk") || x.contains("exhaust") => VentilasjonType::Avtrekk,
|
||
x if x.contains("naturlig") || x.contains("natural") => VentilasjonType::Naturlig,
|
||
_ => return None,
|
||
})
|
||
}
|
||
|
||
fn varmekilde_av_tekst(s: &str) -> Option<VarmekildeType> {
|
||
let t = s.to_lowercase();
|
||
Some(match t.as_str() {
|
||
x if x.contains("luft-luft") || x.contains("luft/luft") || x.contains("air-air") => {
|
||
VarmekildeType::LuftLuftVp
|
||
}
|
||
x if x.contains("luft-vann") || x.contains("luft/vann") => VarmekildeType::LuftVannVp,
|
||
x if x.contains("berg")
|
||
|| x.contains("væske")
|
||
|| x.contains("vaeske")
|
||
|| x.contains("ground") =>
|
||
{
|
||
VarmekildeType::VaeskeVannVp
|
||
}
|
||
x if x.contains("avtrekksvarmepumpe") => VarmekildeType::AvtrekkVp,
|
||
x if x.contains("vedovn") || x.contains("ved") || x.contains("wood") => {
|
||
VarmekildeType::Vedovn
|
||
}
|
||
x if x.contains("pellet") => VarmekildeType::Pellets,
|
||
x if x.contains("fjernvarme") || x.contains("district") => VarmekildeType::Fjernvarme,
|
||
x if x.contains("olje") => VarmekildeType::Olje,
|
||
x if x.contains("gass") || x.contains("gas") => VarmekildeType::Gass,
|
||
x if x.contains("elkjel") || x.contains("elektrokjel") || x.contains("kjel") => {
|
||
VarmekildeType::ElKjel
|
||
}
|
||
x if x.contains("elektr") || x.contains("panelovn") || x.contains("electric") => {
|
||
VarmekildeType::DirekteEl
|
||
}
|
||
_ => return None,
|
||
})
|
||
}
|
||
|
||
fn standardnavn_for(typ: &str) -> &'static str {
|
||
if typ == "IFCROOF" {
|
||
"Tak"
|
||
} else if PLATETYPER.contains(&typ) {
|
||
"Dekke"
|
||
} else {
|
||
"Vegg"
|
||
}
|
||
}
|
||
|
||
fn romnavn(e: &Entitet) -> String {
|
||
e.arg(7)
|
||
.and_then(|a| a.som_tekst())
|
||
.filter(|s| !s.is_empty())
|
||
.or_else(|| e.arg(2).and_then(|a| a.som_tekst()))
|
||
.unwrap_or("rom")
|
||
.to_string()
|
||
}
|
||
|
||
/// Arealet fra en mengdesamling. Godtar både standardnavnene og verktøyspesifikke navn.
|
||
fn arealmengde(m: &HashMap<String, f64>) -> f64 {
|
||
for navn in [
|
||
"NetFloorArea",
|
||
"GrossFloorArea",
|
||
"NetArea",
|
||
"GrossArea",
|
||
"Area",
|
||
] {
|
||
if let Some(v) = m.get(navn) {
|
||
return *v;
|
||
}
|
||
}
|
||
// Ellers: et hvilket som helst areal, slik at verktøyspesifikke navn som
|
||
// «GSA BIM Area» også virker.
|
||
m.iter()
|
||
.filter(|(k, _)| k.to_lowercase().contains("area"))
|
||
.map(|(_, v)| *v)
|
||
.fold(0.0, f64::max)
|
||
}
|
||
|
||
/// Himmelretning og helning ut fra hovedflatens normal.
|
||
fn retning_av(d: &Del, cx: f64, cy: f64, sant_nord: f64) -> (f64, f64) {
|
||
let Some(n) = d.normal else {
|
||
return (
|
||
0.0,
|
||
if PLATETYPER.contains(&d.typ.as_str()) {
|
||
0.0
|
||
} else {
|
||
90.0
|
||
},
|
||
);
|
||
};
|
||
// Normalen er gitt i lokale koordinater; roter den med delens plassering.
|
||
let (dx, dy) = d.plass.map(|p| (p.3, p.4)).unwrap_or((1.0, 0.0));
|
||
let mut g = [n[0] * dx - n[1] * dy, n[0] * dy + n[1] * dx, n[2]];
|
||
|
||
let vannrett = (g[0] * g[0] + g[1] * g[1]).sqrt();
|
||
// Et skrått tak har også en vannrett komponent, men skal alltid ha normalen oppover;
|
||
// ellers kan undersiden bli hovedflaten og gi helning 180° minus takvinkelen.
|
||
let skraa_plate = PLATETYPER.contains(&d.typ.as_str()) && g[2].abs() > 0.1;
|
||
if vannrett > 0.2 && !skraa_plate {
|
||
// Veggflate: velg den normalen som peker bort fra bygningens tyngdepunkt.
|
||
if let Some((x, y, _, _, _)) = d.plass {
|
||
if g[0] * (x - cx) + g[1] * (y - cy) < 0.0 {
|
||
g = [-g[0], -g[1], -g[2]];
|
||
}
|
||
}
|
||
} else if g[2] < 0.0 {
|
||
// Vannrett flate: normalen oppover gir helning 0, nedover 180.
|
||
g = [-g[0], -g[1], -g[2]];
|
||
}
|
||
let helning = g[2].clamp(-1.0, 1.0).acos().to_degrees();
|
||
let asimut = (g[0].atan2(g[1]).to_degrees() + sant_nord).rem_euclid(360.0);
|
||
(asimut, helning)
|
||
}
|
||
|
||
/// Avgjør om en bygningsdel hører til klimaskjermen, og hva den vender mot.
|
||
/// Etasjeinndelingen som klassifiseringen trenger.
|
||
struct Etasjekontekst {
|
||
/// Etasjen under terreng, dersom modellen har en.
|
||
kjeller: Option<usize>,
|
||
/// Laveste etasje over terreng, der etasjeskilleren mot kjelleren ligger.
|
||
forste_over: Option<usize>,
|
||
/// Høyden på den etasjen, m. Geometrien veier tyngre enn etasjetilknytningen, som kan
|
||
/// være feil i eksporten.
|
||
forste_over_hoyde: Option<f64>,
|
||
}
|
||
|
||
fn klassifiser(
|
||
d: &Del,
|
||
laveste: f64,
|
||
helning: f64,
|
||
e: &Etasjekontekst,
|
||
) -> Option<(FlateType, Mot)> {
|
||
let navn = d.navn.to_lowercase();
|
||
let grunnord = [
|
||
"kjellermur",
|
||
"grunnmur",
|
||
"ringmur",
|
||
"såle",
|
||
"sale",
|
||
"fundament",
|
||
];
|
||
let takord = ["tak", "roof", "loft"];
|
||
|
||
if PLATETYPER.contains(&d.typ.as_str()) {
|
||
if d.typ == "IFCROOF" || takord.iter().any(|o| navn.contains(o)) {
|
||
return Some((
|
||
FlateType::Tak,
|
||
if navn.contains("loft") {
|
||
Mot::Uoppvarmet
|
||
} else {
|
||
Mot::Ute
|
||
},
|
||
));
|
||
}
|
||
// Et utkraget dekke eller balkonggulv er merket som ytre og vender mot det fri.
|
||
if d.ytre == Some(true) {
|
||
return Some((FlateType::Gulv, Mot::Ute));
|
||
}
|
||
// Høyden av geometrien 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
|
||
// gulvet i første etasje himlingen over kjelleren, og det nederste dekket ligger mot
|
||
// grunnen. «Kjellergulv» er ikke nok til å si at dekket ligger på bakken: dekket over
|
||
// kjelleren bærer ofte det samme navnet.
|
||
let paa_grunnen = ["on grade", "på grunn", "paa grunn", "såle", "sale"];
|
||
if paa_grunnen.iter().any(|o| navn.contains(o)) {
|
||
return Some((FlateType::Gulv, Mot::Grunn));
|
||
}
|
||
if e.kjeller.is_some() {
|
||
let ved_forste_over = e
|
||
.forste_over_hoyde
|
||
.map(|h| (d.z - h).abs() < 0.6)
|
||
.unwrap_or(false);
|
||
if ved_forste_over || (d.etasje.is_some() && d.etasje == e.forste_over) {
|
||
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;
|
||
}
|
||
|
||
// Vegger.
|
||
if d.ytre == Some(true) {
|
||
return Some((FlateType::Vegg, Mot::Ute));
|
||
}
|
||
if grunnord.iter().any(|o| navn.contains(o)) {
|
||
return Some((FlateType::Vegg, Mot::Grunn));
|
||
}
|
||
if d.ytre.is_none() && helning > 60.0 {
|
||
// Uten `IsExternal` må vi anta at veggen er ytre.
|
||
return Some((FlateType::Vegg, Mot::Ute));
|
||
}
|
||
None
|
||
}
|
||
|
||
fn navn_av(e: &Entitet, r: u64, standard: &str) -> String {
|
||
match e.navn() {
|
||
Some(n) if !n.trim().is_empty() => format!("{n} #{r}"),
|
||
_ => format!("{standard} #{r}"),
|
||
}
|
||
}
|
||
|
||
/// Byggets adresse fra `IfcBuilding.BuildingAddress`, eller fra tomta.
|
||
///
|
||
/// Adresser knyttet til personer og organisasjoner er forfatterens, ikke byggets, og brukes
|
||
/// ikke. Plassholdere uten gate eller poststed, som Vectorworks setter inn, hoppes over.
|
||
fn adresse(fil: &Fil) -> Option<String> {
|
||
let bygning = fil
|
||
.av_type("IFCBUILDING")
|
||
.filter_map(|(_, e)| e.arg(11).and_then(|a| a.som_ref()));
|
||
let tomt = fil
|
||
.av_type("IFCSITE")
|
||
.filter_map(|(_, e)| e.arg(13).and_then(|a| a.som_ref()));
|
||
bygning
|
||
.chain(tomt)
|
||
.filter_map(|r| fil.hent(r))
|
||
.filter(|e| e.typ == "IFCPOSTALADDRESS")
|
||
.find_map(formater_adresse)
|
||
}
|
||
|
||
/// `IfcPostalAddress` har feltene Purpose, Description, UserDefinedPurpose, InternalLocation,
|
||
/// AddressLines, PostalBox, Town, Region, PostalCode og Country.
|
||
fn formater_adresse(e: &Entitet) -> Option<String> {
|
||
let linjer: Vec<String> = e
|
||
.arg(4)
|
||
.map(|a| a.som_liste())
|
||
.unwrap_or(&[])
|
||
.iter()
|
||
.filter_map(|a| a.som_tekst())
|
||
.map(|s| s.trim().to_string())
|
||
.filter(|s| !s.is_empty())
|
||
.collect();
|
||
let postnummer = e.arg(8).and_then(|a| a.som_tekst()).unwrap_or("").trim();
|
||
let sted = e.arg(6).and_then(|a| a.som_tekst()).unwrap_or("").trim();
|
||
if linjer.is_empty() && sted.is_empty() {
|
||
return None;
|
||
}
|
||
let poststed: Vec<&str> = [postnummer, sted]
|
||
.into_iter()
|
||
.filter(|s| !s.is_empty())
|
||
.collect();
|
||
Some(
|
||
linjer
|
||
.into_iter()
|
||
.chain((!poststed.is_empty()).then(|| poststed.join(" ")))
|
||
.collect::<Vec<_>>()
|
||
.join(", "),
|
||
)
|
||
}
|
||
|
||
/// Forfatteren av modellen, som person og organisasjon.
|
||
///
|
||
/// I en modell laget for energirådgivning er det energirådgiveren. Vectorworks' egen
|
||
/// organisasjon, som står når ingenting er fylt inn, tas ikke med.
|
||
fn forfatter(fil: &Fil) -> Option<String> {
|
||
let (_, po) = fil.av_type("IFCPERSONANDORGANIZATION").next()?;
|
||
let person = po
|
||
.arg(0)
|
||
.and_then(|a| a.som_ref())
|
||
.and_then(|r| fil.hent(r));
|
||
let organisasjon = po
|
||
.arg(1)
|
||
.and_then(|a| a.som_ref())
|
||
.and_then(|r| fil.hent(r));
|
||
// IfcPerson: Identification, FamilyName, GivenName, …
|
||
let personnavn = person
|
||
.map(|p| {
|
||
[p.arg(2), p.arg(1)]
|
||
.into_iter()
|
||
.flatten()
|
||
.filter_map(|a| a.som_tekst())
|
||
.map(str::trim)
|
||
.filter(|s| !s.is_empty())
|
||
.collect::<Vec<_>>()
|
||
.join(" ")
|
||
})
|
||
.filter(|s| !s.is_empty());
|
||
// IfcOrganization: Identification, Name, …
|
||
let organisasjonsnavn = organisasjon
|
||
.and_then(|o| o.arg(1).and_then(|a| a.som_tekst()))
|
||
.map(str::trim)
|
||
.filter(|s| !s.is_empty() && !s.to_lowercase().contains("vectorworks"))
|
||
.map(str::to_string);
|
||
match (personnavn, organisasjonsnavn) {
|
||
(Some(p), Some(o)) => Some(format!("{p}, {o}")),
|
||
(Some(p), None) => Some(p),
|
||
(None, Some(o)) => Some(o),
|
||
(None, None) => None,
|
||
}
|
||
}
|
||
|
||
/// Prosjektets dreining mot sant nord, i grader med klokka.
|
||
fn sant_nord(fil: &Fil) -> f64 {
|
||
for (_, e) in fil.av_type("IFCGEOMETRICREPRESENTATIONCONTEXT") {
|
||
if let Some(r) = e.arg(5).and_then(|a| a.som_ref()) {
|
||
if let Some(d) = fil.hent(r) {
|
||
let v = d.arg(0).map(|a| a.som_liste()).unwrap_or(&[]);
|
||
if v.len() >= 2 {
|
||
let (x, y) = (
|
||
v[0].som_tall().unwrap_or(0.0),
|
||
v[1].som_tall().unwrap_or(1.0),
|
||
);
|
||
// TrueNorth peker mot nord i prosjektets koordinater.
|
||
return x.atan2(y).to_degrees();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
0.0
|
||
}
|
||
|
||
/// Sammensatt global plassering: (x, y, z, dx, dy) der (dx, dy) er lokal x-akse i planet.
|
||
fn global_plassering(fil: &Fil, r: u64, skala: f64) -> Option<(f64, f64, f64, f64, f64)> {
|
||
let mut x = 0.0;
|
||
let mut y = 0.0;
|
||
let mut z = 0.0;
|
||
let mut dx = 1.0;
|
||
let mut dy = 0.0;
|
||
let mut kjede = Vec::new();
|
||
let mut gjeldende = Some(r);
|
||
let mut vakt = 0;
|
||
while let Some(p) = gjeldende {
|
||
vakt += 1;
|
||
if vakt > 64 {
|
||
break;
|
||
}
|
||
let e = fil.hent(p)?;
|
||
if e.typ != "IFCLOCALPLACEMENT" {
|
||
break;
|
||
}
|
||
kjede.push(p);
|
||
gjeldende = e.arg(0).and_then(|a| a.som_ref());
|
||
}
|
||
for p in kjede.into_iter().rev() {
|
||
let e = fil.hent(p)?;
|
||
let ax = e
|
||
.arg(1)
|
||
.and_then(|a| a.som_ref())
|
||
.and_then(|a| fil.hent(a))?;
|
||
let (lx, ly, lz) = punkt(fil, ax.arg(0).and_then(|a| a.som_ref()), skala);
|
||
let (rx, ry) = retning(fil, ax.arg(2).and_then(|a| a.som_ref())).unwrap_or((1.0, 0.0));
|
||
// Roter det lokale punktet med foreldrenes akse og legg det til.
|
||
let nx = x + lx * dx - ly * dy;
|
||
let ny = y + lx * dy + ly * dx;
|
||
x = nx;
|
||
y = ny;
|
||
z += lz;
|
||
let ndx = dx * rx - dy * ry;
|
||
let ndy = dy * rx + dx * ry;
|
||
let lengde = (ndx * ndx + ndy * ndy).sqrt().max(1e-12);
|
||
dx = ndx / lengde;
|
||
dy = ndy / lengde;
|
||
}
|
||
Some((x, y, z, dx, dy))
|
||
}
|
||
|
||
fn punkt(fil: &Fil, r: Option<u64>, skala: f64) -> (f64, f64, f64) {
|
||
let Some(e) = r.and_then(|r| fil.hent(r)) else {
|
||
return (0.0, 0.0, 0.0);
|
||
};
|
||
let v = e.arg(0).map(|a| a.som_liste()).unwrap_or(&[]);
|
||
let g = |i: usize| v.get(i).and_then(|a| a.som_tall()).unwrap_or(0.0) * skala;
|
||
(g(0), g(1), g(2))
|
||
}
|
||
|
||
fn retning(fil: &Fil, r: Option<u64>) -> Option<(f64, f64)> {
|
||
let e = r.and_then(|r| fil.hent(r))?;
|
||
let v = e.arg(0).map(|a| a.som_liste()).unwrap_or(&[]);
|
||
if v.len() < 2 {
|
||
return None;
|
||
}
|
||
Some((
|
||
v[0].som_tall().unwrap_or(1.0),
|
||
v[1].som_tall().unwrap_or(0.0),
|
||
))
|
||
}
|
||
|
||
type Egenskaper = HashMap<u64, HashMap<String, Arg>>;
|
||
|
||
/// Samler alle egenskaper fra `IfcRelDefinesByProperties` per objekt.
|
||
fn samle_egenskaper(fil: &Fil) -> Egenskaper {
|
||
let mut ut: Egenskaper = HashMap::new();
|
||
for (_, rel) in fil.av_type("IFCRELDEFINESBYPROPERTIES") {
|
||
let objekter = rel.arg(4).map(|a| a.som_liste()).unwrap_or(&[]);
|
||
let Some(def) = rel
|
||
.arg(5)
|
||
.and_then(|a| a.som_ref())
|
||
.and_then(|r| fil.hent(r))
|
||
else {
|
||
continue;
|
||
};
|
||
if def.typ != "IFCPROPERTYSET" {
|
||
continue;
|
||
}
|
||
let mut verdier = HashMap::new();
|
||
for p in def.arg(4).map(|a| a.som_liste()).unwrap_or(&[]) {
|
||
let Some(pe) = p.som_ref().and_then(|r| fil.hent(r)) else {
|
||
continue;
|
||
};
|
||
if pe.typ != "IFCPROPERTYSINGLEVALUE" {
|
||
continue;
|
||
}
|
||
let (Some(navn), Some(v)) = (pe.arg(0).and_then(|a| a.som_tekst()), pe.arg(2)) else {
|
||
continue;
|
||
};
|
||
verdier.insert(navn.to_string(), v.clone());
|
||
}
|
||
for o in objekter {
|
||
if let Some(r) = o.som_ref() {
|
||
ut.entry(r).or_default().extend(verdier.clone());
|
||
}
|
||
}
|
||
}
|
||
// Typeobjektenes egenskaper arves av forekomstene.
|
||
let mut arv: Vec<(u64, HashMap<String, Arg>)> = Vec::new();
|
||
for (_, rel) in fil.av_type("IFCRELDEFINESBYTYPE") {
|
||
let Some(typ) = rel.arg(5).and_then(|a| a.som_ref()) else {
|
||
continue;
|
||
};
|
||
let Some(verdier) = ut.get(&typ).cloned() else {
|
||
continue;
|
||
};
|
||
for o in rel.arg(4).map(|a| a.som_liste()).unwrap_or(&[]) {
|
||
if let Some(r) = o.som_ref() {
|
||
arv.push((r, verdier.clone()));
|
||
}
|
||
}
|
||
}
|
||
for (r, verdier) in arv {
|
||
let e = ut.entry(r).or_default();
|
||
for (k, v) in verdier {
|
||
e.entry(k).or_insert(v);
|
||
}
|
||
}
|
||
ut
|
||
}
|
||
|
||
/// Samler alle mengder fra `IfcElementQuantity` per objekt.
|
||
fn samle_mengder(fil: &Fil) -> HashMap<u64, HashMap<String, f64>> {
|
||
let mut ut: HashMap<u64, HashMap<String, f64>> = HashMap::new();
|
||
for (_, rel) in fil.av_type("IFCRELDEFINESBYPROPERTIES") {
|
||
let objekter = rel.arg(4).map(|a| a.som_liste()).unwrap_or(&[]);
|
||
let Some(def) = rel
|
||
.arg(5)
|
||
.and_then(|a| a.som_ref())
|
||
.and_then(|r| fil.hent(r))
|
||
else {
|
||
continue;
|
||
};
|
||
if def.typ != "IFCELEMENTQUANTITY" {
|
||
continue;
|
||
}
|
||
let mut verdier = HashMap::new();
|
||
for q in def.arg(5).map(|a| a.som_liste()).unwrap_or(&[]) {
|
||
let Some(qe) = q.som_ref().and_then(|r| fil.hent(r)) else {
|
||
continue;
|
||
};
|
||
let Some(navn) = qe.arg(0).and_then(|a| a.som_tekst()) else {
|
||
continue;
|
||
};
|
||
if let Some(v) = qe.arg(3).and_then(|a| a.som_tall()) {
|
||
verdier.insert(navn.to_string(), v);
|
||
}
|
||
}
|
||
for o in objekter {
|
||
if let Some(r) = o.som_ref() {
|
||
ut.entry(r).or_default().extend(verdier.clone());
|
||
}
|
||
}
|
||
}
|
||
ut
|
||
}
|
||
|
||
/// Kobler vinduer og dører til veggen de sitter i, via åpningene.
|
||
fn samle_apninger(fil: &Fil) -> (HashMap<u64, u64>, HashMap<u64, u64>) {
|
||
// åpning → vertselement
|
||
let mut vert_for_apning: HashMap<u64, u64> = HashMap::new();
|
||
for (_, rel) in fil.av_type("IFCRELVOIDSELEMENT") {
|
||
if let (Some(vert), Some(apning)) = (
|
||
rel.arg(4).and_then(|a| a.som_ref()),
|
||
rel.arg(5).and_then(|a| a.som_ref()),
|
||
) {
|
||
vert_for_apning.insert(apning, vert);
|
||
}
|
||
}
|
||
let mut vindu = HashMap::new();
|
||
let mut dor = HashMap::new();
|
||
for (_, rel) in fil.av_type("IFCRELFILLSELEMENT") {
|
||
let (Some(apning), Some(element)) = (
|
||
rel.arg(4).and_then(|a| a.som_ref()),
|
||
rel.arg(5).and_then(|a| a.som_ref()),
|
||
) else {
|
||
continue;
|
||
};
|
||
let Some(vert) = vert_for_apning.get(&apning) else {
|
||
continue;
|
||
};
|
||
match fil.hent(element).map(|e| e.typ.as_str()) {
|
||
Some("IFCDOOR") => {
|
||
dor.insert(element, *vert);
|
||
}
|
||
Some("IFCWINDOW") => {
|
||
vindu.insert(element, *vert);
|
||
}
|
||
_ => {}
|
||
}
|
||
}
|
||
(vindu, dor)
|
||
}
|
||
|
||
fn egenskap(e: &Egenskaper, r: u64, navn: &str) -> Option<f64> {
|
||
e.get(&r)?.get(navn)?.som_tall()
|
||
}
|
||
|
||
fn u_verdi(e: &Egenskaper, r: u64) -> Option<f64> {
|
||
[
|
||
"ThermalTransmittance",
|
||
"UValue",
|
||
"U-Value",
|
||
"Varmegjennomgangskoeffisient",
|
||
]
|
||
.iter()
|
||
.find_map(|n| egenskap(e, r, n))
|
||
.filter(|u| *u > 0.0 && *u < 20.0)
|
||
}
|
||
|
||
fn er_ytre(e: &Egenskaper, r: u64) -> Option<bool> {
|
||
let v = e.get(&r)?.get("IsExternal")?;
|
||
match v {
|
||
Arg::Enum(s) => Some(s == "T" || s.eq_ignore_ascii_case("true")),
|
||
Arg::Tall(n) => Some(*n != 0.0),
|
||
Arg::Tekst(s) => Some(s == "T" || s.eq_ignore_ascii_case("true")),
|
||
_ => None,
|
||
}
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod tester {
|
||
use super::*;
|
||
|
||
/// To yttervegger på 5 × 2,5 m med hver sin trekantgeometri, i millimeter.
|
||
/// Sørveggen ligger ved y = −5 m, nordveggen ved y = +5 m.
|
||
fn prove() -> String {
|
||
prove_med(&[(100, "Sorvegg", -5.0), (120, "Nordvegg", 5.0)])
|
||
}
|
||
|
||
/// Som `prove`, men med de veggene testen ber om: (entitetsnummer, navn, y i meter).
|
||
fn prove_med(vegger: &[(u64, &str, f64)]) -> String {
|
||
let mut s = String::from(
|
||
"ISO-10303-21;\nHEADER;ENDSEC;\nDATA;\n #1= IFCSIUNIT(*,.LENGTHUNIT.,.MILLI.,.METRE.);\n #2= IFCUNITASSIGNMENT((#1));\n #3= IFCPROJECT('p',$,'Prosjekt',$,$,$,$,(#40),#2);\n #4= IFCDIRECTION((0.,1.));\n #40= IFCGEOMETRICREPRESENTATIONCONTEXT($,'Model',3,1.E-5,#50,#4);\n #5= IFCSIUNIT(*,.LENGTHUNIT.,$,.METRE.);\n #10= IFCBUILDING('b',$,'Testhus',$,$,#20,$,$,.ELEMENT.,$,$,$);\n #20= IFCLOCALPLACEMENT($,#21);\n #21= IFCAXIS2PLACEMENT3D(#22,$,$);\n #22= IFCCARTESIANPOINT((0.,0.,0.));\n #200= IFCPROPERTYSINGLEVALUE('ThermalTransmittance',$,IFCREAL(0.18),$);\n #201= IFCPROPERTYSINGLEVALUE('IsExternal',$,IFCBOOLEAN(.T.),$);\n #202= IFCPROPERTYSET('ps',$,'Pset_WallCommon',$,(#200,#201));\n #300= IFCSPACE('s',$,'Stue',$,$,#20,$,'Stue',.ELEMENT.,.INTERNAL.,$);\n #310= IFCQUANTITYAREA('NetFloorArea',$,$,100.0,$);\n #311= IFCQUANTITYVOLUME('NetVolume',$,$,250.0,$);\n #312= IFCELEMENTQUANTITY('q2',$,'BaseQuantities',$,$,(#310,#311));\n #313= IFCRELDEFINESBYPROPERTIES('r3',$,$,$,(#300),#312);\n",
|
||
);
|
||
// En vegg som en tynn kasse: 5 m lang, 2,5 m høy, 0,2 m tykk, i millimeter.
|
||
let mut vegg = |nr: u64, navn: &str, y: f64| {
|
||
let (p, l, h, tj) = (nr, 5000.0, 2500.0, 200.0);
|
||
s.push_str(&format!(
|
||
"#{}= IFCWALL('w{p}',$,'{navn}',$,$,#{},#{},$,$);\n",
|
||
p,
|
||
p + 1,
|
||
p + 4
|
||
));
|
||
s.push_str(&format!("#{}= IFCLOCALPLACEMENT(#20,#{});\n", p + 1, p + 2));
|
||
s.push_str(&format!(
|
||
"#{}= IFCAXIS2PLACEMENT3D(#{},$,#{});\n",
|
||
p + 2,
|
||
p + 3,
|
||
p + 9
|
||
));
|
||
s.push_str(&format!(
|
||
"#{}= IFCCARTESIANPOINT((0.,{:.1},0.));\n",
|
||
p + 3,
|
||
y * 1000.0
|
||
));
|
||
s.push_str(&format!(
|
||
"#{}= IFCPRODUCTDEFINITIONSHAPE($,$,(#{}));\n",
|
||
p + 4,
|
||
p + 5
|
||
));
|
||
s.push_str(&format!(
|
||
"#{}= IFCSHAPEREPRESENTATION(#40,'Body','Tessellation',(#{}));\n",
|
||
p + 5,
|
||
p + 6
|
||
));
|
||
s.push_str(&format!(
|
||
"#{}= IFCTRIANGULATEDFACESET(#{},$,.T.,((1,2,3),(1,3,4),(5,7,6),(5,8,7),(1,5,6),(1,6,2),(2,6,7),(2,7,3),(3,7,8),(3,8,4),(4,8,5),(4,5,1)),$);\n",
|
||
p + 6,
|
||
p + 7
|
||
));
|
||
s.push_str(&format!(
|
||
"#{}= IFCCARTESIANPOINTLIST3D(((0.,0.,0.),({l:.1},0.,0.),({l:.1},{tj:.1},0.),(0.,{tj:.1},0.),(0.,0.,{h:.1}),({l:.1},0.,{h:.1}),({l:.1},{tj:.1},{h:.1}),(0.,{tj:.1},{h:.1})));\n",
|
||
p + 7
|
||
));
|
||
s.push_str(&format!("#{}= IFCDIRECTION((1.,0.,0.));\n", p + 9));
|
||
s.push_str(&format!(
|
||
"#{}= IFCRELDEFINESBYPROPERTIES('rel{p}',$,$,$,(#{p}),#202);\n",
|
||
p + 8
|
||
));
|
||
};
|
||
for (nr, navn, y) in vegger {
|
||
vegg(*nr, navn, *y);
|
||
}
|
||
s.push_str("ENDSEC;\nEND-ISO-10303-21;");
|
||
s
|
||
}
|
||
|
||
#[test]
|
||
fn leser_areal_uverdi_og_himmelretning_av_geometrien() {
|
||
let r = fra_tekst(&prove(), "prove").unwrap();
|
||
let b = &r.bygning;
|
||
assert_eq!(b.bygning.navn, "Testhus");
|
||
assert_eq!(b.bygning.oppvarmet_bra, 100.0);
|
||
assert_eq!(b.bygning.oppvarmet_volum, Some(250.0));
|
||
assert_eq!(b.flate.len(), 2, "flater: {:?}", b.flate);
|
||
for f in &b.flate {
|
||
// Hovedflaten er 5 × 2,5 m, ikke summen av alle sider.
|
||
assert!(
|
||
(f.areal - 12.5).abs() < 0.01,
|
||
"{} fikk areal {}",
|
||
f.navn,
|
||
f.areal
|
||
);
|
||
assert_eq!(f.u_verdi, Some(0.18));
|
||
assert_eq!(f.mot, Mot::Ute);
|
||
}
|
||
let sor = b
|
||
.flate
|
||
.iter()
|
||
.find(|f| f.navn.starts_with("Sorvegg"))
|
||
.unwrap();
|
||
let nord = b
|
||
.flate
|
||
.iter()
|
||
.find(|f| f.navn.starts_with("Nordvegg"))
|
||
.unwrap();
|
||
assert!(
|
||
(sor.orientering - 180.0).abs() < 1.0,
|
||
"sør = {}",
|
||
sor.orientering
|
||
);
|
||
assert!(
|
||
nord.orientering < 1.0 || nord.orientering > 359.0,
|
||
"nord = {}",
|
||
nord.orientering
|
||
);
|
||
}
|
||
|
||
#[test]
|
||
fn samme_vegg_i_flere_etasjer_telles_en_gang() {
|
||
// Den samme veggen på nøyaktig samme sted to ganger, slik en eksport gjør når den
|
||
// legger de samme delene i flere etasjer.
|
||
let tekst = prove_med(&[
|
||
(100, "Sorvegg", -5.0),
|
||
(120, "Nordvegg", 5.0),
|
||
(140, "Sorvegg", -5.0),
|
||
]);
|
||
let r = fra_tekst(&tekst, "prove").unwrap();
|
||
assert_eq!(r.bygning.flate.len(), 2, "flater: {:?}", r.bygning.flate);
|
||
assert!(
|
||
r.merknader.iter().any(|m| m.contains("dobbelt i modellen")),
|
||
"{:?}",
|
||
r.merknader
|
||
);
|
||
}
|
||
|
||
#[test]
|
||
fn vegger_faar_himmelretning_i_navnet() {
|
||
let r = fra_tekst(&prove(), "prove").unwrap();
|
||
let mut navn: Vec<&str> = r.bygning.flate.iter().map(|f| f.navn.as_str()).collect();
|
||
navn.sort();
|
||
assert_eq!(navn, vec!["Nordvegg, nord", "Sorvegg, sør"]);
|
||
}
|
||
|
||
#[test]
|
||
fn uoppvarmede_rom_fra_tilleggsfilen_holdes_utenfor_bra() {
|
||
let valg = Importvalg {
|
||
uoppvarmede_rom: vec!["STUE".into()],
|
||
};
|
||
let r = fra_tekst_med(&prove(), "prove", &valg).unwrap();
|
||
assert_ne!(r.bygning.bygning.oppvarmet_bra, 100.0);
|
||
assert!(r
|
||
.merknader
|
||
.iter()
|
||
.any(|m| m.contains("uoppvarmet etter tilleggsfilen")));
|
||
}
|
||
|
||
/// Lengdeenheten skal hentes gjennom prosjektets enhetsoppsett, ikke ved å lete
|
||
/// gjennom alle enheter i filen. Prøvefilen har både millimeter og meter.
|
||
#[test]
|
||
fn lengdeenheten_hentes_fra_prosjektet() {
|
||
let fil = step::les(&prove());
|
||
assert_eq!(ifcgeom::lengdeenhet(&fil), 0.001);
|
||
}
|
||
|
||
/// Et postformat festet på bygningen og eksportert som IFC-egenskapssett skal leses,
|
||
/// slik at byggeår, tetthet, ventilasjon og varmekilde kommer med fra modellen.
|
||
#[test]
|
||
fn egenskapssett_paa_bygningen_leses() {
|
||
let t = prove().replace(
|
||
"#300= IFCSPACE(",
|
||
"#400= IFCPROPERTYSINGLEVALUE('Byggeaar',$,IFCINTEGER(1948),$);\n\
|
||
#401= IFCPROPERTYSINGLEVALUE('Lekkasjetall',$,IFCREAL(8.0),$);\n\
|
||
#402= IFCPROPERTYSINGLEVALUE('Ventilasjonstype',$,IFCLABEL('Balansert'),$);\n\
|
||
#403= IFCPROPERTYSINGLEVALUE('Varmegjenvinning',$,IFCREAL(80.0),$);\n\
|
||
#404= IFCPROPERTYSINGLEVALUE('Varmekilde',$,IFCLABEL('Bergvarmepumpe'),$);\n\
|
||
#405= IFCPROPERTYSINGLEVALUE('Kommune',$,IFCLABEL('Indre \u{d8}stfold'),$);\n\
|
||
#406= IFCPROPERTYSET('ps2',$,'Enok',$,(#400,#401,#402,#403,#404,#405));\n\
|
||
#407= IFCRELDEFINESBYPROPERTIES('r4',$,$,$,(#10),#406);\n\
|
||
#300= IFCSPACE(",
|
||
);
|
||
let r = fra_tekst(&t, "prove").unwrap();
|
||
let b = &r.bygning;
|
||
assert_eq!(b.bygning.byggeaar, 1948);
|
||
assert_eq!(b.infiltrasjon.n50, Some(8.0));
|
||
assert_eq!(b.ventilasjon.typ, VentilasjonType::Balansert);
|
||
assert_eq!(b.ventilasjon.gjenvinning, Some(0.8));
|
||
assert_eq!(b.klima.kommune.as_deref(), Some("Indre Østfold"));
|
||
assert_eq!(b.oppvarming.kilde.len(), 1);
|
||
assert_eq!(b.oppvarming.kilde[0].typ, VarmekildeType::VaeskeVannVp);
|
||
assert!(r.merknader.iter().any(|m| m.contains("tatt i bruk")));
|
||
}
|
||
|
||
#[test]
|
||
fn eksport_uten_bygningsdeler_gir_tydelig_feil() {
|
||
let tom = "ISO-10303-21;\nHEADER;ENDSEC;\nDATA;\n\
|
||
#1= IFCSIUNIT(*,.LENGTHUNIT.,.MILLI.,.METRE.);\n\
|
||
#2= IFCUNITASSIGNMENT((#1));\n\
|
||
#3= IFCPROJECT('p',$,'Prosjekt',$,$,$,$,$,#2);\n\
|
||
#10= IFCBUILDING('b',$,'Hus',$,$,$,$,$,.ELEMENT.,$,$,$);\n\
|
||
#11= IFCBUILDINGSTOREY('k',$,'Kjeller',$,$,$,$,$,.ELEMENT.,-2350.);\n\
|
||
ENDSEC;\nEND-ISO-10303-21;";
|
||
let feil = fra_tekst(tom, "tom")
|
||
.err()
|
||
.expect("en tom eksport skal gi feil");
|
||
let tekst = feil.to_string();
|
||
assert!(tekst.contains("ingen bygningsdeler"), "{tekst}");
|
||
assert!(tekst.contains("1 etasjer"), "{tekst}");
|
||
}
|
||
|
||
/// Adressen på firmaet som laget modellen skal ikke bli byggets adresse.
|
||
#[test]
|
||
fn adressen_hentes_fra_bygningen_og_ikke_fra_forfatteren() {
|
||
let t = prove().replace(
|
||
"#10= IFCBUILDING('b',$,'Testhus',$,$,#20,$,$,.ELEMENT.,$,$,$);",
|
||
"#501= IFCPOSTALADDRESS($,$,$,$,('Firmaveien 1'),$,'Firmaby',$,'9999','Norge');\n\
|
||
#502= IFCORGANIZATION('999999999','Eksempel AS',$,$,(#501));\n\
|
||
#503= IFCPERSON($,'Nordmann','Kari',$,$,$,$,$);\n\
|
||
#504= IFCPERSONANDORGANIZATION(#503,#502,$);\n\
|
||
#500= IFCPOSTALADDRESS($,$,$,$,('Eksempelveien 12'),$,'Eksempelby',$,'1234','Norge');\n\
|
||
#10= IFCBUILDING('b',$,'Testhus',$,$,#20,$,$,.ELEMENT.,$,$,#500);",
|
||
);
|
||
let r = fra_tekst(&t, "prove").unwrap();
|
||
assert_eq!(
|
||
r.bygning.bygning.adresse.as_deref(),
|
||
Some("Eksempelveien 12, 1234 Eksempelby")
|
||
);
|
||
assert_eq!(
|
||
r.bygning.bygning.energiraadgiver.as_deref(),
|
||
Some("Kari Nordmann, Eksempel AS")
|
||
);
|
||
}
|
||
|
||
#[test]
|
||
fn plassholderadresse_og_standardnavn_brukes_ikke() {
|
||
let t = prove()
|
||
.replace(
|
||
"#10= IFCBUILDING('b',$,'Testhus',$,$,#20,$,$,.ELEMENT.,$,$,$);",
|
||
"#500= IFCPOSTALADDRESS($,$,$,'Vectorworks Architect',$,$,$,$,$,$);\n\
|
||
#10= IFCBUILDING('b',$,'Default Building',$,$,#20,$,$,.ELEMENT.,$,$,#500);",
|
||
)
|
||
.replace(
|
||
"#3= IFCPROJECT('p',$,'Prosjekt',$,$,$,$,(#40),#2);",
|
||
"#3= IFCPROJECT('p',$,'Eksempelhuset','Energianalyse',$,'Eksempelhuset','Eksisterende',(#40),#2);",
|
||
);
|
||
let r = fra_tekst(&t, "prove").unwrap();
|
||
assert_eq!(r.bygning.bygning.adresse, None);
|
||
assert_eq!(r.bygning.bygning.navn, "Eksempelhuset");
|
||
}
|
||
|
||
#[test]
|
||
fn georeferering_i_utm_gir_posisjon_for_klimavalg() {
|
||
let t = prove().replace(
|
||
"#4= IFCDIRECTION((0.,1.));",
|
||
"#4= IFCDIRECTION((0.,1.));\n\
|
||
#600= IFCPROJECTEDCRS('EPSG:25832','ETRS89 / UTM zone 32N','ETRS89',$,$,$,$);\n\
|
||
#601= IFCMAPCONVERSION(#40,#600,613351.291,6611921.980,0.,1.,0.,$);",
|
||
);
|
||
let r = fra_tekst(&t, "prove").unwrap();
|
||
let [b, l] = r
|
||
.bygning
|
||
.klima
|
||
.posisjon
|
||
.expect("posisjon fra georefereringen");
|
||
assert!(
|
||
(b - 59.63).abs() < 1e-4 && (l - 11.01).abs() < 1e-4,
|
||
"{b}, {l}"
|
||
);
|
||
}
|
||
|
||
#[test]
|
||
fn vectorworks_standardplassering_brukes_ikke() {
|
||
let t = prove().replace(
|
||
"#4= IFCDIRECTION((0.,1.));",
|
||
"#4= IFCDIRECTION((0.,1.));\n\
|
||
#600= IFCPROJECTEDCRS('EPSG:3857',$,'WGS 84',$,$,$,$);\n\
|
||
#601= IFCMAPCONVERSION(#40,#600,-8575524.35228859,4705852.25746973,0.,1.,0.,$);",
|
||
);
|
||
let r = fra_tekst(&t, "prove").unwrap();
|
||
assert_eq!(r.bygning.klima.posisjon, None);
|
||
assert!(r.merknader.iter().any(|m| m.contains("standardplassering")));
|
||
}
|
||
|
||
#[test]
|
||
fn terrenget_leses_av_de_naermeste_punktene() {
|
||
// Et terreng som faller mot øst: bakken er høyere ved vestveggen enn ved østveggen.
|
||
let punkter: Vec<[f64; 3]> = (0..10)
|
||
.flat_map(|i| (0..10).map(move |j| [i as f64, j as f64, -1.0 - 0.2 * i as f64]))
|
||
.collect();
|
||
let vest = terreng_ved(&punkter, 0.5, 5.0).unwrap();
|
||
let ost = terreng_ved(&punkter, 8.5, 5.0).unwrap();
|
||
assert!(vest > ost, "vest {vest}, øst {ost}");
|
||
assert!((vest + 1.1).abs() < 0.2, "vest {vest}");
|
||
assert!((ost + 2.7).abs() < 0.2, "øst {ost}");
|
||
assert_eq!(terreng_ved(&[], 0.0, 0.0), None);
|
||
}
|
||
|
||
#[test]
|
||
fn grunnmur_over_terreng_av_hoydene() {
|
||
// ±0 ligger 131,2 moh., terrenget 130,6 moh. og første etasje på ±0: 0,6 m over bakken.
|
||
assert!((over_terreng_for_kjeller(131.2, 130.6, 0.0, 2.35) - 0.6).abs() < 1e-9);
|
||
// Aldri mer enn kjellerhøyden, og aldri under null.
|
||
assert_eq!(over_terreng_for_kjeller(131.2, 125.0, 0.0, 2.35), 2.35);
|
||
assert_eq!(over_terreng_for_kjeller(130.0, 131.0, 0.0, 2.35), 0.0);
|
||
}
|
||
|
||
#[test]
|
||
fn vegg_uten_geometri_utelates() {
|
||
let uten = prove().replace("'Body','Tessellation'", "'Axis','Curve2D'");
|
||
let r = fra_tekst(&uten, "prove").unwrap();
|
||
assert!(r.bygning.flate.is_empty());
|
||
assert!(r
|
||
.merknader
|
||
.iter()
|
||
.any(|m| m.contains("geometrien ikke ga noe areal")));
|
||
}
|
||
}
|