Masterproef:
Warmteverlies in een BIM-systeem
Kandidaat: Filip Van Duyse Promotoren Interne promotor: Ing. Cedric Vuye Externe promotor: Ing. Wim Tas 2011-2012
Woord vooraf Dit eindwerk werd gerealiseerd in het kader van de Master opleiding van het departement Industriële Wetenschappen & Technologie, optie Bouwkunde aan de Artesis Hogeschool te Antwerpen. De reden waarom ik voor dit onderwerp gekozen heb, is tweezijdig. Ten eerste omdat BIMsystemen een vrij recente ontwikkeling zijn en alle mogelijkheden hiervan nog niet volledig bepaald zijn. Het programmeren door het schrijven van macro’s biedt dan ook een oneindig aantal nieuwe mogelijkheden. Hier zal in de toekomst nog veel gebruik van gemaakt worden. Ten tweede speelt ook het berekenen van warmteverliezen een steeds grotere rol. Door de stijgende energieprijzen wordt er al langer dan vandaag meer en meer aandacht besteed aan het isoleren van gebouwen. Door beide zaken te combineren is deze masterproef zeker gemaakt met het oog op de toekomst.
De auteur geeft de toelating dit afstudeerwerk voor consultatie beschikbaar te stellen en delen van het afstudeerwerk te kopiëren voor eigen gebruik. Elk ander gebruik valt onder de beperkingen van het auteursrecht, in het bijzonder met betrekking tot de verplichting de bron uitdrukkelijk te vermelden bij het aanhalen van resultaten uit dit afstudeerwerk. 25 mei 2012
© artesis
p 1 / 83
Dankwoord Eerst en vooral zou ik mijn externe promotor, de heer Wim Tas, van harte willen bedanken voor het aanbrengen van dit onderwerp en het leveren van de nodige informatie om deze masterproef af te werken. Verder wil ik zeker nog de heer Jos Vandamme bedanken voor mij in te leiden in de wereld van BIM-systemen en in het bijzonder Autodesk Revit. Ook mevrouw Valerie Van Belleghem, mijn eerste interne promotor, wil ik via deze weg bedanken. Ten slotte wil ik de heer Cedric Vuye bedanken om op het laatste moment nog als mijn interne promotor op te treden. Ook mijn familie en vrienden mogen niet vergeten worden in dit dankwoord. Dankzij hun steun en zorg was het mogelijk om dit eindwerk tot een goed einde te brengen.
© artesis
p 2 / 83
Inhoudsopgave Woord vooraf Dankwoord Inhoudsopgave Figuurlijst Tabellenlijst Inleiding 1. Doel 2. Inhoud Hoofdstuk 1: Warmteverlies 1. Inleiding 2. Theorie warmteverlies[3]
1 2 3 7 8 9 9 10 11 11 12
2.1.
Inleiding
12
2.2.
Domein
12
2.3.
Voorwaarden, definities en symbolen
12
2.3.1.
Voorwaarden en definities
12
2.3.2.
Symbolen en eenheden
13
2.4.
Principe van de berekeningsmethode
13
2.5.
Algemene aspecten
14
2.5.1.
Berekeningswijze voor verwarmde ruimtes
14
2.5.2.
Berekeningswijze voor een bouwdeel of een gebouw
14
2.6.
Vereiste gegevens
14
2.6.1.
Klimatologische gegevens
14
2.6.2.
Interne ontwerptemperatuur
15
2.6.3.
Bouwgegevens
15
2.7.
Totale ontwerpwarmtebelasting van een verwarmde ruimte: Basisgeval
15
2.7.1.
Ontwerptransmissieverlies
16
2.7.2.
Ontwerpventilatieverlies
18
3.
Beperkingen
21
3.1.
Beperkingen op het warmteverlies
21
3.1.1.
Warmteverlies rechtstreeks naar buiten
21
3.1.2.
Warmteverlies naar buiten via een onverwarmde ruimte
21
3.1.3.
Warmteverlies naar buiten via de grond
21
3.1.4.
Ventilatieverlies met eventueel ventilatiesysteem
21
© artesis
p 3 / 83
3.2.
Beperkingen in Autodesk Revit
21
3.2.1.
Exportproblemen
21
3.2.2.
Beperkte u-waarden
22
3.2.3.
Koudebruggen
22
4.
gbXML [7]
23
4.1.
Inleiding
23
4.2.
Geschiedenis
23
4.3.
Geometrie
24
4.4.
Voor- en nadelen
25
5.
C# [1][2][8][9]
26
5.1.
Veelgebruikte gegevenstypes
26
5.1.1.
Integer
26
5.1.2.
Double
26
5.1.3.
Boolean
26
5.1.4.
String
26
5.1.5.
Array
27
5.1.6.
ArrayList
27
5.1.7.
XmlTextReader
27
5.2.
Veelgebruikte codeertechnieken
27
5.2.1.
Lussen
27
5.3.
Aanpassingen aan de macro
28
5.3.1.
Openen van de macro
28
5.3.2.
Aanpassen van de macro
28
5.3.3.
Compileren van de macro
28
Hoofdstuk 2: Autodesk Revit - Macro 1. Inleiding 2. Autodesk Revit model
29 29 30
2.1.
Beginvoorwaarden
30
2.1.1.
Aanmaken van spaces
30
2.1.2.
Aanmaken van parameters
30
2.1.3.
Constructie instellen
31
2.2.
Exporteren naar gbXML
31
© artesis
p 4 / 83
2.3.
Macro
32
2.3.1.
Starten
32
2.3.2.
Inlezen
33
2.3.3.
Berekening
35
2.3.4.
Uitvoer
42
3. Handleiding om het warmteverlies te berekenen gebruik makend van het programma. 45 3.1.
Stap 1: Nieuw project opstarten
45
3.2.
Stap 2: Model invoegen
45
3.3.
Stap 3: Ruimtes definiëren
45
3.4.
Stap 4: Ruimtes instellen
46
3.5.
Stap 5: Algemene instellingen
47
3.6.
Stap 6: Binnenmuren definiëren
47
3.7.
Stap 7: gbXML
48
3.8.
Stap 8: Macro starten
48
Hoofdstuk 3: Nabeschouwing 1. Inleiding 2. Testcase
49 49 51
2.1.
Gegevens
51
2.2.
Resultaten
51
2.2.1.
Kelder
52
2.2.2.
Gelijkvloers
52
2.2.3.
Eerste verdiep
52
2.3.
Besluit
52
Hoofdstuk 4: Conclusie Hoofdstuk 5: Bibliografie 1. Boeken 2. Internet Bijlagen 1. Volledige code van de macro 2. Warmteverlies via de vloer volgens NBN EN 13370
53 54 54 54 55 55 76
2.1.
76
© artesis
Vereenvoudigde wijze:
p 5 / 83
2.2.
Volgens norm EN ISO 13370:
76
2.2.1.
Stap 1
76
2.2.2.
Stap 2
77
2.2.3.
Stap 3
77
2.2.4.
Stap 4
77
2.2.5.
Conclusie
77
3.
© artesis
Resultaten testcase
78
p 6 / 83
Figuurlijst Figuur 1 – mogelijke u-waarden in Autodesk Revit ......................................................................... 22 Figuur 2- Verschil tussen Autodesk Revit en DesignBuilder ........................................................... 25 Figuur 3 - voorbeeld van een Autodesk Revit model ....................................................................... 30 Figuur 4 – instellen van de constructie-elementen .......................................................................... 31 Figuur 5 – voorbeeld van exporteren naar gbXML .......................................................................... 32 Figuur 6 – aanvang van de macro ................................................................................................... 32 Figuur 7 - Globale parameters ........................................................................................................ 32 Figuur 8 – code die inlezen start ..................................................................................................... 33 Figuur 9 – overzicht object .............................................................................................................. 33 Figuur 10 – object na inlezen bouwdata .......................................................................................... 34 Figuur 11 – object na inlezen gegevens constructie-elementen ...................................................... 34 Figuur 12 – object na invullen van u-waarden ................................................................................. 35 Figuur 13 – code die berekening start ............................................................................................. 35 Figuur 14 – code die uitvoer van resultaten bevat ........................................................................... 42 Figuur 15 – Voorbeeld van tekstbestand met resultaten ................................................................. 43 Figuur 16 – messagebox met resultaten ......................................................................................... 44 Figuur 17 - Nieuw project aan de hand van een template ............................................................... 45 Figuur 18 - Space Schedule ............................................................................................................ 46 Figuur 19 - "Building Construction" - venster ................................................................................... 47 Figuur 20 - Instellingen van DesignBuilder ...................................................................................... 49 Figuur 21 – Grafiek met resultaten van DesignBuilder .................................................................... 50 Figuur 22 - Tabel met resultaten van DesignBuilder ....................................................................... 50 Figuur 23 - Model voor testcase ...................................................................................................... 51 Figuur 24 - Kelder, gelijkvloers en 1e verdiep ................................................................................. 51 Figuur 25 - Voorbeeld van het model .............................................................................................. 76
© artesis
p 7 / 83
Tabellenlijst Tabel 1- symbolen en eenheden ..................................................................................................... 13 Tabel 2 – noodzakelijke bouwgegevens .......................................................................................... 15 Tabel 3 – noodzakelijke parameters warmteverlies......................................................................... 15 Tabel 4 – noodzakelijke parameters ventilatieverlies ...................................................................... 15 Tabel 5 - Equivalente U-waarde voor vloerplaat op grondniveau .................................................... 17 Tabel 6 - Equivalente U-waarde voor vloerplaat 3m onder grondniveau ......................................... 18 Tabel 7 - Equivalente U-waarde voor muren onder grondniveau .................................................... 18 Tabel 8 - Hiërarchie van gbXML ...................................................................................................... 23 Tabel 9 -Geschiedenis van gbXML ................................................................................................. 24 Tabel 10 - Veelvuldig gebruikte methoden van XmlTextReader ..................................................... 27 Tabel 11 - Procedures die warmteverliezen berekenen .................................................................. 35 Tabel 12 - Instellingen van SpaceSchedule .................................................................................... 46
© artesis
p 8 / 83
Inleiding 1. Doel 1
De doelstelling van deze masterproef was het schrijven van een macro in een BIM-systeem , in dit 2
geval Autodesk Revit . De macro zou snel het warmteverlies van het model bepalen zonder dat er externe software aan te pas komt. De warmteverliesberekening heeft als doel het bepalen van de warmtebelasting. Hieruit kan men dan het verwarmingssysteem dimensioneren. Vroeger werd het warmteverlies berekend door het model te exporteren naar specifieke analyse programma’s. Hierin werden dan de nodige bewerkingen uitgevoerd om tot de resultaten te komen en deze resultaten dienden dan manueel overgenomen te worden in Autodesk Revit. Dit nam veel tijd in beslag. Deze macro berekent de verliezen en geeft snel een beeld van het warmteverlies tussen de ruimtes van het gebouw onderling als het warmteverlies naar de buitenomgeving. Uitgaande van de resultaten kan men het gebouw en dan vooral de gebruikte materialen in de opbouw ervan aanpassen. Hierna kan men starten met het dimensioneren van het verwarmingssysteem en het plaatsen van verwarmingstoestellen in het model.
1
BIM staat voor Building Information Management
2
Autodesk Revit is een ontwerpprogramma waarin onder andere 3D modellen aangemaakt kunnen worden.
© artesis
p 9 / 83
2. Inhoud Het eindwerk is grotendeels onderverdeeld in twee delen. Het eerste deel bevat de theoretische achtergrond van warmteverliezen. Het behandelt alle nodige informatie die nodig is om warmteverliezen te berekenen en de nodige beperkingen die ingevoerd werden. Hiernaast volgt nog een inleiding in gbXML
3
en C#. Deze zullen helpen om het
programmeergedeelte beter te begrijpen. Het tweede gedeelte beschrijft hoe de macro gecreëerd werd. Het proces in Autodesk Revit dat doorlopen wordt om de resultaten te verkrijgen, wordt van begin tot einde overlopen. Verder vindt u hier een handleiding die stap voor
stap uitlegt hoe u met het programma
werkt.
Aansluitend volgt een testcase waarin het warmteverlies van een simpel voorbeeldmodel berekend zal worden aan de hand van een analyseprogramma. De volledige code van de macro bevindt zich in de bijlage.
3
gbXML: green building Extensible Markup Language
© artesis
p 10 / 83
Hoofdstuk 1: Warmteverlies 1. Inleiding Alvorens er in Autodesk Revit gestart kan worden, zal eerst de theoretische kant van warmteverlies bekeken moeten worden. Deze wordt beschreven in verschillende Europese normen. De algemene norm die vastlegt hoe de berekening van warmteverliezen moet gebeuren is NBN EN 12831. Hierin staan de nodige formules en deze norm vervangt gedeeltelijk NBN B 62-003. Voor enkele bouwelementen van het gebouw wordt verwezen naar extra normen. Deze worden daar dan ook vermeld en verklaard. Na de samenvatting van de norm zullen de beperkingen toegelicht worden. Hierdoor zal het theoretisch gedeelte zoals het gebruikt werd in het computerprogramma duidelijk zijn. Ten slotte volgt een korte inleiding in het ontstaan en gebruik van gbXML gevolgd door een introductie van C# in verband met de belangrijkste termen die gebruikt bij het schrijven van de macro.
© artesis
p 11 / 83
2. Theorie warmteverlies[3] 2.1. Inleiding Deze norm beschrijft de berekening van de ontwerpwarmtebelasting: tussen 2 kamers of 2 verwarmde ruimtes met als doel de verwarmingselementen te bepalen; van een volledig gebouw met als doel de totale warmtetoevoer te bepalen.
2.2. Domein De norm bevat methoden om het ontwerpwarmteverlies en de ontwerpwarmtebelasting te berekenen van normale gevallen. Normale gevallen omvatten alle gebouwen: met een maximale hoogte van de kamers niet groter dan 5m; die verwarmd worden tot op een stabiele temperatuur.
2.3. Voorwaarden, definities en symbolen 2.3.1.Voorwaarden en definities a.
Kelder
Een kamer wordt als kelder beschouwd wanneer meer dan 70% van de externe muren in contact zijn met de grond. b.
Bouwelement
Bouwcomponenten zoals vloeren, muren… c.
Bouwdeel
Totaal volume dat verwarmd wordt door één verwarmingssysteem. d.
Ontwerptemperatuurverschil
Verschil tussen de interne ontwerptemperatuur en de externe ontwerptemperatuur. e.
Ontwerpwarmteverlies
Warmtehoeveelheid per tijdseenheid die het gebouw verlaat onder specifieke ontwerpvoorwaarden. f.
Ontwerpwarmteverliescoëfficiënt
Verschil in ontwerpwarmteverlies per temperatuureenheid. g.
Ontwerpventilatieverliescoëfficiënt
Verschil in ontwerpventilatieverlies per temperatuureenheid. h.
Ontwerpwarmtetransport
Warmte die getransporteerd wordt binnen een gebouw of een bouwdeel. i.
Ontwerpwarmtebelasting
Vereiste warmtestroom om te voldoen aan de ontwerpvoorwaarden. j.
Ontwerptransmissieverlies van een ruimte
Warmteverlies naar buiten of naar andere verwarmde ruimtes ten gevolge van thermische geleiding. k.
Ontwerpventilatieverlies van een ruimte
Warmteverlies naar buiten of naar andere verwarmde ruimtes ten gevolge van ventilatie. l.
Externe luchttemperatuur
Temperatuur van de lucht buiten het gebouw. m.
Externe ontwerptemperatuur
Externe luchttemperatuur die gebruikt wordt bij de berekening van het ontwerpwarmteverlies.
© artesis
p 12 / 83
n.
Verwarmde ruimte
Ruimte die verwarmd dient te worden tot de interne ontwerptemperatuur. o.
Interne luchttemperatuur
Temperatuur van de lucht in het gebouw. p.
Interne ontwerptemperatuur
Interne luchttemperatuur in het centrum van de verwarmde ruimte die gebruikt wordt bij de berekening van het ontwerpwarmteverlies. q.
Gemiddelde jaarlijkse buitentemperatuur
Gemiddelde waarde van de buitentemperatuur tijdens het jaar. r.
Thermische zone
Gedeelte van de verwarmde kamer met een vaste temperatuur of met verwaarloosbare verschillen. s.
Onverwarmde ruimte
Ruimte die geen deel uitmaakt van de verwarmde ruimtes. t.
Ventilatiesysteem
Systeem dat de ventilatie omvat. u.
Zone
Een groep van ruimtes die gelijke thermische karakteristieken hebben.
2.3.2.Symbolen en eenheden Symbool
Naam
Eenheid
a, b, c, f
variabele factoren
-
A
oppervlakte
m²
cp
specifieke warmte capaciteit
J/(kg*K)
d
dikte
m
ei
“schild” coëfficiënt
-
ek, el
correctiefactoren
-
Gw
grondwater correctie factor
-
H
warmteverlies coëfficiënt
W/(m²*K)
l
lengte
m
n
aantal luchtwisselingen
1/h
n50
aantal luchtwisselingen bij 50Pa drukverschil 1/h tussen binnen en buiten
T
temperatuur in Kelvin
K
U
thermische geleidingscoëfficiënt
W/(m²*K)
V
volume
m³
Ѵ
luchtstroom
m³/s
ε
hoogte correctie factor
-
Φ
warmteverlies
W
η
efficiëntie
%
λ
thermische geleidingscoëfficiënt
W/(m*K)
θ
temperatuur in °C
°C
ρ
massadichtheid
kg/m³
Ψ
lineaire thermische geleidingscoëfficiënt
W/(mK)
Tabel 1- symbolen en eenheden
2.4. Principe van de berekeningsmethode De methode voor de algemene gevallen steunt op 2 hypothesen:
© artesis
p 13 / 83
de temperatuurdistributie is uniform; de warmteverliezen worden berekend eigenschappen van de bouwelementen.
bij
stationaire
temperaturen
en
vaste
Aanvankelijk wordt eerst het ontwerpwarmteverlies berekend. Deze resultaten worden dan gebruikt om de ontwerpwarmtebelasting te bepalen. Bij de berekening van het ontwerpwarmteverlies van een verwarmde ruimte wordt met volgende componenten rekening gehouden: ontwerptransmissieverlies: warmteverlies naar buiten of naar andere verwarmde ruimtes ten gevolge van thermische geleiding; ontwerpventilatieverlies: warmteverlies naar buiten of naar andere verwarmde ruimtes ten gevolge van ventilatie.
2.5. Algemene aspecten 2.5.1.Berekeningswijze voor verwarmde ruimtes De berekeningswijze voor verwarmde ruimtes verloopt als volgt: a) Bepaal de externe ontwerptemperatuur en de gemiddelde jaarlijkse buitentemperatuur; b) Bepaal van elke ruimte of ze verwarmd of onverwarmd is en hun bijhorende interne ontwerptemperatuur; c) Bepaal de dimensies en de thermische eigenschappen van de bouwdelen van elk van deze ruimtes; d) Bereken de ontwerpwarmteverliescoëfficiënt en vermenigvuldig deze met het verschil tussen de interne en de externe ontwerptemperatuur om zo het ontwerptransmissieverlies te bekomen; e) Bereken de ontwerpventilatieverliescoëfficiënt en vermenigvuldig deze met het verschil tussen de interne en de externe ontwerptemperatuur om zo het ontwerpventilatieverlies te bekomen; f) Bereken het totale ontwerpwarmteverlies door het ontwerptransmissieverlies en het ontwerpventilatieverlies op te tellen; g) Bereken de opwarmcapaciteit, dit is het bijkomend vermogen dat nodig is om het warmteverlies te compenseren bij onderbroken verwarming; h) Bereken de totale ontwerpwarmtebelasting van de ruimte door het totale ontwerpwarmteverlies en de opwarmcapaciteit samen te tellen.
2.5.2.Berekeningswijze voor een bouwdeel of een gebouw Voor het dimensioneren van de nodige totale warmtelevering dient men eerst de totale ontwerpwarmtebelasting te bepalen. Deze berekening is gebaseerd op de resultaten van voorgaande berekeningswijze. a) Som alle ontwerptransmissieverliezen op zonder rekening te houden met de warmtetransmissie binnen het bouwdeel of gebouw zelf om zo tot het totale ontwerptransmissieverlies te komen; b) Som alle ontwerpventilatieverliezen op zonder rekening te houden met de warmteventilatie binnen het bouwdeel of gebouw zelf om zo tot het totale ontwerpventilatieverlies te komen; c) Tel het totale ontwerptransmissieverlies samen met het totale ontwerpventilatieverlies om zo het totale ontwerpwarmteverlies van het bouwdeel of gebouw te bekomen; d) Bereken de totale opwarmcapaciteit door deze van elke ruimte apart op te tellen; e) Bereken de totale ontwerpwarmtebelasting van het bouwdeel of het gebouw door het totale ontwerpwarmteverlies en de totale opwarmcapaciteit samen te tellen.
2.6. Vereiste gegevens 2.6.1.Klimatologische gegevens Voor de berekeningsmethode worden volgende waarden gebruikt: Externe ontwerptemperatuur θe, om het ontwerpwarmteverlies naar buiten te berekenen; Gemiddelde jaarlijkse buitentemperatuur θm,e, om het ontwerpwarmteverlies via de grond te berekenen.
© artesis
p 14 / 83
2.6.2.Interne ontwerptemperatuur De binnentemperatuur die gebruikt wordt voor de berekening is de interne ontwerptemperatuur θint. In dit geval worden de interne ontwerptemperatuur en de gebruikstemperatuur gelijkgesteld aan elkaar.
2.6.3.Bouwgegevens De gegevens van de ruimtes die nodig zijn voor de berekening zijn: Symbool Naam van de parameter Eenheid V
Volume van elke kamer
m³
A
Oppervlakte van elk bouwelement
m²
U
Warmteverliescoëfficiënt
W/(m²K)
Ψ
Lineaire Warmteverliescoëfficiënt
W/(mK)
l
Lengte van de koudebrug
m
Tabel 2 – noodzakelijke bouwgegevens
Voor de berekening van de warmteverliescoëfficiënt zullen verschillende parameters nodig zijn. Deze worden hieronder opgesomd, gevolgd door de norm waarin deze beschreven worden. Symbool en eenheid Naam van de parameter Gerelateerde norm Rsi (m²K/W)
Interne oppervlakte weerstand
EN ISO 6946
Rse (m²K/W)
Externe oppervlakte weerstand
EN ISO 6949
λ (W/mK)
Thermische geleiding
EN ISO 10456 EN ISO 12525 EN ISO 13370
R (m²K/W)
Thermische weerstand
EN ISO 6946
Ra (m²K/W)
Thermische weerstand van luchtlagen
EN ISO 6946 EN ISO 10077-1
U (W/m²K)
Thermische geleiding
EN ISO 6946 EN ISO 10077-1
Ψ (W/mK)
Lineaire thermische geleiding
EN ISO 10211-1 EN ISO 14683
χ (W/K)
Punt-thermische geleding
EN ISO 10211-1
Tabel 3 – noodzakelijke parameters warmteverlies
Voor de berekening van het warmteverlies door ventilatie worden volgende parameters gebruikt: Symbool Naam van de parameter Eenheid nmin
minimaal aantal luchtwisselingen per uur
h
-1
n50
luchtwisselingen bij 50Pa drukverschil tussen h
-1
binnen en buiten per uur Ѵ inf
luchtstroom via infiltratie
m³/s
Ѵ su
luchtaanvoer
m³/s
Ѵ ex
luchtafvoer
ηѴ
warmteherwinningscoëfficiënt
m³/s van
de -
luchtafvoer Tabel 4 – noodzakelijke parameters ventilatieverlies
2.7. Totale ontwerpwarmtebelasting Basisgeval
van
een
verwarmde
ruimte:
De totale ontwerpwarmtebelasting Φi van een verwarmde ruimte (i) wordt berekend als volgt: 2-1 met
© artesis
ΦT,i = ontwerptransmissieverlies van een verwarmde ruimte (i) in Watt;
p 15 / 83
ΦV,i = ontwerpventilatieverlies van een verwarmde ruimte (i) in Watt.
2.7.1.Ontwerptransmissieverlies Het ontwerptransmissieverlies van een verwarmde ruimte (i) ΦT,i wordt berekend als volgt: (
) (
)
2-2
met
HT,i = ontwerptransmissiecoëfficiënt van een verwarmde ruimte via de bouwschil in W/K; HT,iue = ontwerptransmissiecoëfficiënt van een verwarmde ruimte naar een onverwarmde ruimte in W/K; HT,ig = ontwerptransmissiecoëfficiënt van een verwarmde ruimte via de grond in W/K; HT,ij = ontwerptransmissiecoëfficiënt van een verwarmde ruimte naar een naburige verwarmde kamer, verwarmd op een andere temperatuur, in W/K; θint,i = interne ontwerptemperatuur van een verwarmde kamer in °C; θe = externe ontwerptemperatuur in °C. a.
Warmteverlies rechtstreeks naar buiten HT,i
De ontwerptransmissiecoëfficiënt wordt als volgt berekend: ∑
∑
2-3
met
2;
Ak = oppervlakte van bouwelement (k) in m ek, el = corrigerende factoren in verband met verschillende isolatie, vochtopname, windsnelheid in het geval hier nog geen rekening met gehouden werd bij de berekening van de U-waarde. Deze waarden worden beide gelijkgesteld aan 1 wegens gebrek aan informatie van de gebruikte materialen. 2 Uk = thermische geleidingscoëfficiënt van bouwelement (k) in W/(m K); ll = lengte van de koudebrug (l) in m; Ψl = lineaire thermische geleidingscoëfficiënt van de koudebrug (l) in W/(mK). b.
Warmteverlies naar buiten via een onverwarmde ruimte HT,iue
Wanneer er zich tussen de verwarmde ruimte en de buitenkant een onverwarmde ruimte (u) bevindt, zal de ontwerptransmissiecoëfficiënt op volgende wijze berekend worden: ∑
∑
2-4
met
bu = factor die rekening houdt met het temperatuurverschil van de onverwarmde ruimte en de externe ontwerptemperatuur. Deze waarde moet volgens één van volgende manieren bepaald worden: o Als de temperatuur van de onverwarmde ruimte θ u gegeven of berekend is, wordt bu bepaald door volgende formule: 2-5 o
Als θu niet bekend is, wordt bu gegeven door: 2-6
met
© artesis
Hiu = warmteverliescoëfficiënt van de verwarmde ruimte (i) naar de onverwarmde ruimte (u) in W/K; Hue = warmteverliescoëfficiënt van de onverwarmde ruimte (u) naar buiten (e) in W/K.
p 16 / 83
c.
Warmteverlies naar buiten via de grond HT,ig [4]
Het warmteverlies door de vloeren en kelderwanden is afhankelijk van verschillende factoren zoals de grootte van het oppervlak in contact met de grond, de diepte van de (kelder)vloer onder de grond en thermische eigenschappen van de grond. Dit verlies wordt gedetailleerd berekend in de norm NBN EN ISO 13370. Hieronder volgt echter de vereenvoudigde versie uit de norm die in het programma ook toegepast wordt. Het verschil tussen beide methoden werd nagegaan en het resultaat hiervan kan teruggevonden worden in de bijlage. De ontwerptransmissiecoëfficiënt van de verwarmde ruimte (i) naar de grond (g) wordt als volgt berekend: (∑
)
2-7
met
fg1 = Correctiefactor die de variatie van de buitentemperatuur in de loop van het jaar verrekent; deze factor hangt af van land tot land maar wordt volgens de norm vastgelegd op 1,45; fg2 = factor die rekening houdt met het temperatuurverschil tussen de gemiddelde jaarlijkse buitentemperatuur en de externe ontwerptemperatuur via volgende formule: 2-8
Ak = oppervlak van element (k) dat in contact komt met de grond in m²; Uequiv,k = thermische geleidingscoëfficiënt van bouwelement k in W/(m²K); Gw = Correctiefactor die de stand van het grondwater verrekent.
De waarde van Uequiv,k is afhankelijk van het gebruikt type vloer en kan uit tabellen gehaald worden. De vloer kan ofwel op of onder het grondniveau liggen. In beide gevallen wordt gebruik gemaakt van de parameter B’. Deze houdt rekening met de oppervlakte en de omtrek van de vloer: 2-9
met
2
Ag = oppervlakte van de vloerplaat in m ; P = omtrek van de vloerplaat grenzend aan de omgeving in m.
B’-waarde
Uequiv,k voor vloerplaat op grondniveau Geen isolatie
Uvloer =
Uvloer = 2
Uvloer = 2
Uvloer = 2
2
2,0 W/m K
1,0 W/m K
0,5 W/m K
0,25 W/m K
2
1,30
0,77
0,55
0,33
0,17
4
0,88
0,59
0,45
0,30
0,17
6
0,68
0,48
0,38
0,28
0,17
8
0,55
0,41
0,33
0,25
0,15
10
0,47
0,36
0,30
0,23
0,14
12
0,41
0,32
0,27
0,21
0,14
14
0,37
0,29
0,24
0,19
0,13
16
0,33
0,26
0,22
0,18
0,13
18
0,31
0,24
0,21
0,17
0,12
20
0,28
0,22
0,19
0,16
0,12
Tabel 5 - Equivalente U-waarde voor vloerplaat op grondniveau
B’-waarde
Uequiv,k voor vloerplaat 3m onder grondniveau Geen isolatie
Uvloer =
Uvloer = 2
2,0 W/m K
© artesis
Uvloer = 2
1,0 W/m K
Uvloer = 2
0,5 W/m K
2
0,25 W/m K
p 17 / 83
2
0,63
0,46
0,35
0,24
0,14
4
0,51
0,40
0,33
0,24
0,14
6
0,43
0,35
0,29
0,22
0,14
8
0,37
0,31
0,26
0,21
0,14
10
0,32
0,27
0,24
0,19
0,13
12
0,29
0,25
0,22
0,18
0,13
14
0,26
0,23
0,20
0,17
0,12
16
0,24
0,21
0,19
0,16
0,12
18
0,22
0,20
0,18
0,15
0,11
20
0,21
0,18
0,16
0,14
0,11
Tabel 6 - Equivalente U-waarde voor vloerplaat 3m onder grondniveau
In het laatste geval dient ook de thermische geleidingscoëfficiënt van de ondergrondse muren aangepast te worden. Uwall Uequiv z = 3m 0,00
0,00
0,50
0,32
0,75
0,43
1,00
0,53
1,25
0,61
1,50
0,68
1,75
0,74
2,00
0,79
2,25
0,84
2,50
0,88
2,75
0,92
3,00
0,96
Tabel 7 - Equivalente U-waarde voor muren onder grondniveau
d.
Warmteverlies naar of van een aangrenzende ruimte, verwarmd op een verschillende temperatuur HT,ij
HT,ij stelt de ontwerptransmissiecoëfficiënt voor die voorkomt tussen 2 kamers die verwarmd zijn op een verschillende temperatuur. Dit kunnen ruimtes van het zelfde gebouw zijn of ruimtes van twee aangrenzende gebouwen. De berekening verloopt als volgt: ∑
2-10
met
fij = factor die rekening houdt met het temperatuurverschil tussen de twee verwarmde ruimtes, gegeven door: 2-11
Ak = oppervlak van element (k) dat in contact komt met de aangrenzende ruimte in m²; 2 Uk = thermische geleidingscoëfficiënt van bouwelement (k) in W/(m K);
Het effect van koudebruggen werd hier niet in rekening gebracht.
2.7.2.Ontwerpventilatieverlies Het ontwerp ventilatieverlies ΦV,i voor een verwarmde ruimte (i) wordt als volgt berekend: (
© artesis
)
2-12
p 18 / 83
met
HѴ,i = ontwerpventilatieverlies in W/K; θint,i = interne ontwerptemperatuur van de verwarmde ruimte in °C; θe = externe ontwerptemperatuur in °C.
De ontwerpventilatieverliescoëfficiënt HV,i wordt berekend via volgende formule: 2-13 met
Ѵ i = luchtstroom van een verwarmde ruimte (i) in m³/s; ρ = dichtheid van lucht in kg/m³; cp = specifieke warmtecapaciteit van lucht in kJ/(kgK).
Men kan ρ en cp als constante beschouwen en op die manier de formule herschrijven als: 2-14 met Ѵi hier uitgedrukt in m³/h. De wijze waarop de luchtstroom van de verwarmde kamer (i) Ѵi berekend wordt, is afhankelijk van de aan- of afwezigheid van een ventilatiesysteem. a.
Zonder ventilatiesysteem
Bij de afwezigheid van een ventilatiesysteem wordt verondersteld dat de aangevoerde lucht dezelfde thermische karakteristieken heeft als de buitenlucht. Hierdoor zal het warmteverlies evenredig zijn met het temperatuurverschil tussen de binnen- en buitenlucht. De waarde van de luchtstroom Ѵi, die nodig zal zijn voor de berekening van de ontwerpventilatieverliescoëfficiënt, wordt bepaald via volgende formule: (
)
2-15
met
Ѵ i = luchtstroom van een verwarmde ruimte (i) in m³/h; Ѵ inf,i = luchtstroom via infiltratie in m³/h; Ѵ min,i = minimale luchtstroom voor hygiënische redenen in m³/h.
De luchtstroom via infiltratie Ѵinf,i wordt als volgt berekend: 2-16 met
Vi = volume van de verwarmde ruimte in m³; n50 = aantal luchtwisselingen bij 50Pa drukverschil tussen binnen en buiten per uur; ei = “schild”-coëfficiënt; εi = hoogte correctie factor (windsnelheid ~ hoogte van de ruimte).
De factor 2 in de vergelijking compenseert het feit dat n 50 op het hele gebouw berekend is. Wanneer in het slechtste geval alle luchtinfiltratie langs één zijde van het gebouw binnenkomt, zal deze hier rekening met houden. De waarden voor deze parameters zijn terug te vinden in de nationale bijlage. Voor hygiënische redenen is er een minimale luchtstroom Ѵmin,i vereist. Deze wordt berekend als volgt: 2-17 met
nmin = minimale hoeveelheid externe luchtwisselingen per uur; Vi = volume van de verwarmde ruimte in m³.
De minimale hoeveelheid externe luchtwisselingen is vastgelegd in de nationale bijlage.
© artesis
p 19 / 83
b.
Met ventilatiesysteem
Indien er een ventilatiesysteem aanwezig is, heeft de aangevoerde lucht niet noodzakelijk dezelfde thermische karakteristieken als de buitenlucht. In volgende gevallen kan dit verschillen: bij de aanwezigheid van een warmteherwinningssysteem; wanneer de buitenlucht voorverwarmd wordt; wanneer de toegevoegde lucht afkomstig is van aangrenzende kamers. Wanneer dergelijke gevallen zich voordoen, zal een temperatuurreductiefactor ingevoerd worden. Deze zal het temperatuurverschil tussen de aangevoerde lucht en de buitenlucht in rekening brengen. Bij kamers die meer lucht afvoeren dan aangevoerd krijgen, zal dit verschil gecompenseerd worden door buitenlucht die door de bouwschil heen dringt. In dit geval zal ook de reductiefactor gebruikt worden. De vergelijking om de luchtstroom Ѵ i te berekenen, wordt hieronder weergegeven: 2-18 met
Ѵinf,i = luchtstroom via infiltratie in m³/h; Ѵsu,i = luchtaanvoer in de verwarmde ruimte in m³/h; Ѵmech,inf,i = hoeveelheid lucht in ruimte (i) die meer afgevoerd dan aangevoerd wordt in m³/h; f Ѵ,i = temperatuurreductiefactor, berekend met volgende formule: 2-19
met o
θsu, i = temperatuur van de extra aangevoerde lucht in °C; deze kan in het geval van een warmteherwinningssysteem berekend worden via de efficiëntie van dit systeem.
De luchtaanvoer in de verwarmde ruimte Ѵsu,i is afhankelijk van het ventilatie systeem. De waarden van Ѵsu,i zijn afhankelijk van systeem tot systeem en zijn terug te vinden bij de ontwerper hiervan. Indien er geen gegevens van het systeem bekend zijn, zal de berekening van het ventilatieverlies gebeuren zonder het ventilatiesysteem in de berekening te betrekken. Ѵmech,inf kan berekend worden via volgende formule: (
)
2-20
met
Ѵex = hoeveelheid lucht die het gebouw verlaat in m³/h; Ѵsu = hoeveelheid lucht die aangevoerd wordt in m³/h.
Ѵmech,inf,i kan dan als volgt berekend worden: ∑
2-21
met
© artesis
Vi = het volume van de ruimte (i).
p 20 / 83
3. Beperkingen 3.1. Beperkingen op het warmteverlies Omdat het doel van deze masterproef meer gericht is op het creëren van een macro, zullen enkele beperkingen in verband met de theorie ingevoerd worden.
3.1.1.Warmteverlies rechtstreeks naar buiten In formule 2-3 zal de laatste term, die de aanwezigheid van koudebruggen verrekend, niet gebruikt worden. In Autodesk Revit wordt geen rekening gehouden met koudebruggen. Dit verlies zal achteraf nog gecompenseerd worden. Zie 3.2.3 Koudebruggen De waarden ek, el zullen gelijk gesteld worden aan 1 zoals NBN EN 12831 voorschrijft bij gebrek aan nationale waarden.
3.1.2.Warmteverlies naar buiten via een onverwarmde ruimte Onverwarmde ruimtes zullen berekend worden zoals verwarmde ruimtes. De gebruiker zal hier bij het instellen van de kamertemperatuur rekening met moeten houden. Ook hier wordt de aanwezigheid van eventuele koudebruggen buiten beschouwing gelaten.
3.1.3.Warmteverlies naar buiten via de grond Warmteverlies via de grond wordt in de gebruikte norm en in de macro op vereenvoudigde wijze berekend. Een gedetailleerde berekening werd dan ook uitgevoerd aan de hand van EN ISO 13370 om het verschil tussen beide werkwijzen te bekijken. Deze berekening zit in de bijlage. De waarde van fg1 wordt gelijkgesteld aan 1,45 zoals de norm voorschrijft. De factor Gw zal de gebruiker zelf instellen. Wanneer het verschil tussen grondwater en de vloerplaat kleiner is dan 1 meter krijgt Gw de waarde 1,15. In de andere gevallen zal deze factor de waarde 1 krijgen.
3.1.4.Ventilatieverlies met eventueel ventilatiesysteem De gebruiker dient vooraf de eigenschappen van het mechanisch ventilatiesysteem in te geven. Hieronder verstaat men: Ѵsu,i = luchtaanvoer in de verwarmde ruimte (standaard ingesteld op 150 m³/h); Ѵex = hoeveelheid lucht die het gebouw verlaat (standaard ingesteld op 0 m³/h); θsu, i = temperatuur van de extra aangevoerde lucht. Wanneer er geen ventilatiesysteem aanwezig is, moet Ѵ su,i in alle kamers gelijkgesteld worden aan 0. Hierdoor weet het programma dat het de minimale ventilatieverliezen zal moeten berekenen.
3.2. Beperkingen in Autodesk Revit Autodesk Revit en gbXML zorgen op hun beurt voor enkele beperkingen. Enkele konden opgelost worden, maar voor andere was dit onmogelijk.
3.2.1.Exportproblemen Wanneer het model geëxporteerd wordt naar gbXML, zouden niet alle noodzakelijke gegevens aanwezig zijn in dit gbXML-document. Zo zal er voor onder andere de temperatuur van de ruimtes geen parameter voorzien zijn. Dit was ook het geval voor de buitentemperatuur en het mechanisch ventilatiesysteem. Dit probleem werd opgelost door in de macro deze waarde rechtstreekst uit Autodesk Revit te halen in plaats van deze uit het gbXML-document te lezen.
© artesis
p 21 / 83
3.2.2.Beperkte u-waarden Het instellen van de u-waarden wordt beperkt door de aangeboden mogelijkheden in het programma. Er kunnen dus geen waarden naar keuze ingegeven worden. Autodesk Revit biedt wel 4
een groot aantal vooropgestelde waarden aan , samen met enkele eigenschappen van het gebruikte materiaal. Zie Figuur 1
Figuur 1 – mogelijke u-waarden in Autodesk Revit
3.2.3.Koudebruggen Koudebruggen zijn plaatsen in een gebouw waar warmteverlies plaatsvindt door slechte, thermische isolatie. Deze verbindingen ontstaan vooral bij bouwknopen zoals tussen muur en vloer maar ook tussen ramen en deuren. Autodesk Revit kan hier geen rekening met houden. Als oplossing hiervoor krijgen de waarden die vereenvoudigd werden, een extra 20%.[6]
4
Voor een volledig overzicht:
http://docs.autodesk.com/RVTMPJ/2011/ENU/filesUsersGuide/Constructions_index.html
© artesis
p 22 / 83
4. gbXML [7] 4.1. Inleiding Het “green building XML” schema of kortweg gbXML is ontwikkeld om de overdracht van informatie uit een BIM-bestand te vergemakkelijken. Deze overdracht of interoperabiliteit moet zorgen voor een betere samenhang van aan de ene kant ontwerpsoftware en aan de andere kant 5
analysesoftware. De ontwikkeling van gbXML is gebaseerd op XML . Deze ontwerptaal kan gegevens gestructureerd weergeven in de vorm van een platte tekst. Deze voorstelling is zowel leesbaar voor de mens als voor computers. De XML-specificatie definieert de syntaxis van elementen, attributen en de andere structuren die in XML-bestanden kunnen voorkomen. De XMLspecificatie legt echter geen namen vast voor deze elementen en attributen, precies omdat deze keuze afhangt van het doel van het XML-bestand. Een voorbeeld vindt u hieronder:
N-1-E-W-2 0.000000 -6.571592 9.307143 0.000000 <Tilt>90.000000 4.000000 <Width>5.000000 -11.571592
© artesis
p 24 / 83
9.307143 0.000000 -11.571592 9.307143 4.000000 -6.571592 9.307143 4.000000 -6.571592 9.307143 0.000000
4.4. Voor- en nadelen Er zijn enkele belangrijke voordelen van gbXML voor deze masterproef: Van elk oppervlak worden de aangrenzende ruimtes weergegeven; De eigenschappen van de ruimtes worden samengevat; De eigenschappen van de materialen worden gestructureerd weergegeven; Toch zijn er enkele nadelen aan verbonden: Er kunnen geen extra eigenschappen toegevoegd worden aan de ruimtes; (zie 3.2 Beperkingen in Autodesk Revit ) Er kunnen enkel rechthoekige vormen geëxporteerd worden. Wanneer een project met gebogen muren in Autodesk Revit opgebouwd wordt, geeft dit niet het verwachte resultaat wanneer het geïmporteerd wordt in DesignBuilder. Zie Figuur 2. De macro kan hier wel warmteverliezen voor bepalen.
Figuur 2- Verschil tussen Autodesk Revit en DesignBuilder
© artesis
p 25 / 83
5. C# [1][2][8][9] Omdat een basiskennis van C# wel nodig is om de code te kunnen begrijpen, vindt u hieronder een kleine handleiding die de gebruikte termen uit de macro zal verklaren. Om te beginnen zullen enkele belangrijke gegevenstypes uitgelicht worden.
5.1. Veelgebruikte gegevenstypes 5.1.1.Integer Declaratie:
int myInt = 123;
Een integer is gegevenstype dat gehele, numerieke gegevens kan bevatten. Er zijn meerdere soorten integers beschikbaar. Deze verschillen van elkaar in de hoeveelheid beschikbare bits. De standaard integer bevat 32 bits en kan dus 2
32
verschillende waarden aannemen. Deze waarden
variëren van -2 147 483 648 tot 2 147 483 647. Wanneer er buiten deze grenzen getreden wordt, zal er overflow (of underflow) optreden. In de macro worden integers meestal gebruikt als teller om de inhoud van de objecten te overlopen. Voorbeeld: for (int tellerSpace = 0; tellerSpace < building.Count; tellerSpace++)
5.1.2.Double Declaratie:
double myDouble = 123.456;
Een double is een gegevenstype dat reële, numerieke gegevens kan bevatten. Ook hier zijn meerdere soorten beschikbaar maar als standaard worden 64 bits gebruikt. De waarden hiervan kunnen variëren van ±5.0 × 10−324 tot ±1.7 × 10308. In de macro worden er veel doubles gebruikt. Alle numerieke gegevens die voorkomen werden als double vastgelegd. Voorbeeld: double q, temp1, temp2;
5.1.3.Boolean Declaratie:
bool myBool = true;
Een boolean is een gegevenstype met slechts twee mogelijkheden: true of false. Het wordt gebruikt om de waarheidswaarde van logische expressies te representeren. In de macro worden booleans voor verschillende doeleinden gebruikt. Voorbeeld: if (Convert.ToString(boundary[1]) == "ExteriorWall") {bool interior = false;}
5.1.4.String Declaratie:
string myString = “abcd123”;
Een string is een gegevenstype dat een reeks karakters bevat. Deze worden dan tussen aanhalingstekens geschreven. Het samenvoegen van 2 strings heet “concatenatie”. In de macro worden strings grotendeels gebruikt bij het uitschrijven van het tekstdocument met resultaten. Hier wordt geregeld gebruik gemaakt van een backslash. Hierdoor weet de computer dat het volgend karakter een speciale betekenis heeft. /t zorgt bijvoorbeeld voor een extra tab.
© artesis
p 26 / 83
Voorbeeld: file.WriteLine(" Totaal warmteverlies =\t\t" + Math.Round(h[teller]) + "\tWatt");
5.1.5.Array Declaratie:
int[] myIntArray = new int[5] { 1, 2, 3, 4, 5 };
Een array is een datastructuur die een reeks elementen bevat. Alle elementen moeten wel hetzelfde gegevenstype hebben. Elk element uit de reeks heeft een eigen index waarmee dat element aangeduid wordt. Het eerste element uit de array staat op indexlocatie 0! De index van een array met 5 elementen loopt dus van 0 tot en met 4. Voorbeeld: double[] warmteVerlies = new double[building.Count];
5.1.6.ArrayList Declaratie:
ArrayList building = new ArrayList();
Een arrayList werkt zoals een array met als belangrijkste verschil dat niet alle elementen van hetzelfde type hoeven te zijn. Ook hier heeft elk element een eigen index. Enkele belangrijke methodes die gebruik worden zijn Add, remove, count… In de macro worden alle gegevens uit het gbXML-bestand opgeslagen in een arrayList. Deze bevat zelf ook enkele arrayLists die op hun beurt ArrayLists bevatten. Voorbeeld: ArrayList building = new ArrayList();
5.1.7.XmlTextReader Declaratie:
XmlTextReader leesXml = new XmlTextReader("Warmteverlies.xml");
De XmlTextReader zal de XML lezen uit het bestand. Volgende methoden werden veelvuldig gebruikt in de macro: Read
Start het inlezen
Close
Stopt het inlezen
ReadToFollowing(“Name”)
Leest tot “Name” gevonden wordt
GetAttribute(“Name”)
Haalt het attribuut met als naam “Name” op
ReadString
Leest de string in op de huidige plaats
Name
Geeft de naam van het huidige element terug
Tabel 10 - Veelvuldig gebruikte methoden van XmlTextReader
5.2. Veelgebruikte codeertechnieken 5.2.1.Lussen Om het hoofdobject te doorzoeken, wordt steeds gebruik gemaakt van dezelfde lus-techniek. Deze lus zorgt ervoor dat alle objecten die binnen het hoofdobject (en onderliggende objecten) zitten, gebruikt kunnen worden binnen de procedure. Op deze manier worden ook alle objecten (kamers) één voor één overlopen.
© artesis
p 27 / 83
De eerste for-lus overloopt de elementen in het hoofdobject dat alle informatie van het gebouw omvat. Deze elementen zullen vanaf dan bereikbaar zijn onder de naam space en bevatten de informatie van één ruimte. De tweede for-lus overloopt de elementen binnen één space. Elk element hier stelt een boundary voor van deze space. Een boundary-object bevat de informatie van één oppervlak. Beide lussen samen overlopen dus alle oppervlakken uit het hele gebouw. Deze techniek wordt bij elke verwerkingsprocedure gevolgd.
5.3. Aanpassingen aan de macro In sommige gevallen kan het handig zijn om de code van de macro te bekijken en eventueel zelfs aanpassingen te maken. In dit gedeelte zal uitgelegd worden hoe de gebruiker dit moet aanpakken. Als voorbeeld zal het wijzigen van de locatie en de naam van het gbXML-bestand gebruikt worden.
5.3.1.Openen van de macro Om de code te kunnen aanpassen dient deze eerst geopend te worden. Dit gebeurt in Autodesk Revit door te klikken op Managge > Macro > Macro Manager. Hetzelfde venster dat gebruikt wordt om de macro te starten komt tevoorschijn. Wanneer we nu de macro selecteren en Edit klikken, zal de code tevoorschijn komen.
5.3.2.Aanpassen van de macro Op lijn 38 zal u volgende code zien staan: XmlTextReader leesXml = new XmlTextReader("Warmteverlies.xml"); Dit verwijst naar de plaats waar het gbXML-bestand zich bevindt. Wanneer u enkel de naam van het gbXML-bestand wil wijzigen, kan u deze hier vervangen en kan u meteen doorgaan met het compileren van de macro. Wanneer u echter ook de locatie van het gbXML-bestand dat dient ingelezen te worden wilt wijzigen, zal u iets meer moeten aanpassen. Omdat in C# een backslash een speciale functie heeft, dient er voor de string een @-symbool geplaatst te worden. Dit geeft aan dat in de volgende string de functie van de backslash genegeerd moet worden. Een voorbeeld van deze code is als volgt: XmlTextReader leesXml = new XmlTextReader(@"C:\Users\Filip\Documents\Warmteverlies.xml"); Wanneer u klaar bent met aanpassen, moet de macro nog gecompileerd worden. Dit is het omzetten van de code naar machinetaal.
5.3.3.Compileren van de macro Het compileren van de macro gebeurt door in de menubalk Build > Build Test te klikken. Indien er geen foutmeldingen komen, kan u het venster sluiten en verder werken in Autodesk Revit. Wanneer er echter wel foutmeldingen zijn, zullen deze onderaan het scherm opgesomd worden. Vergeet het Autodesk Revit model niet op te slaan! Anders worden ook u wijzigingen in de macro ongedaan gemaakt.
© artesis
p 28 / 83
Hoofdstuk 2: Autodesk Revit - Macro 1. Inleiding Nu de theoretische kant overlopen is, kan gestart worden met het implementeren van deze formules in Autodesk Revit. Dit zal gebeuren via het creëren van een macro die in het programma opgeroepen kan worden. Deze macro is geschreven in de programmeertaal C#. Het uitvoeren van de macro is echter slechts een onderdeel van het proces. Er zal om te beginnen aan enkele voorwaarden moeten voldaan zijn. Het Autodesk Revit model zal afgewerkt moeten zijn zodat het geëxporteerd kan worden naar gbXML. Daarna zal het gbXML-document gelokaliseerd moeten worden. Hierna kan de macro gestart worden. Deze zal eerst de nodige gegevens inlezen. Vervolgens worden deze gegevens gebruikt om van elke ruimte de warmteverliezen te bepalen. Ten slotte komen de resultaten op het scherm en worden deze op de juiste plaats opgeslagen. Het hele proces wordt hieronder uitgewerkt.
© artesis
p 29 / 83
2. Autodesk Revit model De eerste stap in het proces is het tekenen van het model. Hieronder zal in Autodesk Revit een gebouw uitgewerkt worden. Als voorbeeld zal onderstaand model (Figuur 3) genomen worden. Dit is een plattegrond van een fictief gebouw met 10 ruimtes.
Figuur 3 - voorbeeld van een Autodesk Revit model
Wanneer de geometrie van het gebouw klaar is, zullen enkele basisvoorwaarden vervuld moeten worden.
2.1. Beginvoorwaarden 2.1.1.Aanmaken van spaces Elke ruimte zal afgebakend moeten worden. Dit neemt in Autodesk Revit niet veel tijd in beslag. Deze spaces zullen in het gbXML-document zorgen voor een duidelijke structuur.
2.1.2.Aanmaken van parameters Er werden in het model nog twee nieuwe parameters aangemaakt. Deze parameters zijn temperatuur, warmteverlies, grondwater, buitentemperatuur en veiligheidsfactor. De eerste bevat de temperatuur van elke ruimte of space. Deze zal vooral belangrijk zijn bij het inlezen van de gegevens en kan gemakkelijk gewijzigd worden om andere gevallen te simuleren. De parameter warmteverlies zal ná het uitvoeren van de macro de resultaten bevatten. Voor elke ruimte zal hier een waarde ingevuld worden. Deze waarde is positief bij warmteverlies of negatief bij warmtewinst. Bij grondwater zal de gebruiker een waarde moeten ingeven die gebruikt zal worden door de macro. Deze waarde zal bij de berekening van de vloerplaat rekening houden met de hoogte van het grondwaterpeil. De buitentemperatuur bevat, zoals de naam het zegt, de temperatuur van de buitenlucht. Deze zal standaard ingesteld staan op -8°C. Dit om de meest extreme gevallen te simuleren. De veiligheidsfactor is een extra parameter die op het einde aan de resultaten wordt toegevoegd. Deze staat standaard ingesteld op 1.2 waardoor er 20% extra veiligheid zit op de resultaten.
© artesis
p 30 / 83
2.1.3.Constructie instellen Als laatste moeten de eigenschappen van de constructie-elementen vastgelegd worden. In Figuur 4 wordt het venster weergegeven waarin deze instellingen gebeuren. Wanneer er voor hetzelfde type elementen, verschillende materialen gebruikt worden in het model, zal de manier waarop dit moet ingegeven worden verder in het eindwerk besproken worden. Zie 3.Handleiding om het warmteverlies te berekenen gebruik makend van het programma.
Figuur 4 – instellen van de constructie-elementen
2.2. Exporteren naar gbXML Wanneer alle instellingen vastliggen, kan geëxporteerd worden naar gbXML. Hierbij wordt het gbXML-document aangemaakt en opgeslagen. Dit bestand dient opgeslagen te worden in dezelfde map als het Autodesk Revit bestand. In deze map zal de macro immers zoeken naar het bestand. Als naam moet “Warmteverlies” gebruikt worden. Wanneer de gebruiker een andere naam, of map, wil gebruiken, zal dit in de code van de macro ingesteld moete worden. Hoe dit juist gebeurt, werd eerder besproken in 5.3 Aanpassingen aan de macro. De instellingen hier zouden bij het correct invoeren van de beginvoorwaardes geen foutmeldingen mogen geven. (Figuur 5)
© artesis
p 31 / 83
Figuur 5 – voorbeeld van exporteren naar gbXML
2.3. Macro 2.3.1.Starten Nadat het gbXML-document aangemaakt is, zal de locatie op de harde schijf hiervan in de macrocode geplaatst moeten worden. De bovenste lijn in Figuur 6 legt deze vast. De overige code maakt vier belangrijke variabelen aan: leesXml: deze zal het gbXML document inlezen; building: dit is het hoofdobject dat uiteindelijk alle gegevens zal bevatten; surface: dit is een hulpobject om de oppervlakken in te lezen; storey: dit is een hulpobject om de verdiepingen in te lezen.
Figuur 6 – aanvang van de macro
Figuur 7 - Globale parameters
© artesis
p 32 / 83
Verder dienen eerst enkele constanten uit Autodesk Revit opgeslagen worden. Dit zijn parameters die niet via gbXML opgenomen kunnen worden. De buitentemperatuur, de grondwaterfactor en de veiligheidsfactor zijn hier de drie constanten. Zie Figuur 7. Hierna kan de macro opgestart worden.
2.3.2.Inlezen De macro zal eerst het gbXML-document lokaliseren. Hierna zal met het inlezen beginnen. Dit gebeurt in 4 stappen, zoals Figuur 8 weergeeft. Deze manier van werken was nodig omdat het lezen enkel voorwaarts kan gebeuren, er kan dus niet teruggekeerd worden; de opbouw van het gbXML-document niet toeliet om rechtstreeks alle gegevens in te lezen.
Figuur 8 – code die inlezen start
Na het inlezen zal er één object “building” gecreëerd zijn dat alle nodige gegevens bevat. (Figuur 9) Het object “building” bevat x aantal objecten, met x gelijk aan het aantal ruimtes in het model. Elk van deze objecten bevat informatie over deze ruimte. Dit kan een tekst (Id), een waarde (Area, Volume…) of terug een object (SpaceBoundary1). Deze objecten “SpaceBoundaries” stellen de oppervlakken van de ruimtes voor. Het aantal is afhankelijk van ruimte tot ruimte. Deze bevatten op hun beurt informatie over de oppervlakken. Ook hier zijn er terug verschillende mogelijkheden zoals tekst (SurfaceIdRef, AdjacentSpace), waarde (U-Value, Area) of object (Opening1). Deze objecten “Openingen” stellen de deuren en ramen voor. In het object vinden we de u-waarde en de oppervlakte van de opening terug.
Figuur 9 – overzicht object
© artesis
p 33 / 83
a.
“BuildingLezen”
“BuildingLezen” is een procedure die start met het opstellen van het object “building”. Hier wordt gestart met lezen en invoeren van gegevens. Enkel de temperatuur veroorzaakt hier een bijkomende moeilijkheid. Deze zal op een andere manier verkregen moeten worden. Deze parameter is immers door de gebruiker aangemaakt en zal dus niet in het gbXML-document terug te vinden zijn. Hierdoor moet in Autodesk Revit zelf de waarde opgezocht worden. Wanneer deze procedure klaar is, zal het object “building” de gegevens bevatten zoals in Figuur 10 aangegeven zijn.
Figuur 10 – object na inlezen bouwdata
b.
“SurfaceLezen”
Deze procedure zal een tijdelijk object “surface” aanmaken. Dit zal de verschillende soorten oppervlakken die in het model gebruikt werden bevatten. Ook alle gegevens van de oppervlakken zullen hier ingevuld worden (Figuur 11). Enkel de U-waarden worden later toegevoegd.
Figuur 11 – object na inlezen gegevens constructie-elementen
c.
“UwaardeInvullen”
Om het object “surface” te vervolledigen, dienen de U-waardes nog ingevuld te worden. Wanneer deze procedure afgerond is, zal het object er als volgt uitzien. (Figuur 12)
© artesis
p 34 / 83
Figuur 12 – object na invullen van u-waarden
d.
“BuildingVervolledigen”
Als laatste zal het object “building” vervolledigd moeten worden met informatie uit het object “surface”. Dit gebeurt door in beide objecten “Id” te vergelijken en, indien deze overeenstemmen, de gegevens te kopiëren. Wanneer dit gebeurd is, zal het object “building” alle gegevens bevatten. (Figuur 9)
2.3.3.Berekening
Figuur 13 – code die berekening start
Nu alle gegevens samengevat zijn in één object kan met de berekening van het warmteverlies gestart worden. Hier wordt de theorie uit 2.Theorie warmteverlies toegepast. De macro berekent het warmteverlies voor elk type apart zoals in Figuur 13 te zien is. Onderstaande tabel geeft meer uitleg over de benamingen van de procedures. Procedure Omschrijving warmteVerliesSpace
Berekening van het warmteverlies tussen twee kamers op hetzelfde verdiep
warmteVerliesExterior
Berekening van het warmteverlies naar buiten toe
warmteVerliesFloorslab
Berekening van het warmteverlies door de vloerplaat
warmteVerliesRoof
Berekening van het warmteverlies via het dak
warmteVerliesFloorCeiling Berekening van het warmteverlies tussen twee kamers op verschillende verdiepen warmteVerliesVentilatie
Berekening van het warmteverlies ten gevolge van ventilatie
Tabel 11 - Procedures die warmteverliezen berekenen
© artesis
p 35 / 83
Elke procedure slaat zijn resultaten op in een andere array. De laatste stap voegt van al deze arrays de resultaten samen in één array door de resultaten te bundelen. Hierdoor kan per ruimte het totale warmteverlies weergegeven worden. Hieronder wordt elke procedure overlopen en stap voor stap wordt er uitgelegd wat er gebeurt.
a.
Warmteverlies tussen 2 kamers (warmteVerliesSpace)
De namen van de 2 kamers worden vastgelegd en het verdiep van beide kamers wordt bepaald.
Er wordt gecontroleerd of we te maken hebben met een binnenmuur en of beide kamers zich op hetzelfde verdiep bevinden.
De temperatuur van beide kamers wordt bepaald, net zoals de U-waarde van de gemeenschappelijke muur. De U-waarde wordt aangepast door de oppervlakte weerstanden te verrekenen [5]. De oppervlakte van de muur wordt als laatste bepaald zodat uiteindelijk het warmteverlies van deze muur berekend kan worden.
Er wordt gecontroleerd of er eventuele openingen(deuren/ramen) zijn in de muur en deze worden dan één voor één overlopen.
© artesis
p 36 / 83
In het eerste geval hebben we te maken met een raam. De U-waarde wordt bepaald, net zoals de oppervlakte van het raam. Hierna wordt het warmteverlies van de muur aangepast door het warmteverlies van het raam erbij op te tellen. Het tweede geval behandelt de deuren op een identieke wijze. Het enige verschil is de locatie waar de U-waarde zich bevindt.
Om af te sluiten wordt het berekende warmteverlies verrekend met voorgaand berekende warmteverliezen van deze kamer. b.
Warmteverlies naar buiten (warmteVerliesExterior)
De naam van de kamer wordt vast gelegd en er wordt gecontroleerd of we te maken hebben met een buitenmuur.
De U-waarde van de muur wordt bepaald en aangepast met de waarden voor oppervlakte weerstanden. De oppervlakte van de muur wordt bepaald en de temperatuur van de kamer wordt opgezocht.
© artesis
p 37 / 83
Ook hier wordt nagegaan of er openingen zoals ramen of deuren in de buitenmuur zitten. Dit gebeurt op dezelfde manier als eerder gezien bij het warmteverlies tussen 2 kamers.
Als laatste voegen we het berekende warmteverlies terug samen bij de voorgaande resultaten.
Bij de aanwezigheid van een kelder zullen er ook ondergrondse muren in het model zitten. Deze worden hier verrekend.
Allereerst wordt de U-waarde van deze ondergrondse muren opgezocht en deze wordt erna opnieuw aangepast met zijn oppervlakte weerstanden. Daarna wordt het oppervlak van deze muur en de temperatuur in de kamer opgezocht. De laatste stap is het berekenen van het warmteverlies van de muur en het bekomen resultaat wordt dan bij de voorgaande opgeteld. c.
Warmteverlies van de vloer (warmteVerliesFloorslab)
Alvorens te beginnen aan de berekeningen dienen eerst enkele waarden bepaald te worden van de vloer zoals de totale oppervlakte en de perimeter.
© artesis
p 38 / 83
De eerste mogelijkheid is “SlabOnGrade”. Dit wil zeggen dat de vloerplaat op volle grond ligt en er dus geen kelder aanwezig is. De temperatuur van de kamer wordt bepaald, de U-waarde wordt opgezocht en opnieuw aangepast met de overeenkomstige oppervlakte weerstanden en de oppervlakte van de vloer wordt bepaald. De constante “grondwater” en de buitentemperatuur “tempE”
werden op voorhand vastgelegd in het model. Alle gegevens zijn bekend zodat het
warmteverlies via de vloer berekend kan worden. Als laatste wordt het resultaat samengevoegd bij de voorgaande resultaten.
Een andere mogelijk is “UndergroundSlab”. Hier zit de vloerplaat volledig onder de grond. Het enige verschil met de “SlabOnGrade” is de bepaling van de U-waarde. Deze is afhankelijk van de oppervlakte, de perimeter en de U-waarde van de vloer op zich. Via deze 3 waarden wordt de algemene U-waarde uit een tabel gehaald. Deze tabel is verschillend bij beide mogelijkheden. d.
Warmteverlies via het dak (warmteVerliesRoof)
De naam van de kamer wordt als eerste vastgelegd. Hierna wordt gekeken of we te maken hebben met een “roof”. Indien dit het geval is, wordt de temperatuur van de kamer vastgesteld, de Uwaarde van het dak wordt bepaald en aangepast en de oppervlakte van het dak zal ook nodig zijn om het warmteverlies te berekenen. Dit gebeurt in de stap erna en opnieuw worden de resultaten samengevoegd.
© artesis
p 39 / 83
e.
Warmteverlies tussen vloeren/plafonds (warmteVerliesFloorCeiling)
Bij de start worden de 2 ruimtes die beschouwd zullen worden vastgelegd.
Het verdiep van beide kamers wordt opgezocht.
De temperatuur van beide kamers wordt bepaald alsook de U-waarde van het gemeenschappelijk bouwdeel.
De aanpassing van de U-waarde met de oppervlakte weerstanden verloop hier complexer aangezien we 2 mogelijkheden hebben: opwaartse en neerwaartse warmtestroom.
Als laatste wordt de oppervlakte van het element berekend zodat we het warmteverlies via dit deel kunnen bepalen. De resultaten worden opnieuw samengevoegd. f.
© artesis
Warmteverlies door ventilatie (warmteVerliesVentilatie)
p 40 / 83
Bij de start wordt de naam van de ruimte en de temperatuur ervan opgehaald. Ook wordt het verdiep van deze kamer bepaald.
Om de formule te kunnen toepassen zullen eerst de nodige parameters opgezocht worden. Deze komen niet voor in het gbXML-bestand en zullen dus rechtstreeks uit Autodesk Revit gehaald worden. De parameters worden eerst uit Revit gehaald door ze op te slaan onder he type parameter. Hierna worden deze omgezet tot bruikbare variabelen.
Hier wordt gecontroleerd of de kamer een buitenmuur heeft of niet. Indien niet, zal de “schild”coëfficiënt gelijk zijn aan 0. Anders is de waarde van e afhankelijk van het aantal openingen in deze buitenmuren.
Het bepalen van de hoogtefactor zal geburen door de verdiepingshoogte van de ruimte te zoeken. Deze is hier gekoppeld aan de corresponderende factor.
© artesis
p 41 / 83
Hier wordt het onderscheid gemaakt tussen de berekening met ventilatiesysteem of zonder ventilatiesysteem.
Uiteindelijk zijn alle parameters gekend en kan het warmteverlies ten gevolge van ventilatie berekend worden. De laatste stap is het samenvoegen van de resultaten.
2.3.4.Uitvoer
Figuur 14 – code die uitvoer van resultaten bevat
Het schrijven van de gegevens zal gebeuren door deze in de vooraf aangemaakte parameter “Warmteverlies”
te
plaatsen.
De
kleine
procedure
“schrijfWarmteverlies”
werd
hiervoor
aangeroepen zoals in Figuur 14 te zien is. Deze overloopt in Autodesk Revit alle ruimtes en zoekt naar het corresponderend warmteverlies in het object “warmteVerlies”. De waarde wordt dan overgenomen zodat deze voor de gebruiker altijd terug te vinden is in Autodesk Revit bij de eigenschappen van de ruimte. Om een meer gedetailleerd overzicht te geven werd een tekstbestand aangemaakt met al de resultaten in. Hierin wordt elk type van warmteverlies weergegeven zodat duidelijk te zien is waar het meeste verlies plaatsvindt. Zie Figuur 15.
© artesis
p 42 / 83
Figuur 15 – Voorbeeld van tekstbestand met resultaten
Om de gebruiker na het uitvoeren van de macro toch een bevestiging te geven wanneer deze klaar is met berekenen, zal een messagebox op het scherm verschijnen. Deze zal de resultaten gebundeld weergeven, zodat deze snel en gemakkelijk te vergelijken zijn met elkaar. (Figuur 16)
© artesis
p 43 / 83
Figuur 16 – messagebox met resultaten
© artesis
p 44 / 83
3. Handleiding om het warmteverlies te berekenen gebruik makend van het programma. Om het programma voor iedereen toegankelijk te maken is het geïntegreerd in een template. Hieronder vindt u een handleiding die u stap voor stap zal begeleiden om het warmteverlies te berekenen van uw model.
3.1. Stap 1: Nieuw project opstarten Open Autodesk Revit MEP en klik in de linker bovenhoek op
. Hierna kiest u voor New >
Project. Een scherm komt tevoorschijn. Onder template file klikt u op Browse en selecteert u de template. Er onder kiest u voor Create new > Project. Hierna klikt u op OK. Een leeg project met de macro reeds in geïnstalleerd wordt nu geopend. Zie Figuur 17.
Figuur 17 - Nieuw project aan de hand van een template
3.2. Stap 2: Model invoegen Teken of kopieer uw model in dit project. Dit doet u door in de menubalk op Architecture te klikken en vervolgens muren, vloeren, daken, ramen, deuren… te tekenen. Wanneer de geometrie van uw gebouw klaar is, kan u verder naar stap 3.
3.3. Stap 3: Ruimtes definiëren Om de verschillende ruimtes duidelijk aan te geven in het gbXML-bestand zullen we deze nu definiëren. Klik in de menubalk op Analyse > Space. Wanneer er een venster tevoorschijn komt, klikt u hier op Nee. Hierna kunt u elke ruimte van het gebouw aanduiden. Als u hiermee klaar bent, gaan we verder met stap 4.
© artesis
p 45 / 83
3.4. Stap 4: Ruimtes instellen
Figuur 18 - Space Schedule
Elke ruimte die u in stap 3 hebt aangeduid, gaan we nu apart instellen. In het venster Project Browser dubbelklikt u op Space Schedule. Indien u de Project Browser niet kunt zien, gaat u naar View > User interface > Project Browser. Hier vindt u een overzicht van de ruimtes die u in stap 3 geselecteerd hebt. Zie Figuur 18. Om een beter overzicht te krijgen, kunt u bij View > Tile klikken om zo beide schermen naast elkaar te krijgen. Als u in het scherm Space Schedule een ruimte selecteert, zal deze in het vloerplan aangegeven worden. Hieronder vindt u een tabel die uitleg geeft over de instellingen in de Space Schedule. Name
Hier kunt u elke kamer een willekeurige naam geven
Number
Hier nummert u de kamers beginnende bij 1
Level
Hier staat op welk verdiep de kamer zich bevindt
Temperatuur
Hier geeft u de temperatuur van elke kamer in
Specified Supply Airflow
Hier geeft u de grote van het ventilatiesysteem in
Supply Air Temperature
Hier geeft u de temperatuur van de ingeblazen lucht in
Construction Type
Opbouw van de binnenmuren (zie stap 6)
Warmteverlies
Hier komen de resultaten van de berekening
Tabel 12 - Instellingen van SpaceSchedule
© artesis
p 46 / 83
3.5. Stap 5: Algemene instellingen
Figuur 19 - "Building Construction" - venster
Ga naar Manage > Project Information. Hier stelt u de buitentemperatuur in, de aanwezigheid van het grondwater en de veiligheidsfactor. Wanneer het verschil tussen het grondwater en de vloerplaat groter is dan 1m, laat u deze waarde staan op 1. Wanneer het verschil echter kleiner is dan 1m, verandert u deze waarde in 1.15. Bij Energy Settings klikt u op Edit. Hierna klikt u bij Building Construction op Building. In het venster dat tevoorschijn komt, kunt u de materialen instellen waaruit de bouwdelen bestaan. Indien er verschillende soorten binnenmuren in het gebouw zitten, wordt in de volgende stap uitgelegd hoe dit opgelost wordt. Selecteer hier alvast de meest voorkomende materialen in het model. Klik OK wanneer alles klaar is.
3.6. Stap 6: Binnenmuren definiëren Om verschillende binnenmuren aan het model toe te voegen zal een extra stap nodig zijn. Wanneer de binnenmuren allemaal hetzelfde opgebouwd zijn, kan u deze stap overslaan en meteen doorgaan naar stap 7. Selecteer in het vloerplan een ruimte die een binnenmuur bevat met een andere opbouw. Bij de Properties van deze ruimte klikt u bij Construction Type. Een venster komt tevoorschijn waarbij u links op Construction 1 klikt. Indien dit hier niet staat, klik u bovenaan op New en typt u “Construction 1” in gevolgd door OK. Aan de rechterkant kunt u nu bij Interior Walls het ander type binnenmuur aanduiden. Wanneer dit gebeurd is, klikt u op OK. Het verder aanpassen van deze gegevens gebeurt terug in het venster Space Schedule. In de voorlaatste kolom zult u bijna overal
zien staan. Bij de ruimtes die een gemeenschappelijke
© artesis
p 47 / 83
binnenmuur hebben die uit een ander materiaal bestaat dan eerder vastgelegd in stap 5, kiest u voor Construction 1. Hier moet u wel goed opletten. Een voorbeeld: Stel dat muurtype B als standaard is ingesteld. In dit geval moet u 2 nieuwe Construction types aanmaken. Construction 1 voor Space1 en Space2 en Construction 2 voor Space3 en Space4. Indien u enkel één Construction Type zou gebruiken voor alle kamers, zouden alle muren als type A worden aangenomen.
3.7. Stap 7: gbXML Nu alles is ingesteld kunnen we het model gaan exporteren. Dit doen we door links bovenaan te klikken op
> export > gbXML. In het volgende scherm klikt u op Next… Dan wordt er
gevraagd waar u het gbXML-document wil opslaan. Dit bestand moet in dezelfde map komen als het Revit-document! Het bestand slaat u op onder de naam Warmteverlies.xml. Dit is belangrijk omdat het programma dit bestand zal moeten terugvinden! Indien u toch een andere naam of locatie wilt gebruiken, vindt u de werkwijze terug in 5.3 Aanpassingen aan de macro.
3.8. Stap 8: Macro starten Dit is de laatste stap in het proces. Klik in de menubalk op Manage > Macro Manager. Dubbelklik op Test en selecteer Main. Als u nu op Run kunt klikken, doet u dit en zullen de resultaten tevoorschijn komen. Als u niet op Run kunt klikken, klikt u op Edit. In het scherm dat tevoorschijn komt, gaat u naar Build > Build Test. Hierna mag u dit venster sluiten en zult u zien dat u op Run kunt klikken. De resultaten vindt u nu terug in het venster Space Schedule.
© artesis
p 48 / 83
Hoofdstuk 3: Nabeschouwing 1. Inleiding In dit hoofdstuk zal van een relatief eenvoudig model de warmteverliezen bepaald worden aan de hand van de macro. Dit model zal ook in DesignBuilder nagerekend worden. De resultaten zullen vergeleken worden om de juistheid van de macro na te gaan. DesignBuilder is een software programma dat onder andere het energieverbruik van een gebouw kan nagaan. Via de officiële site van DesignBuilder kon een proefversie van het programma gedownload worden. Het programma heeft uiteraard veel meer opties dan de macro waardoor de resultaten nooit volledig overeen zullen komen. Zo kan het programma rekening houden met de locatie van het gebouw en daarbij horende klimaatgegevens maar ook met kantoorapparatuur, verlichting… Zie Figuur 21
Figuur 20 - Instellingen van DesignBuilder
De uitvoer van de resultaten kan weergegeven worden in grafiekvorm of in tabelvorm. Bij de grafiek krijgt de gebruiker meteen een goed overzicht van de resultaten. In de tabel zijn de resultaten meer gedetailleerd af te lezen. Zie Figuur 21 en Figuur 22
© artesis
p 49 / 83
Figuur 21 – Grafiek met resultaten van DesignBuilder
Figuur 22 - Tabel met resultaten van DesignBuilder
Bij de resultaten maakt DesignBuilder onderscheid tussen beglazing, muren en deuren. In de macro zijn deze drie waarden samengevoegd. Verder geeft het programma waarden voor het plafond, de vloer, het dak, binnenmuren en ventilatie. De berekeningen in DesignBuilder volgen weliswaar niet de norm die gebruikt werd om de macro op te stellen. De resultaten zullen vervolgens nooit volledig overeen kunnen komen.
© artesis
p 50 / 83
2. Testcase
Figuur 23 - Model voor testcase
2.1. Gegevens Het proefmodel dat aangemaakt werd in Autodesk Revit bestaat uit drie verdiepingen. Er is een kelderverdiep met twee ruimtes, een gelijkvloers met vier ruimtes en een eerste verdiep met ook vier ruimtes. Zie Figuur 24
Figuur 24 - Kelder, gelijkvloers en 1e verdiep
De buitentemperatuur wordt ingesteld op -8°C en met het grondwater wordt geen rekening gehouden. De veiligheidsfactor wordt ingesteld op 20%, dezelfde als in DesignBuilder. De temperatuur in de kelder wordt ingesteld op 15°C, de kamers op het gelijkvloers krijgen een temperatuur van 22°C en op het eerste verdiep wordt deze 20°C.
2.2. Resultaten De resultaten van zowel DesignBuilder en de macro zijn terug te vinden in de bijlagen. Hieronder worden ze verdieping per verdieping overlopen en de belangrijkste verschillen worden aangegeven.
© artesis
p 51 / 83
2.2.1.Kelder Een groot verschil tussen de twee berekeningen zit in het warmteverlies van de muren en vloeren. Hier berekent de macro een veel groter warmteverlies dan DesignBuilder aangeeft. Het verschil is zelfs 12 keer groter. Ook bij de vloer is het verschil van dezelfde grote. Het warmteverlies bij oppervlakken in contact met de grond is dus veel kleiner dan de macro zal berekenen. De kleine warmtewinst door het plafond van de kelder komt wel terug in beide resultaten. Het warmteverlies door ventilatie vertoont een kleinere afwijking (16% verschil).
2.2.2.Gelijkvloers Het warmteverlies doorheen de muren vertoont nog steeds een verschil al is het hier kleiner dan bij de kelder. Het verschil bedraagt hier nog 60%. Het warmteverlies door ventilatie is ook hier vrij gelijkend (1% verschil).
2.2.3.Eerste verdiep Op het eerste verdiep blijft het verschil even groot als op het gelijkvloers. Hier wordt een verschil van 62% opgemeten. De ventilatie vertoont hier wel een grotere afwijking dan bij de voorgaande verdiepingen. Het verschil loopt hier op tot 32%.
2.3. Besluit De
resultaten
van
de
berekeningen
vertonen
weinig
overeenkomst.
De
verschillende
warmteverliezen komen wel in beide berekeningen terug maar er is steeds een verschil tussen de waarden.
© artesis
p 52 / 83
Hoofdstuk 4: Conclusie De macro geeft een goede eerste indruk van de warmteverliezen. Het berekenen van de verliezen verloopt snel waardoor grote afwijkingen gemakkelijk opgespoord kunnen worden. Wanneer echter meer gedetailleerde waarden nodig zijn, zal er toch gebruik gemaakt moeten worden van speciale analyse software. Het aantal instellingen en de opbouw van het model zorgen voor meerdere mogelijkheden. Door gebruik te maken van het programmeren in BIM-systemen en in het bijzonder Autodesk Revit ontstaan er wel ontelbaar veel mogelijkheden. De mogelijkheid om macro’s te creëren geeft een enorme meerwaarde aan deze programma’s. In de toekomst zouden deze software programma’s één geheel kunnen vormen waardoor berekeningen sneller uitgevoerd worden en exporteren naar gbXML overbodig wordt.
© artesis
p 53 / 83
Hoofdstuk 5: Bibliografie 1. Boeken [1] GERZ, S., Visual C# 2010: de basis, Amsterdam: Pearson Education Benelux, 2010, 272p [2] WILLMS, R., C# zonder stress, Brussel: Easy Computing, 2003, 268p [3] BIN, NBN EN 12831, Brussel, 2003, 79p [4] BIN, NBN EN ISO 13370, Brussel, 2008, 48p [5] BIN, NBN EN ISO 6946, Brussel; 2008, 28p
2. Internet [6]
Leefmilieu
Brussel,
Beperking
van
koudebruggen,
internet,
04/04/2012,
11p,
http://app.leefmilieubrussel.be/handleiding_duurzaam_gebouw/(S(lfknwla5raq0y44550wpf2zg))/doc s_NL/ENE09_NL.pdf [7] gbXML, Open Green Building XMl Schema, internet, 04/04/2012, (http://www.gbxml.org/) [8] MSDN, MSDN Library, internet, 24/02/2011, (http://msdn.microsoft.com/en-us/library) [9]
Autodesk,
Developer
Center,
internet,
02/03/2011,
(http://usa.autodesk.com/adsk/servlet/index?siteID=123112&id=2484975)
© artesis
p 54 / 83
Bijlagen 1. Volledige code van de macro using using using using using using using using
System; System.IO; System.Xml; System.Windows.Forms; Autodesk.Revit; Autodesk.Revit.UI; System.Collections; Autodesk.Revit.DB;
namespace Test { [Autodesk.Revit.Attributes.Transaction(Autodesk.Revit.Attributes.T ransactionMode.Manual)] [Autodesk.Revit.Attributes.Regeneration(Autodesk.Revit.Attributes. RegenerationOption.Manual)] [Autodesk.Revit.VSTA.AddInId("97ea714a-dedb-4528-a8ec777bdfe7cfc2")] public partial class ThisDocument { private void Module_Startup(object sender, EventArgs e) { } private void Module_Shutdown(object sender, EventArgs e) { } #region VSTA generated code private void InternalStartup() { this.Startup += new System.EventHandler(Module_Startup); this.Shutdown += new System.EventHandler(Module_Shutdown); } #endregion public void main() { XmlTextReader leesXml = new XmlTextReader("Warmteverlies.xml"); leesXml.WhitespaceHandling = WhitespaceHandling.None; ArrayList building = new ArrayList(); ArrayList surface = new ArrayList(); ArrayList storey = new ArrayList(); UIApplication app = this.Application; Document doc = app.ActiveUIDocument.Document; //Buitentemperatuur bepalen:
© artesis
p 55 / 83
Parameter para1 = doc.ProjectInformation.get_Parameter("Buitentemperatuur"); double buitenTemp = para1.AsDouble(); //Grondwater bepalen Parameter para2 = doc.ProjectInformation.get_Parameter("Grondwater"); double grondwater = para2.AsDouble(); //Veiligheidsfactor bepalen Parameter para3 = doc.ProjectInformation.get_Parameter("Veiligheidsfactor"); double veiligheid = para3.AsDouble(); //INVOER leesXml.Read(); building = buildingLezen(ref leesXml, building, storey); surface = surfaceLezen(ref leesXml, surface); surface = uwaardeInvullen(ref leesXml, surface); building = buildingVervolledigen(ref leesXml, building, surface); leesXml.Close(); //VERWERKING double[] h = new double[building.Count]; double[] hSpace, hExterior, hRoof, hFloorSlab, hFloorCeiling, hVentilatie = new double[building.Count]; hSpace = warmteVerliesSpace(building, storey); hExterior = warmteVerliesExterior(building, buitenTemp); hFloorSlab = warmteVerliesFloorSlab(building, storey, buitenTemp, grondwater); hRoof = warmteVerliesRoof(building, storey, buitenTemp); hFloorCeiling = warmteVerliesFloorCeiling(building, storey); hVentilatie = warmteVerliesVentilatie(building, storey, buitenTemp); veiligheidsFactor(hSpace, veiligheid); veiligheidsFactor(hExterior, veiligheid); veiligheidsFactor(hFloorSlab, veiligheid); veiligheidsFactor(hRoof, veiligheid); veiligheidsFactor(hFloorCeiling, veiligheid); veiligheidsFactor(hVentilatie, veiligheid); h = hTotaal(hSpace, hExterior, hRoof, hFloorSlab, hFloorCeiling, hVentilatie); //UITVOER schrijfWarmteverlies(building, h); maakTxt(h, hSpace, hExterior, hRoof, hFloorSlab, hFloorCeiling, hVentilatie); toonMsgBox(building, h); }
© artesis
p 56 / 83
#region lezenXML ArrayList buildingLezen(ref XmlTextReader leesXml, ArrayList building, ArrayList storey) { // SPACES EN BOUNDARIES INLEZEN IN BUILDING bool testOpSpace = true; int cadObjectId = 0; ArrayList storeySpace = new ArrayList(); UIApplication app = this.Application; Document doc = app.ActiveUIDocument.Document; leesXml.ReadToFollowing("Space"); while (testOpSpace) { ArrayList space = new ArrayList(); building.Add(space); string id = leesXml.GetAttribute("id"); space.Add(id); storey = buildingStoreyIdRef(leesXml, storey, id); leesXml.ReadToFollowing("Area"); space.Add(Convert.ToDouble(leesXml.ReadString()) / 1000000); leesXml.ReadToFollowing("Volume"); space.Add(Convert.ToDouble(leesXml.ReadString()) / 1000000); //Temperatuur toevoegen leesXml.ReadToFollowing("CADObjectId"); cadObjectId = Convert.ToInt32(leesXml.ReadString()); space.Add(cadObjectId); ElementId elemid1 = new ElementId(cadObjectId); Element elem1 = doc.get_Element(elemid1); Parameter para = elem1.get_Parameter("Temperatuur"); space.Add((para.AsDouble())); bool testOpBoundary = true; bool eersteBoundary = true; while (testOpBoundary) { if (eersteBoundary) { leesXml.ReadToFollowing("SpaceBoundary"); eersteBoundary = false; } ArrayList boundary = new ArrayList(); boundary.Add(leesXml.GetAttribute("surfaceIdRef")); space.Add(boundary); do { leesXml.Read(); } while (leesXml.Name != "SpaceBoundary"); leesXml.Read(); if (leesXml.Name == "Space") { testOpBoundary = false; © artesis
p 57 / 83
} } leesXml.Read(); if (leesXml.Name == "Building") { testOpSpace = false; } } return building; } ArrayList surfaceLezen(ref XmlTextReader leesXml, ArrayList surface) { //SURFACES INLEZEN IN SURFACE bool testOpSurface = true; bool eersteSurface = true; string surfaceType; while (testOpSurface) { if (eersteSurface) { leesXml.ReadToFollowing("Surface"); eersteSurface = false; } surfaceType = leesXml.GetAttribute("surfaceType"); if (surfaceType == "Shade") { leesXml.ReadToFollowing("Construction"); goto shadeEinde; } if (surfaceType == "Air") { leesXml.ReadToFollowing("Surface"); goto airEinde; } ArrayList space = new ArrayList(); surface.Add(space); space.Add(leesXml.GetAttribute("id")); space.Add(leesXml.GetAttribute("surfaceType")); space.Add(leesXml.GetAttribute("constructionIdRef")); leesXml.ReadToFollowing("AdjacentSpaceId"); space.Add(leesXml.GetAttribute("spaceIdRef")); leesXml.Read(); if (leesXml.Name == "AdjacentSpaceId") { space.Add(leesXml.GetAttribute("spaceIdRef")); } else { space.Add(null); } leesXml.ReadToFollowing("Height"); double hoogte = Convert.ToDouble(leesXml.ReadString()) / 1000000; leesXml.ReadToFollowing("Width"); double breedte = Convert.ToDouble(leesXml.ReadString()) / 1000000; double area = hoogte * breedte;
© artesis
p 58 / 83
openingen(space, leesXml, area, breedte); //CADObjectId inlezen string cadObjectId = leesXml.ReadString(); cadObjectId = cadObjectId.Substring(cadObjectId.Length - 7, 6); space.Add(cadObjectId); leesXml.Read(); leesXml.Read(); airEinde: if (leesXml.Name == "Campus") { testOpSurface = false; } } shadeEinde: return surface; } ArrayList uwaardeInvullen(ref XmlTextReader leesXml, ArrayList surface) { //constructionIdRef vervangen door U-waarde ArrayList construction = new ArrayList(); bool testOpConstruction = true; bool testOpWindow = true; while (testOpConstruction) { ArrayList u = new ArrayList(); u.Add(leesXml.GetAttribute("id")); leesXml.ReadToFollowing("U-value"); u.Add(Convert.ToDouble(leesXml.ReadString()) / 10000); construction.Add(u); do { leesXml.Read(); } while (leesXml.Name != "Construction"); leesXml.Read(); if (leesXml.Name != "Construction") { testOpConstruction = false; } } leesXml.ReadToFollowing("WindowType"); while (testOpWindow) { ArrayList u = new ArrayList(); u.Add(leesXml.GetAttribute("id")); leesXml.ReadToFollowing("U-value");
© artesis
p 59 / 83
try { u.Add(Convert.ToDouble(leesXml.ReadString()) / 10000); } catch { MessageBox.Show("Geen raam aanwezig!"); throw; } construction.Add(u); do { leesXml.Read(); } while (leesXml.Name != "WindowType"); leesXml.Read(); if (leesXml.Name != "WindowType") { testOpWindow = false; } } for (int tellerSurface = 0; tellerSurface < surface.Count; tellerSurface++) { ArrayList space = (ArrayList)Convert.ChangeType(surface[tellerSurface], typeof(ArrayList)); for (int tellerConstruction = 0; tellerConstruction < construction.Count; tellerConstruction++) { ArrayList temp = (ArrayList)Convert.ChangeType(construction[tellerConstruction], typeof(ArrayList)); if (Convert.ToString(space[2]) == Convert.ToString(temp[0])) { space[2] = temp[1]; } if (space.Count > 8) { for (int tellerOpening = 5; tellerOpening < space.Count - 3; tellerOpening++) { ArrayList opening = (ArrayList)Convert.ChangeType(space[tellerOpening], typeof(ArrayList)); if (Convert.ToString(opening[0]) == Convert.ToString(temp[0])) { opening[0] = temp[1]; } else if (Convert.ToString(opening[1]) == Convert.ToString(temp[0])) { opening[1] = temp[1]; } } } © artesis
p 60 / 83
} } return surface; } ArrayList buildingVervolledigen(ref XmlTextReader leesXml, ArrayList building, ArrayList surface) { //INFORMATIE UIT SURFACE HALEN EN OP JUISTE PLAATS IN BUILDING STEKEN bool tester = true; for (int tellerSpace = 0; tellerSpace < building.Count; tellerSpace++) { ArrayList tempSpace = (ArrayList)Convert.ChangeType(building[tellerSpace], typeof(ArrayList)); for (int tellerBoundary = 5; tellerBoundary < tempSpace.Count; tellerBoundary++) { ArrayList tempBoundary = (ArrayList)Convert.ChangeType(tempSpace[tellerBoundary], typeof(ArrayList)); for (int tellerSurface = 0; tellerSurface < surface.Count; tellerSurface++) { ArrayList tempSurface = (ArrayList)Convert.ChangeType(surface[tellerSurface], typeof(ArrayList)); if (Convert.ToString(tempBoundary[0]) == Convert.ToString(tempSurface[0])) { tempBoundary = tempSurface; tester = false; goto einde; } } einde: if (tester) { tempSpace.RemoveAt(tellerBoundary); tellerBoundary -= 1; } else { tempSpace[tellerBoundary] = tempBoundary; tester = true; } } } return building; } #endregion
© artesis
p 61 / 83
#region hulpModules ArrayList openingen(ArrayList space, XmlTextReader leesXml, double area, double b) { do { leesXml.Read(); if (leesXml.Name == "Opening") { ArrayList opening = new ArrayList(); space.Add(opening); opening.Add(leesXml.GetAttribute("constructionIdRef")); opening.Add(leesXml.GetAttribute("windowTypeIdRef")); leesXml.ReadToFollowing("Height"); double hoogteOpening = Convert.ToDouble(leesXml.ReadString()) / 1000000; leesXml.ReadToFollowing("Width"); double breedteOpening = Convert.ToDouble(leesXml.ReadString()) / 1000000; opening.Add(hoogteOpening * breedteOpening); area = area - (hoogteOpening * breedteOpening); while (leesXml.Name != "Opening" || leesXml.Name == "CADObjectId") { leesXml.Read(); } } } while (leesXml.Name != "CADObjectId"); space.Add(b); space.Add(area); return space; } double zoekTemp(string spaceString, ArrayList building) { double temp = 0; for (int tellerSpace = 0; tellerSpace < building.Count; tellerSpace++) { ArrayList space = (ArrayList)Convert.ChangeType(building[tellerSpace], typeof(ArrayList)); string spaceId = Convert.ToString(space[0]); if (spaceId == spaceString) { temp = Convert.ToDouble(space[4]); } } return temp; } void schrijfWarmteverlies(ArrayList building, double[] warmteVerlies) { UIApplication app = this.Application; © artesis
p 62 / 83
Document doc = app.ActiveUIDocument.Document; for (int tellerSpace = 0; tellerSpace < building.Count; tellerSpace++) { ArrayList space = (ArrayList)Convert.ChangeType(building[tellerSpace], typeof(ArrayList)); int cadObjectId = Convert.ToInt32(space[3]); ElementId elemid = new ElementId(cadObjectId); Element elem = doc.get_Element(elemid); Parameter param = elem.get_Parameter("Warmteverlies"); if (!param.IsReadOnly) { Transaction transaction = new Transaction(doc); transaction.Start("Warmteverlies"); param.Set(warmteVerlies[tellerSpace]); transaction.Commit(); } } } void toonMsgBox(ArrayList building, double[] warmteVerlies) { int aantalSpaces = building.Count; string result = ""; for (int tel = 0; tel < aantalSpaces; tel++) { int room = tel + 1; if (warmteVerlies[tel] < 0) { result += "Warmteverlies space " + room + " = " + Math.Abs(Math.Round(warmteVerlies[tel])) + " watt" + Environment.NewLine + Environment.NewLine; } else { result += "Warmtewinst space " + room + " = " + Math.Abs(Math.Round(warmteVerlies[tel])) + " watt" + Environment.NewLine + Environment.NewLine; } } MessageBox.Show(result); } int storeyTester(string str, ArrayList storey) { int level = 0; for (int teller1 = 0; teller1 < storey.Count; teller1++) { ArrayList smallStorey = (ArrayList)Convert.ChangeType(storey[teller1], typeof(ArrayList)); for (int teller2 = 0; teller2 < smallStorey.Count; teller2++) { if (str == Convert.ToString(smallStorey[0])) { level = Convert.ToInt32(smallStorey[1]); © artesis
p 63 / 83
break; } } } return level; } double[] hTotaal(double[] h1, double[] h2, double[] h3, double[] h4, double[] h5, double[] h6) { double[] h = new double[h1.Length]; for (int i = 0; i < h1.Length; i++) { h[i] += h1[i] + h2[i] + h3[i] + h4[i] + h5[i] + h6[i]; } return h; } void maakTxt(double[] h, double[] hSpace, double[] hExterior, double[] hRoof, double[] hFloorSlab, double[] hFloorCeiling, double[] hVentilatie) { int aantalSpaces = h.Length; string line = "SAMENVATTING WARMTEVERLIES"; System.IO.File.WriteAllText("WriteLines.txt", line); for (int teller = 0; teller < aantalSpaces; teller++) { using (System.IO.StreamWriter file = new System.IO.StreamWriter("WriteLines.txt", true)) { file.WriteLine(" "); file.WriteLine("- SPACE " + (teller + 1)); file.WriteLine(" Totaal warmteverlies =\t\t" + Math.Round(-h[teller]) + "\tWatt"); file.WriteLine(" *Intern warmteverlies =\t" + Math.Round(-hSpace[teller] - hFloorCeiling[teller]) + "\tWatt"); file.WriteLine(" + Muren =\t\t" + Math.Round(-hSpace[teller]) + "\tWatt"); file.WriteLine(" + Vloer en plafond =\t" + Math.Round(-hFloorCeiling[teller]) + "\tWatt"); file.WriteLine(" *Extern warmteverlies =\t" + Math.Round(-hRoof[teller] - hFloorSlab[teller] hExterior[teller]) + "\tWatt"); file.WriteLine(" + Dak =\t\t\t" + Math.Round(-hRoof[teller]) + "\tWatt"); file.WriteLine(" + Vloer =\t\t" + Math.Round(-hFloorSlab[teller]) + "\tWatt"); file.WriteLine(" + Muren =\t\t" + Math.Round(-hExterior[teller]) + "\tWatt"); file.WriteLine(" *Ventilatieverlies =\t\t" + Math.Round(-hVentilatie[teller]) + "\tWatt"); file.WriteLine(" "); } } } void areaEnPerimeter(ArrayList building, ref double a, ref double p, double floors) { for (int tellerSpace = 0; tellerSpace < building.Count; tellerSpace++) © artesis
p 64 / 83
{ ArrayList space = (ArrayList)Convert.ChangeType(building[tellerSpace], typeof(ArrayList)); a += Convert.ToDouble(space[1]); for (int tellerBoundary = 5; tellerBoundary < space.Count; tellerBoundary++) { ArrayList boundary = (ArrayList)Convert.ChangeType(space[tellerBoundary], typeof(ArrayList)); if (Convert.ToString(boundary[1]) == "ExteriorWall" || Convert.ToString(boundary[1]) == "UndergroundWall") { p += Convert.ToDouble(boundary[boundary.Count - 3]); } } } p = p / floors; a = a / floors; } double zoekUVloer1(double u, string room, ArrayList building, double areaTotaal, double perim) { double[,] tabel = new double[,] { { 0.77, 0.55, 0.33, 0.17 }, { 0.59, 0.45, 0.30, 0.17 }, { 0.48, 0.38, 0.27, 0.17 }, { 0.41, 0.33, 0.25, 0.16 }, { 0.36, 0.30, 0.23, 0.15 }, { 0.32, 0.27, 0.21, 0.14 }, { 0.29, 0.24, 0.19, 0.14 }, { 0.26, 0.22, 0.18, 0.13 }, { 0.24, 0.21, 0.17, 0.12 }, { 0.22, 0.19, 0.16, 0.12 } }; //B' = 2a/p double b = 2 * areaTotaal / perim; int plaats = 0; //test //b = 3.666; if (b > 20) { b = 20; } b = Math.Truncate(b); if (b % 2 != 0) { b++; } b = b / 2 - 1; if (u > 1.5) { plaats = 0; } else if (u <= 1.5 && u > 0.75) { plaats = 1; } else if (u <= 0.75 && u > 0.425) © artesis
p 65 / 83
{ plaats = 2; } else { plaats = 3; } int b2 = Convert.ToInt32(b); u = tabel[b2, plaats]; return u; } double zoekUVloer2(double u, string room, ArrayList building, double areaTotaal, double perim) { double[,] tabel = new double[,] { { 0.46, 0.35, 0.24, 0.14 }, { 0.40, 0.33, 0.24, 0.14 }, { 0.35, 0.29, 0.22, 0.14 }, { 0.31, 0.26, 0.21, 0.14 }, { 0.27, 0.24, 0.19, 0.13 }, { 0.25, 0.22, 0.18, 0.13 }, { 0.23, 0.20, 0.17, 0.12 }, { 0.21, 0.19, 0.16, 0.12 }, { 0.20, 0.18, 0.15, 0.11 }, { 0.18, 0.16, 0.14, 0.11 } }; //B' = 2a/p double b = 2 * areaTotaal / perim; int plaats = 0; //test //b = 3.666; if (b > 20) { b = 20; } b = Math.Truncate(b); if (b % 2 != 0) { b++; } b = b / 2 - 1; if (u > 1.5) { plaats = 0; } else if (u <= 1.5 && u > 0.75) { plaats = 1; } else if (u <= 0.75 && u > 0.425) { plaats = 2; } else { plaats = 3; } int b2 = Convert.ToInt32(b); u = tabel[b2, plaats]; © artesis
p 66 / 83
return u; } double zoekUMuurOnderGrond(double u) { if (u < 0.50) { u = 0.50; } while (u % 0.25 != 0 || u == 3.00) { u = u + 0.01; u = Math.Round(u, 2); } double[] tabel = new double[] { 0.32, 0.43, 0.53, 0.61, 0.68, 0.74, 0.79, 0.84, 0.88, 0.92, 0.96 }; int plaats = Convert.ToInt16(u / 0.25 - 2); u = tabel[plaats]; return u; } ArrayList buildingStoreyIdRef(XmlTextReader leesXml, ArrayList storey, string space) { string strStoreyIdRef1 = leesXml.GetAttribute("buildingStoreyIdRef"); string strStoreyIdRef2 = strStoreyIdRef1.Substring(10, strStoreyIdRef1.Length - 10); int intStoreyIdRef = Convert.ToInt32(strStoreyIdRef2); ArrayList smallStorey = new ArrayList(); smallStorey.Add(space); smallStorey.Add(intStoreyIdRef); storey.Add(smallStorey); return storey; } void veiligheidsFactor(double[] lijst, double veiligheid) { for (int teller = 0; teller < lijst.Length; teller++) { lijst[teller] = lijst[teller] * veiligheid; } } #endregion
© artesis
p 67 / 83
#region Warmteverlies double[] warmteVerliesSpace(ArrayList building, ArrayList storey) { //Warmteverlies bepalen naar naburige kamers double q, temp1, temp2; double[] warmteVerlies = new double[building.Count]; int areaLocation; int aantalSpaces = building.Count; for (int tellerSpace = 0; tellerSpace < building.Count; tellerSpace++) { ArrayList space = (ArrayList)Convert.ChangeType(building[tellerSpace], typeof(ArrayList)); for (int tellerBoundary = 5; tellerBoundary < space.Count; tellerBoundary++) { ArrayList boundary = (ArrayList)Convert.ChangeType(space[tellerBoundary], typeof(ArrayList)); string AdjacentSpace1 = Convert.ToString(space[0]); string AdjacentSpace2 = Convert.ToString(boundary[3]); if (AdjacentSpace2 == AdjacentSpace1) { AdjacentSpace2 = Convert.ToString(boundary[4]); } int level1 = storeyTester(AdjacentSpace1, storey); int level2 = storeyTester(AdjacentSpace2, storey); if (Convert.ToString(boundary[1]) == "InteriorWall" && level1 == level2) //controleer op interior wall { temp1 = zoekTemp(AdjacentSpace1, building); temp2 = zoekTemp(AdjacentSpace2, building); areaLocation = boundary.Count - 2; double u = Convert.ToDouble(boundary[2]); u = 1 / (1 / u + 0.13 + 0.13); double area = Convert.ToDouble(boundary[areaLocation]); q = (temp1 - temp2) * u * area; //Ramen en deuren int aantalOpeningen = boundary.Count; int openingTeller = 5; while (aantalOpeningen > 8) {
© artesis
p 68 / 83
ArrayList opening = (ArrayList)Convert.ChangeType(boundary[openingTeller], typeof(ArrayList)); if (opening[0] == null) //raam { double uwaardeRaam = Convert.ToDouble(opening[1]); double areaRaam = Convert.ToDouble(opening[2]); q = q + uwaardeRaam * areaRaam * (temp1 - temp2); } else if (opening[1] == null) //deur { double uwaardeDeur = Convert.ToDouble(opening[0]); double areaDeur = Convert.ToDouble(opening[2]); q = q + uwaardeDeur * areaDeur * (temp1 - temp2); } aantalOpeningen -= 1; openingTeller++; } warmteVerlies[tellerSpace] -= q * 1.2; } } } return warmteVerlies; } double[] warmteVerliesExterior(ArrayList building, double tempE) { double q; double[] warmteVerlies = new double[building.Count]; for (int tellerSpace = 0; tellerSpace < building.Count; tellerSpace++) { ArrayList space = (ArrayList)Convert.ChangeType(building[tellerSpace], typeof(ArrayList)); for (int tellerBoundary = 5; tellerBoundary < space.Count; tellerBoundary++) { ArrayList boundary = (ArrayList)Convert.ChangeType(space[tellerBoundary], typeof(ArrayList)); string AdjacentSpace1 = Convert.ToString(space[0]); if (Convert.ToString(boundary[1]) == "ExteriorWall") //controleer op exterior wall { double u = Convert.ToDouble(boundary[2]); u = 1 / (1 / u + 0.13 + 0.04); double area = Convert.ToDouble(boundary[boundary.Count - 2]); double temp1 = zoekTemp(AdjacentSpace1, building); q = u * (temp1 - tempE) * area;
© artesis
p 69 / 83
//Ramen en deuren int aantalOpeningen = boundary.Count; int openingTeller = 5; while (aantalOpeningen > 8) { ArrayList opening = (ArrayList)Convert.ChangeType(boundary[openingTeller], typeof(ArrayList)); if (opening[0] == null) { q = q + Convert.ToDouble(opening[1]) * Convert.ToDouble(opening[2]) (temp1 - tempE); } else if (opening[1] == null) { q = q + Convert.ToDouble(opening[0]) * Convert.ToDouble(opening[2]) (temp1 - tempE); } aantalOpeningen -= 1; openingTeller++; }
//raam * //deur *
warmteVerlies[tellerSpace] -= q * 1.2; } else if (Convert.ToString(boundary[1]) == "UndergroundWall") { double u = Convert.ToDouble(boundary[2]); u = 0.6;
//gbXML geeft geen id...?
u = zoekUMuurOnderGrond(u); u = 1 / (1 / u + 0.04); double area = Convert.ToDouble(boundary[boundary.Count - 2]); double temp1 = zoekTemp(AdjacentSpace1, building); q = u * (temp1 - tempE) * area; warmteVerlies[tellerSpace] -= q * 1.2; } } } return warmteVerlies; } double[] warmteVerliesFloorSlab(ArrayList building, ArrayList storey, double tempE, double grondwater) { double q, temp1; double areaTotaal = 0, perim = 0; //buitentemperatuur double[] warmteVerlies = new double[building.Count]; double aantalVerdiepingen = storey.Count; areaEnPerimeter(building, ref areaTotaal, ref perim, aantalVerdiepingen);
© artesis
p 70 / 83
for (int tellerSpace = 0; tellerSpace < building.Count; tellerSpace++) { ArrayList space = (ArrayList)Convert.ChangeType(building[tellerSpace], typeof(ArrayList)); for (int tellerBoundary = 5; tellerBoundary < space.Count; tellerBoundary++) { string room = Convert.ToString(space[0]); ArrayList boundary = (ArrayList)Convert.ChangeType(space[tellerBoundary], typeof(ArrayList)); if (Convert.ToString(boundary[1]) == "SlabOnGrade") //z=0 { temp1 = zoekTemp(room, building); double u = Convert.ToDouble(boundary[2]); u = zoekUVloer1(u, room, building, areaTotaal, perim); u = 1 / (1 / u + 0.17 + 0.04); double areaVloer = Convert.ToDouble(boundary[boundary.Count - 2]); q = 1.45 * grondwater * u * (temp1 tempE) * areaVloer; warmteVerlies[tellerSpace] -= q * 1.2; } else if (Convert.ToString(boundary[1]) == "UndergroundSlab") //z=3 { temp1 = zoekTemp(room, building); double u = Convert.ToDouble(boundary[2]); u = zoekUVloer2(u, room, building, areaTotaal, perim); u = 1 / (1 / u + 0.17 + 0.04); double areaVloer = Convert.ToDouble(boundary[boundary.Count - 2]); q = 1.45 * grondwater * u * (temp1 tempE) * areaVloer; warmteVerlies[tellerSpace] -= q * 1.2; } } } return warmteVerlies; } double[] warmteVerliesRoof(ArrayList building, ArrayList storey, double tempE) { double q, temp1; //buitentemperatuur double[] warmteVerlies = new double[building.Count]; for (int tellerSpace = 0; tellerSpace < building.Count; tellerSpace++) { ArrayList space = (ArrayList)Convert.ChangeType(building[tellerSpace], typeof(ArrayList)); for (int tellerBoundary = 5; tellerBoundary < space.Count; tellerBoundary++) { string room = Convert.ToString(space[0]); ArrayList boundary = © artesis
p 71 / 83
(ArrayList)Convert.ChangeType(space[tellerBoundary], typeof(ArrayList)); if (Convert.ToString(boundary[1]) == "Roof") { temp1 = zoekTemp(room, building); double u = Convert.ToDouble(boundary[2]); u = 1 / (1 / u + 0.10 + 0.04); double area = Convert.ToDouble(boundary[boundary.Count - 2]); q = u * (temp1 - tempE) * area; warmteVerlies[tellerSpace] -= q * 1.2; } } } return warmteVerlies; } double[] warmteVerliesFloorCeiling(ArrayList building, ArrayList storey) { //Warmteverlies via het plafond/vloer double q, temp1, temp2; int areaLocation; int aantalSpaces = building.Count; double[] warmteVerlies = new double[building.Count]; for (int tellerSpace = 0; tellerSpace < building.Count; tellerSpace++) { ArrayList space = (ArrayList)Convert.ChangeType(building[tellerSpace], typeof(ArrayList)); for (int tellerBoundary = 5; tellerBoundary < space.Count; tellerBoundary++) { ArrayList boundary = (ArrayList)Convert.ChangeType(space[tellerBoundary], typeof(ArrayList)); string AdjacentSpace1 = Convert.ToString(space[0]); string AdjacentSpace2 = Convert.ToString(boundary[3]); if (AdjacentSpace2 == AdjacentSpace1) { AdjacentSpace2 = Convert.ToString(boundary[4]); } int level1 = storeyTester(AdjacentSpace1, storey); int level2 = storeyTester(AdjacentSpace2, storey); if (Convert.ToString(boundary[1]) == "InteriorFloor" && level1 != level2) { temp1 = zoekTemp(AdjacentSpace1, building); temp2 = zoekTemp(AdjacentSpace2, building);
© artesis
p 72 / 83
double u = Convert.ToDouble(boundary[2]) * 100; areaLocation = boundary.Count - 2; if ((level1 < level2 && temp1 > temp2) || (level1 > level2 && temp1 < temp2)) { u = 1 / (1 / u + 0.10 + 0.10); //opwaartse warmtestroom } else { u = 1 / (1 / u + 0.17 + 0.17); //neerwaartse warmtestroom } double area = Convert.ToDouble(boundary[areaLocation]); q = (temp1 - temp2) * u * area; warmteVerlies[tellerSpace] -= q * 1.2; } } } return warmteVerlies; } double[] warmteVerliesVentilatie(ArrayList building, ArrayList storey, double tempE) { double[] warmteVerlies = new double[building.Count]; double q, vMin, vInf, e, v, f; bool interior = true; int openingen = 0; UIApplication app = this.Application; Document doc = app.ActiveUIDocument.Document; for (int tellerSpace = 0; tellerSpace < building.Count; tellerSpace++) { ArrayList space = (ArrayList)Convert.ChangeType(building[tellerSpace], typeof(ArrayList)); string AdjacentSpace1 = Convert.ToString(space[0]); double temp1 = zoekTemp(AdjacentSpace1, building); int level = storeyTester(AdjacentSpace1, storey); //Ventilatie bepalen int cadObjectId = Convert.ToInt32(space[3]); ElementId elemId = new ElementId(cadObjectId); Element elem1 = doc.get_Element(elemId); Parameter para1 = elem1.get_Parameter("Specified Supply Airflow"); Parameter para2 = elem1.get_Parameter("Supply Air Temperature"); Parameter para3 = elem1.get_Parameter("Specified Exhaust Airflow"); string SupAirflow = para1.AsValueString(); SupAirflow = SupAirflow.Substring(0, SupAirflow.Length - 10); © artesis
p 73 / 83
double SupAirflowDbl = Convert.ToDouble(SupAirflow); double airtemp = para2.AsDouble(); string ExAirflow = para3.AsValueString(); ExAirflow = ExAirflow.Substring(0, ExAirflow.Length - 10); double ExAirflowDbl = Convert.ToDouble(ExAirflow); for (int tellerBoundary = 5; tellerBoundary < space.Count; tellerBoundary++) { ArrayList boundary = (ArrayList)Convert.ChangeType(space[tellerBoundary], typeof(ArrayList)); if (Convert.ToString(boundary[1]) == "ExteriorWall") { interior = false; openingen += boundary.Count - 7; //aantal ramen en deuren tellen } } //e bepalen if (interior) { e = 0;
//geen buitenmuren in deze
space } else { if (openingen == 1) { e = 0.02; //buitenmuren met 1 opening } else if (openingen == 0) { e = 0; //buitenmuren zonder openingen } else { e = 0.03;
//buitenmuren met meerdere
openingen } } f = (temp1 - airtemp) / (temp1 - tempE); //hoogteFactor double hoogteFactor = 1; if (level > 2 && level < 6) { hoogteFactor = 1.2; } else if (level >= 6) { hoogteFactor = 1.5; } © artesis
p 74 / 83
//Berekening vMin = 1 * Convert.ToDouble(space[2]); //nMin = 1 (office room) vInf = 2 * Convert.ToDouble(space[2]) * 5 * e * hoogteFactor; if (SupAirflowDbl == 0) //GEEN ventilatiesysteem { v = Math.Max(vMin, vInf); } else {
//WEL ventilatiesysteem v = Math.Max(vInf + SupAirflowDbl * f +
ExAirflowDbl, vMin); } q = 0.34 * (temp1 - tempE) * v; warmteVerlies[tellerSpace] -= q; } return warmteVerlies; } #endregion } }
© artesis
p 75 / 83
2. Warmteverlies via de vloer volgens NBN EN 13370 Het berekenen van het warmteverlies via de vloer wordt in de gebruikte norm vereenvoudigd weergegeven. Bij deze wijze worden de thermische geleidingscoëfficiënten afgeleid uit tabellen. In de norm EN ISO 13370 wordt een andere manier van berekening gebruikt. Deze maakt geen gebruik van tabellen. Om het verschil tussen beide normen te bekijken werd een eenvoudig model op beide manieren berekend. Model:
Figuur 25 - Voorbeeld van het model
2.1. Vereenvoudigde wijze: SAMENVATTING WARMTEVERLIES - SPACE 1 Totaal warmteverlies =
4261
Watt
0
Watt
+ Muren =
0
Watt
+ Vloer en plafond =
0
Watt
*Intern warmteverlies =
*Extern warmteverlies =
3076
Watt
+ Dak =
304
Watt
+ Vloer =
564
Watt
+ Muren =
2209
Watt
1184
Watt
*Ventilatieverlies =
De vloer in het model heeft een warmteverlies van 564 Watt. Deze waarde bevat echter wel nog de correctiefactor van de koudebruggen en de veiligheidsfactor. Wanneer we het toevoegen van deze waarden ongedaan maken, komen we op een totaal warmteverlies van 313 Watt.
2.2. Volgens norm EN ISO 13370: 2.2.1.Stap 1 Variabelen: Dikte van de buitenmuren w =
500 mm
Geleiding van de grond λ=
2 W/(m*K)
RSi =
0.17 K*m²/W
Rf =
1 / 0.6008 W/(K*m²)
RSe =
0.04 K*m²/W
© artesis
(standaardwaarde)
p 76 / 83
(
)
De equivalente dikte van de muur bedraagt 4.25m.
2.2.2.Stap 2 Variabelen: Oppervlakte van de vloer A =
25 m²
Perimeter van de vloer P =
20m
De karakteristieke dimensie B’ van de vloer bedraagt 2.5m.
2.2.3.Stap 3 Na stap 1 en stap 2 zijn er nu 2 mogelijkheden: d t < B’ of dt ≥ B’. In ons geval hebben we te maken met het tweede geval. De thermische geleidingscoëfficiënt kan nu berekend worden. (
)
2.2.4.Stap 4 Nu we de thermische geleidingscoëfficiënt hebben berekend, kunnen we het warmteverlies bepalen. Variabelen: Binnentemperatuur θi =
20°C
Buitentemperatuur θe = ( )
-8°C
2.2.5.Conclusie Er is een duidelijk verschil tussen de resultaten. De vereenvoudigde berekening, dus ook de berekening gehanteerd in de macro, heeft een groter warmteverlies.
© artesis
p 77 / 83
3. Resultaten testcase Kelder:
Gelijkvloers:
© artesis
p 78 / 83
© artesis
p 79 / 83
Eerste verdieping:
© artesis
p 80 / 83
Resultaten Macro: SAMENVATTING WARMTEVERLIES - SPACE 1 Totaal warmteverlies = *Intern warmteverlies =
2289
Watt
-95
Watt
+ Muren =
0
Watt
+ Vloer en plafond =
-95
Watt
*Extern warmteverlies =
954
Watt
+ Dak =
0
Watt
+ Vloer =
327
Watt
+ Muren =
628
Watt
1430
Watt
2289
Watt
*Ventilatieverlies =
- SPACE 2 Totaal warmteverlies = *Intern warmteverlies =
-95
Watt
+ Muren =
0
Watt
+ Vloer en plafond =
-95
Watt
*Extern warmteverlies =
954
Watt
+ Dak =
0
Watt
+ Vloer =
327
Watt
+ Muren =
628
Watt
1430
Watt
2424
Watt
*Ventilatieverlies =
- SPACE 3 Totaal warmteverlies = *Intern warmteverlies =
40
Watt
+ Muren =
0
Watt
+ Vloer en plafond =
40
Watt
1194
Watt
+ Dak =
0
Watt
+ Vloer =
0
Watt
*Extern warmteverlies =
© artesis
p 81 / 83
+ Muren = *Ventilatieverlies =
1194
Watt
1190
Watt
1476
Watt
- SPACE 4 Totaal warmteverlies = *Intern warmteverlies =
18
Watt
+ Muren =
0
Watt
+ Vloer en plafond =
18
Watt
943
Watt
+ Dak =
0
Watt
+ Vloer =
0
Watt
+ Muren =
943
Watt
515
Watt
2424
Watt
*Extern warmteverlies =
*Ventilatieverlies =
- SPACE 5 Totaal warmteverlies = *Intern warmteverlies =
40
Watt
+ Muren =
0
Watt
+ Vloer en plafond =
40
Watt
1194
Watt
+ Dak =
0
Watt
+ Vloer =
0
Watt
+ Muren =
1194
Watt
1190
Watt
1476
Watt
*Extern warmteverlies =
*Ventilatieverlies =
- SPACE 6 Totaal warmteverlies = *Intern warmteverlies =
18
Watt
+ Muren =
0
Watt
+ Vloer en plafond =
18
Watt
943
Watt
+ Dak =
0
Watt
+ Vloer =
0
Watt
+ Muren =
943
Watt
515
Watt
2439
Watt
*Extern warmteverlies =
*Ventilatieverlies =
- SPACE 7 Totaal warmteverlies = *Intern warmteverlies =
18
Watt
+ Muren =
0
Watt
+ Vloer en plafond =
18
Watt
1405
Watt
+ Dak =
261
Watt
+ Vloer =
0
Watt
+ Muren =
1144
Watt
1015
Watt
*Extern warmteverlies =
*Ventilatieverlies =
© artesis
p 82 / 83
- SPACE 8 Totaal warmteverlies = *Intern warmteverlies =
2267
Watt
18
Watt
+ Muren =
0
Watt
+ Vloer en plafond =
18
Watt
1233
Watt
+ Dak =
261
Watt
+ Vloer =
0
Watt
+ Muren =
973
Watt
1015
Watt
2439
Watt
*Extern warmteverlies =
*Ventilatieverlies =
- SPACE 9 Totaal warmteverlies = *Intern warmteverlies =
18
Watt
+ Muren =
0
Watt
+ Vloer en plafond =
18
Watt
1405
Watt
+ Dak =
261
Watt
+ Vloer =
0
Watt
+ Muren =
1144
Watt
1015
Watt
2439
Watt
*Extern warmteverlies =
*Ventilatieverlies =
- SPACE 10 Totaal warmteverlies = *Intern warmteverlies =
18
Watt
+ Muren =
0
Watt
+ Vloer en plafond =
18
Watt
1405
Watt
+ Dak =
261
Watt
+ Vloer =
0
Watt
+ Muren =
1144
Watt
1015
Watt
*Extern warmteverlies =
*Ventilatieverlies =
© artesis
p 83 / 83
