tbd 3.2.2 → 3.3.0
Sign up to get free protection for your applications and to get access to all the features.
- checksums.yaml +4 -4
- data/.github/workflows/pull_request.yml +32 -0
- data/.yardopts +14 -0
- data/README.md +23 -25
- data/json/tbd_warehouse17.json +8 -0
- data/json/tbd_warehouse18.json +12 -0
- data/json/tbd_warehouse4.json +17 -0
- data/lib/measures/tbd/README.md +27 -11
- data/lib/measures/tbd/measure.rb +155 -72
- data/lib/measures/tbd/measure.xml +169 -67
- data/lib/measures/tbd/resources/geo.rb +435 -257
- data/lib/measures/tbd/resources/oslog.rb +213 -161
- data/lib/measures/tbd/resources/psi.rb +1849 -900
- data/lib/measures/tbd/resources/ua.rb +380 -309
- data/lib/measures/tbd/resources/utils.rb +2995 -680
- data/lib/measures/tbd/resources/version.rb +1 -1
- data/lib/measures/tbd/tests/tbd_tests.rb +1 -1
- data/lib/tbd/geo.rb +435 -257
- data/lib/tbd/psi.rb +1849 -900
- data/lib/tbd/ua.rb +380 -309
- data/lib/tbd/version.rb +1 -1
- data/lib/tbd.rb +14 -34
- data/tbd.gemspec +1 -1
- data/tbd.schema.json +189 -20
- data/v291_MacOS.md +2 -4
- metadata +8 -4
|
@@ -21,9 +21,9 @@
|
|
|
21
21
|
# SOFTWARE.
|
|
22
22
|
|
|
23
23
|
module TBD
|
|
24
|
-
# Sources for thermal bridge types and default KHI & PSI
|
|
24
|
+
# Sources for thermal bridge types and default KHI- & PSI-factor sets:
|
|
25
25
|
#
|
|
26
|
-
# a) BETBG = Building Envelope Thermal Bridging Guide v1.4 (or
|
|
26
|
+
# a) BETBG = Building Envelope Thermal Bridging Guide v1.4 (or newer):
|
|
27
27
|
#
|
|
28
28
|
# www.bchydro.com/content/dam/BCHydro/customer-portal/documents/power-smart/
|
|
29
29
|
# business/programs/BETB-Building-Envelope-Thermal-Bridging-Guide-v1-4.pdf
|
|
@@ -42,47 +42,63 @@ module TBD
|
|
|
42
42
|
# Library of point thermal bridges (e.g. columns). Each key:value entry
|
|
43
43
|
# requires a unique identifier e.g. "poor (BETBG)" and a KHI-value in W/K.
|
|
44
44
|
class KHI
|
|
45
|
+
extend OSut
|
|
46
|
+
|
|
45
47
|
# @return [Hash] KHI library
|
|
46
48
|
attr_reader :point
|
|
47
49
|
|
|
48
50
|
##
|
|
49
|
-
#
|
|
51
|
+
# Constructs a new KHI library (with defaults).
|
|
50
52
|
def initialize
|
|
51
53
|
@point = {}
|
|
52
54
|
|
|
53
|
-
# The following are
|
|
54
|
-
#
|
|
55
|
-
|
|
56
|
-
@point["
|
|
57
|
-
@point["
|
|
58
|
-
@point["
|
|
59
|
-
@point["
|
|
60
|
-
@point["
|
|
61
|
-
@point["
|
|
55
|
+
# The following are built-in KHI-factors. Users may append new key:value
|
|
56
|
+
# pairs, preferably through a TBD JSON input file. Units are in W/K.
|
|
57
|
+
@point["poor (BETBG)" ] = 0.900 # detail 5.7.2 BETBG
|
|
58
|
+
@point["regular (BETBG)" ] = 0.500 # detail 5.7.4 BETBG
|
|
59
|
+
@point["efficient (BETBG)" ] = 0.150 # detail 5.7.3 BETBG
|
|
60
|
+
@point["code (Quebec)" ] = 0.500 # art. 3.3.1.3. NECB-QC
|
|
61
|
+
@point["uncompliant (Quebec)" ] = 1.000 # NECB-QC Guide
|
|
62
|
+
@point["90.1.22|steel.m|default" ] = 0.480 # steel/metal, compliant
|
|
63
|
+
@point["90.1.22|steel.m|unmitigated"] = 0.920 # steel/metal, non-compliant
|
|
64
|
+
@point["90.1.22|mass.ex|default" ] = 0.330 # ext/integral, compliant
|
|
65
|
+
@point["90.1.22|mass.ex|unmitigated"] = 0.460 # ext/integral, non-compliant
|
|
66
|
+
@point["90.1.22|mass.in|default" ] = 0.330 # interior mass, compliant
|
|
67
|
+
@point["90.1.22|mass.in|unmitigated"] = 0.460 # interior, non-compliant
|
|
68
|
+
@point["90.1.22|wood.fr|default" ] = 0.040 # compliant
|
|
69
|
+
@point["90.1.22|wood.fr|unmitigated"] = 0.330 # non-compliant
|
|
70
|
+
@point["(non thermal bridging)" ] = 0.000 # defaults to 0
|
|
62
71
|
end
|
|
63
72
|
|
|
64
73
|
##
|
|
65
|
-
#
|
|
66
|
-
# a valid, unique :id key and valid :point value).
|
|
74
|
+
# Appends a new KHI entry.
|
|
67
75
|
#
|
|
68
|
-
# @param
|
|
76
|
+
# @param [Hash] k a new KHI entry
|
|
77
|
+
# @option k [#to_s] :id name
|
|
78
|
+
# @option k [#to_f] :point conductance, in W/K
|
|
69
79
|
#
|
|
70
|
-
# @return [Bool]
|
|
71
|
-
# @return [
|
|
80
|
+
# @return [Bool] whether KHI entry is successfully appended
|
|
81
|
+
# @return [false] if invalid input (see logs)
|
|
72
82
|
def append(k = {})
|
|
73
83
|
mth = "TBD::#{__callee__}"
|
|
74
84
|
a = false
|
|
75
|
-
|
|
76
|
-
return
|
|
77
|
-
return
|
|
78
|
-
return
|
|
79
|
-
|
|
80
|
-
|
|
81
|
-
|
|
85
|
+
ck1 = k.respond_to?(:key?)
|
|
86
|
+
return mismatch("KHI" , k, Hash , mth, DBG, a) unless ck1
|
|
87
|
+
return hashkey("KHI id" , k, :id , mth, DBG, a) unless k.key?(:id)
|
|
88
|
+
return hashkey("KHI point", k, :point, mth, DBG, a) unless k.key?(:point)
|
|
89
|
+
|
|
90
|
+
id = trim(k[:id])
|
|
91
|
+
ck1 = id.empty?
|
|
92
|
+
ck2 = k[:point].respond_to?(:to_f)
|
|
93
|
+
return mismatch("KHI id" , k[:id ], String, mth, ERR, a) if ck1
|
|
94
|
+
return mismatch("KHI point", k[:point], Float , mth, ERR, a) unless ck2
|
|
95
|
+
|
|
96
|
+
if @point.key?(id)
|
|
97
|
+
log(ERR, "Skipping '#{id}': existing KHI entry (#{mth})")
|
|
82
98
|
return false
|
|
83
99
|
end
|
|
84
100
|
|
|
85
|
-
@point[
|
|
101
|
+
@point[id] = k[:point].to_f
|
|
86
102
|
|
|
87
103
|
true
|
|
88
104
|
end
|
|
@@ -91,302 +107,753 @@ module TBD
|
|
|
91
107
|
##
|
|
92
108
|
# Library of linear thermal bridges (e.g. corners, balconies). Each key:value
|
|
93
109
|
# entry requires a unique identifier e.g. "poor (BETBG)" and a (partial or
|
|
94
|
-
# complete) set of PSI-
|
|
110
|
+
# complete) set of PSI-factors in W/K per linear meter.
|
|
95
111
|
class PSI
|
|
112
|
+
extend OSut
|
|
113
|
+
|
|
96
114
|
# @return [Hash] PSI set
|
|
97
115
|
attr_reader :set
|
|
98
116
|
|
|
99
117
|
# @return [Hash] shorthand listing of PSI types in a set
|
|
100
118
|
attr_reader :has
|
|
101
119
|
|
|
102
|
-
# @return [Hash] shorthand listing of PSI
|
|
120
|
+
# @return [Hash] shorthand listing of PSI-factors in a set
|
|
103
121
|
attr_reader :val
|
|
104
122
|
|
|
105
123
|
##
|
|
106
|
-
#
|
|
124
|
+
# Constructs a new PSI library (with defaults)
|
|
107
125
|
def initialize
|
|
108
126
|
@set = {}
|
|
109
127
|
@has = {}
|
|
110
128
|
@val = {}
|
|
111
129
|
|
|
112
|
-
# The following are
|
|
113
|
-
#
|
|
114
|
-
# TBD JSON input file.
|
|
115
|
-
#
|
|
116
|
-
|
|
130
|
+
# The following are built-in PSI-factor sets, more often predefined sets
|
|
131
|
+
# published in guides or energy codes. Users may append new sets,
|
|
132
|
+
# preferably through a TBD JSON input file. Units are in W/K per meter.
|
|
133
|
+
#
|
|
134
|
+
# The provided "spandrel" sets are suitable for early design.
|
|
135
|
+
#
|
|
117
136
|
# Convex vs concave PSI adjustments may be warranted if there is a
|
|
118
137
|
# mismatch between dimensioning conventions (interior vs exterior) used
|
|
119
|
-
# for the OpenStudio model
|
|
120
|
-
#
|
|
121
|
-
#
|
|
122
|
-
#
|
|
123
|
-
# using outside dimensions for an
|
|
138
|
+
# for the OpenStudio model vs published PSI data. For instance, the BETBG
|
|
139
|
+
# data reflects an interior dimensioning convention, while ISO 14683
|
|
140
|
+
# reports PSI-factors for both conventions. The following may be used
|
|
141
|
+
# (with caution) to adjust BETBG PSI-factors for convex corners when
|
|
142
|
+
# using outside dimensions for an OpenStudio model.
|
|
124
143
|
#
|
|
125
144
|
# PSIe = PSIi + U * 2(Li-Le), where:
|
|
126
|
-
# PSIe = adjusted PSI
|
|
127
|
-
# PSIi = initial published PSI
|
|
128
|
-
# U = average clear field U-factor of adjacent walls
|
|
129
|
-
# Li =
|
|
130
|
-
# Le =
|
|
145
|
+
# PSIe = adjusted PSI W/K per m
|
|
146
|
+
# PSIi = initial published PSI, in W/K per m
|
|
147
|
+
# U = average clear field U-factor of adjacent walls, in W/m2•K
|
|
148
|
+
# Li = 'interior corner to edge' length of "zone of influence", in m
|
|
149
|
+
# Le = 'exterior corner to edge' length of "zone of influence", in m
|
|
131
150
|
#
|
|
132
151
|
# Li-Le = wall thickness e.g., -0.25m (negative here as Li < Le)
|
|
152
|
+
|
|
153
|
+
# Based on INTERIOR dimensioning (p.15 BETBG).
|
|
133
154
|
@set["poor (BETBG)"] =
|
|
134
155
|
{
|
|
135
|
-
rimjoist:
|
|
136
|
-
parapet:
|
|
137
|
-
|
|
138
|
-
|
|
139
|
-
|
|
140
|
-
|
|
141
|
-
|
|
142
|
-
|
|
143
|
-
|
|
144
|
-
|
|
145
|
-
|
|
156
|
+
rimjoist: 1.000000, # re: BETBG
|
|
157
|
+
parapet: 0.800000, # re: BETBG
|
|
158
|
+
roof: 0.800000, # same as parapet
|
|
159
|
+
fenestration: 0.500000, # re: BETBG
|
|
160
|
+
door: 0.500000, # inferred, same as (vertical) fenestration
|
|
161
|
+
skylight: 0.500000, # inferred, same as (vertical) fenestration
|
|
162
|
+
spandrel: 0.155000, # Detail 5.4.4
|
|
163
|
+
corner: 0.850000, # re: BETBG
|
|
164
|
+
balcony: 1.000000, # re: BETBG
|
|
165
|
+
balconysill: 1.000000, # same as balcony
|
|
166
|
+
balconydoorsill: 1.000000, # same as balconysill
|
|
167
|
+
party: 0.850000, # re: BETBG
|
|
168
|
+
grade: 0.850000, # re: BETBG
|
|
169
|
+
joint: 0.300000, # re: BETBG
|
|
170
|
+
transition: 0.000000 # defaults to 0
|
|
171
|
+
}.freeze
|
|
146
172
|
|
|
173
|
+
# Based on INTERIOR dimensioning (p.15 BETBG).
|
|
147
174
|
@set["regular (BETBG)"] =
|
|
148
175
|
{
|
|
149
|
-
rimjoist:
|
|
150
|
-
parapet:
|
|
151
|
-
|
|
152
|
-
|
|
153
|
-
|
|
154
|
-
|
|
155
|
-
|
|
156
|
-
|
|
157
|
-
|
|
158
|
-
|
|
159
|
-
|
|
176
|
+
rimjoist: 0.500000, # re: BETBG
|
|
177
|
+
parapet: 0.450000, # re: BETBG
|
|
178
|
+
roof: 0.450000, # same as parapet
|
|
179
|
+
fenestration: 0.350000, # re: BETBG
|
|
180
|
+
door: 0.350000, # inferred, same as (vertical) fenestration
|
|
181
|
+
skylight: 0.350000, # inferred, same as (vertical) fenestration
|
|
182
|
+
spandrel: 0.155000, # Detail 5.4.4
|
|
183
|
+
corner: 0.450000, # re: BETBG
|
|
184
|
+
balcony: 0.500000, # re: BETBG
|
|
185
|
+
balconysill: 0.500000, # same as balcony
|
|
186
|
+
balconydoorsill: 0.500000, # same as balconysill
|
|
187
|
+
party: 0.450000, # re: BETBG
|
|
188
|
+
grade: 0.450000, # re: BETBG
|
|
189
|
+
joint: 0.200000, # re: BETBG
|
|
190
|
+
transition: 0.000000 # defaults to 0
|
|
191
|
+
}.freeze
|
|
160
192
|
|
|
193
|
+
# Based on INTERIOR dimensioning (p.15 BETBG).
|
|
161
194
|
@set["efficient (BETBG)"] =
|
|
162
195
|
{
|
|
163
|
-
rimjoist:
|
|
164
|
-
parapet:
|
|
165
|
-
|
|
166
|
-
|
|
167
|
-
|
|
168
|
-
|
|
169
|
-
|
|
170
|
-
|
|
171
|
-
|
|
172
|
-
|
|
173
|
-
|
|
196
|
+
rimjoist: 0.200000, # re: BETBG
|
|
197
|
+
parapet: 0.200000, # re: BETBG
|
|
198
|
+
roof: 0.200000, # same as parapet
|
|
199
|
+
fenestration: 0.199999, # re: BETBG
|
|
200
|
+
door: 0.199999, # inferred, same as (vertical) fenestration
|
|
201
|
+
skylight: 0.199999, # inferred, same as (vertical) fenestration
|
|
202
|
+
spandrel: 0.155000, # Detail 5.4.4
|
|
203
|
+
corner: 0.200000, # re: BETBG
|
|
204
|
+
balcony: 0.200000, # re: BETBG
|
|
205
|
+
balconysill: 0.200000, # same as balcony
|
|
206
|
+
balconydoorsill: 0.200000, # same as balconysill
|
|
207
|
+
party: 0.200000, # re: BETBG
|
|
208
|
+
grade: 0.200000, # re: BETBG
|
|
209
|
+
joint: 0.100000, # re: BETBG
|
|
210
|
+
transition: 0.000000 # defaults to 0
|
|
211
|
+
}.freeze
|
|
174
212
|
|
|
213
|
+
# "Conventional", closer to window wall spandrels.
|
|
175
214
|
@set["spandrel (BETBG)"] =
|
|
176
215
|
{
|
|
177
|
-
rimjoist:
|
|
178
|
-
parapet:
|
|
179
|
-
|
|
180
|
-
|
|
181
|
-
|
|
182
|
-
|
|
183
|
-
|
|
184
|
-
|
|
185
|
-
|
|
186
|
-
|
|
187
|
-
|
|
216
|
+
rimjoist: 0.615000, # Detail 1.2.1
|
|
217
|
+
parapet: 1.000000, # Detail 1.3.2
|
|
218
|
+
roof: 1.000000, # same as parapet
|
|
219
|
+
fenestration: 0.000000, # inferred, generally part of clear-field RSi
|
|
220
|
+
door: 0.000000, # inferred, generally part of clear-field RSi
|
|
221
|
+
skylight: 0.350000, # same as "regular (BETBG)"
|
|
222
|
+
spandrel: 0.155000, # Detail 5.4.4
|
|
223
|
+
corner: 0.425000, # Detail 1.4.1
|
|
224
|
+
balcony: 1.110000, # Detail 8.1.9/9.1.6
|
|
225
|
+
balconysill: 1.110000, # same as balcony
|
|
226
|
+
balconydoorsill: 1.110000, # same as balconysill
|
|
227
|
+
party: 0.990000, # inferred, similar to parapet/balcony
|
|
228
|
+
grade: 0.880000, # Detail 2.5.1
|
|
229
|
+
joint: 0.500000, # Detail 3.3.2
|
|
230
|
+
transition: 0.000000 # defaults to 0
|
|
231
|
+
}.freeze
|
|
188
232
|
|
|
233
|
+
# "GoodHigh performance" curtainwall spandrels.
|
|
189
234
|
@set["spandrel HP (BETBG)"] =
|
|
190
235
|
{
|
|
191
|
-
rimjoist:
|
|
192
|
-
parapet:
|
|
193
|
-
|
|
194
|
-
|
|
195
|
-
|
|
196
|
-
|
|
197
|
-
|
|
198
|
-
|
|
199
|
-
|
|
200
|
-
|
|
201
|
-
|
|
202
|
-
|
|
203
|
-
|
|
236
|
+
rimjoist: 0.170000, # Detail 1.2.7
|
|
237
|
+
parapet: 0.660000, # Detail 1.3.2
|
|
238
|
+
roof: 0.660000, # same as parapet
|
|
239
|
+
fenestration: 0.000000, # inferred, generally part of clear-field RSi
|
|
240
|
+
door: 0.000000, # inferred, generally part of clear-field RSi
|
|
241
|
+
skylight: 0.350000, # same as "regular (BETBG)"
|
|
242
|
+
spandrel: 0.155000, # Detail 5.4.4
|
|
243
|
+
corner: 0.200000, # Detail 1.4.2
|
|
244
|
+
balcony: 0.400000, # Detail 9.1.15
|
|
245
|
+
balconysill: 0.400000, # same as balcony
|
|
246
|
+
balconydoorsill: 0.400000, # same as balconysill
|
|
247
|
+
party: 0.500000, # inferred, similar to parapet/balcony
|
|
248
|
+
grade: 0.880000, # Detail 2.5.1
|
|
249
|
+
joint: 0.140000, # Detail 7.4.2
|
|
250
|
+
transition: 0.000000 # defaults to 0
|
|
251
|
+
}.freeze
|
|
252
|
+
|
|
253
|
+
# CCQ, Chapitre I1, code-compliant defaults.
|
|
254
|
+
@set["code (Quebec)"] =
|
|
255
|
+
{
|
|
256
|
+
rimjoist: 0.300000, # re I1
|
|
257
|
+
parapet: 0.325000, # re I1
|
|
258
|
+
roof: 0.325000, # same as parapet
|
|
259
|
+
fenestration: 0.200000, # re I1
|
|
260
|
+
door: 0.200000, # re I1
|
|
261
|
+
skylight: 0.200000, # re I1
|
|
262
|
+
spandrel: 0.155000, # BETBG Detail 5.4.4 (same as uncompliant)
|
|
263
|
+
corner: 0.300000, # inferred from description, not explicitely set
|
|
264
|
+
balcony: 0.500000, # re I1
|
|
265
|
+
balconysill: 0.500000, # same as balcony
|
|
266
|
+
balconydoorsill: 0.500000, # same as balconysill
|
|
267
|
+
party: 0.450000, # re I1
|
|
268
|
+
grade: 0.450000, # re I1
|
|
269
|
+
joint: 0.200000, # re I1
|
|
270
|
+
transition: 0.000000 # defaults to 0
|
|
271
|
+
}.freeze
|
|
272
|
+
|
|
273
|
+
# CCQ, Chapitre I1, non-code-compliant defaults.
|
|
274
|
+
@set["uncompliant (Quebec)"] =
|
|
275
|
+
{
|
|
276
|
+
rimjoist: 0.850000, # re I1
|
|
277
|
+
parapet: 0.800000, # re I1
|
|
278
|
+
roof: 0.800000, # same as parapet
|
|
279
|
+
fenestration: 0.500000, # re I1
|
|
280
|
+
door: 0.500000, # re I1
|
|
281
|
+
skylight: 0.500000, # re I1
|
|
282
|
+
spandrel: 0.155000, # BETBG Detail 5.4.4 (same as compliant)
|
|
283
|
+
corner: 0.850000, # inferred from description, not explicitely set
|
|
284
|
+
balcony: 1.000000, # re I1
|
|
285
|
+
balconysill: 1.000000, # same as balcony
|
|
286
|
+
balconydoorsill: 1.000000, # same as balconysill
|
|
287
|
+
party: 0.850000, # re I1
|
|
288
|
+
grade: 0.850000, # re I1
|
|
289
|
+
joint: 0.500000, # re I1
|
|
290
|
+
transition: 0.000000 # defaults to 0
|
|
291
|
+
}.freeze
|
|
292
|
+
|
|
293
|
+
# ASHRAE 90.1 2022 (A10) "default" steel-framed and metal buildings.
|
|
294
|
+
@set["90.1.22|steel.m|default"] =
|
|
204
295
|
{
|
|
205
|
-
rimjoist:
|
|
206
|
-
parapet:
|
|
207
|
-
|
|
208
|
-
|
|
209
|
-
|
|
210
|
-
|
|
211
|
-
|
|
212
|
-
|
|
213
|
-
|
|
296
|
+
rimjoist: 0.307000, # "intermediate floor to wall intersection"
|
|
297
|
+
parapet: 0.260000, # "parapet" edge
|
|
298
|
+
roof: 0.020000, # (non-parapet) "roof" edge
|
|
299
|
+
fenestration: 0.194000, # "wall to vertical fenestration intersection"
|
|
300
|
+
door: 0.000000, # (unspecified, defaults to 0)
|
|
301
|
+
skylight: 0.000000, # (unspecified, defaults to 0)
|
|
302
|
+
spandrel: 0.000001, # (unspecified, defaults to 0)
|
|
303
|
+
corner: 0.000002, # (unspecified, defaults to 0)
|
|
304
|
+
balcony: 0.307000, # "intermediate floor balcony/overhang" edge
|
|
305
|
+
balconysill: 0.307000, # "intermediate floor balcony" edge (when sill)
|
|
306
|
+
balconydoorsill: 0.307000, # same as balcony
|
|
307
|
+
party: 0.000001, # (unspecified, defaults to 0)
|
|
308
|
+
grade: 0.000001, # (unspecified, defaults to 0)
|
|
309
|
+
joint: 0.376000, # placeholder for "cladding support"
|
|
310
|
+
transition: 0.000000 # defaults to 0
|
|
214
311
|
}.freeze
|
|
215
|
-
self.gen("code (Quebec)")
|
|
216
312
|
|
|
217
|
-
|
|
313
|
+
# ASHRAE 90.1 2022 (A10) "unmitigated" steel-framed and metal buildings.
|
|
314
|
+
@set["90.1.22|steel.m|unmitigated"] =
|
|
218
315
|
{
|
|
219
|
-
rimjoist:
|
|
220
|
-
parapet:
|
|
221
|
-
|
|
222
|
-
|
|
223
|
-
|
|
224
|
-
|
|
225
|
-
|
|
226
|
-
|
|
227
|
-
|
|
316
|
+
rimjoist: 0.842000, # "intermediate floor to wall intersection"
|
|
317
|
+
parapet: 0.500000, # "parapet" edge
|
|
318
|
+
roof: 0.650000, # (non-parapet) "roof" edge
|
|
319
|
+
fenestration: 0.505000, # "wall to vertical fenestration intersection"
|
|
320
|
+
door: 0.000000, # (unspecified, defaults to 0)
|
|
321
|
+
skylight: 0.000000, # (unspecified, defaults to 0)
|
|
322
|
+
spandrel: 0.000001, # (unspecified, defaults to 0)
|
|
323
|
+
corner: 0.000002, # (unspecified, defaults to 0)
|
|
324
|
+
balcony: 0.842000, # "intermediate floor balcony/overhang" edge
|
|
325
|
+
balconysill: 1.686000, # "intermediate floor balcony" edge (when sill)
|
|
326
|
+
balconydoorsill: 0.842000, # same as balcony
|
|
327
|
+
party: 0.000001, # (unspecified, defaults to 0)
|
|
328
|
+
grade: 0.000001, # (unspecified, defaults to 0)
|
|
329
|
+
joint: 0.554000, # placeholder for "cladding support"
|
|
330
|
+
transition: 0.000000 # defaults to 0
|
|
228
331
|
}.freeze
|
|
229
|
-
self.gen("uncompliant (Quebec)")
|
|
230
332
|
|
|
231
|
-
|
|
333
|
+
# ASHRAE 90.1 2022 (A10) "default" exterior/integral mass walls.
|
|
334
|
+
@set["90.1.22|mass.ex|default"] =
|
|
232
335
|
{
|
|
233
|
-
rimjoist:
|
|
234
|
-
parapet:
|
|
235
|
-
|
|
236
|
-
|
|
237
|
-
|
|
238
|
-
|
|
239
|
-
|
|
240
|
-
|
|
241
|
-
|
|
336
|
+
rimjoist: 0.205000, # "intermediate floor to wall intersection"
|
|
337
|
+
parapet: 0.217000, # "parapet" edge
|
|
338
|
+
roof: 0.150000, # (non-parapet) "roof" edge
|
|
339
|
+
fenestration: 0.226000, # "wall to vertical fenestration intersection"
|
|
340
|
+
door: 0.000000, # (unspecified, defaults to 0)
|
|
341
|
+
skylight: 0.000000, # (unspecified, defaults to 0)
|
|
342
|
+
spandrel: 0.000001, # (unspecified, defaults to 0)
|
|
343
|
+
corner: 0.000002, # (unspecified, defaults to 0)
|
|
344
|
+
balcony: 0.205000, # "intermediate floor balcony/overhang" edge
|
|
345
|
+
balconysill: 0.307000, # "intermediate floor balcony" edge (when sill)
|
|
346
|
+
balconydoorsill: 0.205000, # same as balcony
|
|
347
|
+
party: 0.000001, # (unspecified, defaults to 0)
|
|
348
|
+
grade: 0.000001, # (unspecified, defaults to 0)
|
|
349
|
+
joint: 0.322000, # placeholder for "cladding support"
|
|
350
|
+
transition: 0.000000 # defaults to 0
|
|
242
351
|
}.freeze
|
|
243
|
-
|
|
352
|
+
|
|
353
|
+
# ASHRAE 90.1 2022 (A10) "unmitigated" exterior/integral mass walls.
|
|
354
|
+
@set["90.1.22|mass.ex|unmitigated"] =
|
|
355
|
+
{
|
|
356
|
+
rimjoist: 0.824000, # "intermediate floor to wall intersection"
|
|
357
|
+
parapet: 0.412000, # "parapet" edge
|
|
358
|
+
roof: 0.750000, # (non-parapet) "roof" edge
|
|
359
|
+
fenestration: 0.325000, # "wall to vertical fenestration intersection"
|
|
360
|
+
door: 0.000000, # (unspecified, defaults to 0)
|
|
361
|
+
skylight: 0.000000, # (unspecified, defaults to 0)
|
|
362
|
+
spandrel: 0.000001, # (unspecified, defaults to 0)
|
|
363
|
+
corner: 0.000002, # (unspecified, defaults to 0)
|
|
364
|
+
balcony: 0.824000, # "intermediate floor balcony/overhang" edge
|
|
365
|
+
balconysill: 1.686000, # "intermediate floor balcony" edge (when sill)
|
|
366
|
+
balconydoorsill: 0.824000, # same as balcony
|
|
367
|
+
party: 0.000001, # (unspecified, defaults to 0)
|
|
368
|
+
grade: 0.000001, # (unspecified, defaults to 0)
|
|
369
|
+
joint: 0.476000, # placeholder for "cladding support"
|
|
370
|
+
transition: 0.000000 # defaults to 0
|
|
371
|
+
}.freeze
|
|
372
|
+
|
|
373
|
+
# ASHRAE 90.1 2022 (A10) "default" interior mass walls.
|
|
374
|
+
@set["90.1.22|mass.in|default"] =
|
|
375
|
+
{
|
|
376
|
+
rimjoist: 0.495000, # "intermediate floor to wall intersection"
|
|
377
|
+
parapet: 0.393000, # "parapet" edge
|
|
378
|
+
roof: 0.150000, # (non-parapet) "roof" edge
|
|
379
|
+
fenestration: 0.143000, # "wall to vertical fenestration intersection"
|
|
380
|
+
door: 0.000000, # (unspecified, defaults to 0)
|
|
381
|
+
skylight: 0.000000, # (unspecified, defaults to 0)
|
|
382
|
+
spandrel: 0.000000, # (unspecified, defaults to 0)
|
|
383
|
+
corner: 0.000001, # (unspecified, defaults to 0)
|
|
384
|
+
balcony: 0.495000, # "intermediate floor balcony/overhang" edge
|
|
385
|
+
balconysill: 0.307000, # "intermediate floor balcony" edge (when sill)
|
|
386
|
+
balconydoorsill: 0.495000, # same as balcony
|
|
387
|
+
party: 0.000001, # (unspecified, defaults to 0)
|
|
388
|
+
grade: 0.000001, # (unspecified, defaults to 0)
|
|
389
|
+
joint: 0.322000, # placeholder for "cladding support"
|
|
390
|
+
transition: 0.000000 # defaults to 0
|
|
391
|
+
}.freeze
|
|
392
|
+
|
|
393
|
+
# ASHRAE 90.1 2022 (A10) "unmitigated" interior mass walls.
|
|
394
|
+
@set["90.1.22|mass.in|unmitigated"] =
|
|
395
|
+
{
|
|
396
|
+
rimjoist: 0.824000, # "intermediate floor to wall intersection"
|
|
397
|
+
parapet: 0.884000, # "parapet" edge
|
|
398
|
+
roof: 0.750000, # (non-parapet) "roof" edge
|
|
399
|
+
fenestration: 0.543000, # "wall to vertical fenestration intersection"
|
|
400
|
+
door: 0.000000, # (unspecified, defaults to 0)
|
|
401
|
+
skylight: 0.000000, # (unspecified, defaults to 0)
|
|
402
|
+
spandrel: 0.000000, # (unspecified, defaults to 0)
|
|
403
|
+
corner: 0.000001, # (unspecified, defaults to 0)
|
|
404
|
+
balcony: 0.824000, # "intermediate floor balcony/overhang" edge
|
|
405
|
+
balconysill: 1.686000, # "intermediate floor balcony" edge (when sill)
|
|
406
|
+
balconydoorsill: 0.824000, # same as balcony
|
|
407
|
+
party: 0.000001, # (unspecified, defaults to 0)
|
|
408
|
+
grade: 0.000001, # (unspecified, defaults to 0)
|
|
409
|
+
joint: 0.476000, # placeholder for "cladding support"
|
|
410
|
+
transition: 0.000000 # defaults to 0
|
|
411
|
+
}.freeze
|
|
412
|
+
|
|
413
|
+
# ASHRAE 90.1 2022 (A10) "default" wood-framed (and other) walls.
|
|
414
|
+
@set["90.1.22|wood.fr|default"] =
|
|
415
|
+
{
|
|
416
|
+
rimjoist: 0.084000, # "intermediate floor to wall intersection"
|
|
417
|
+
parapet: 0.056000, # "parapet" edge
|
|
418
|
+
roof: 0.020000, # (non-parapet) "roof" edge
|
|
419
|
+
fenestration: 0.171000, # "wall to vertical fenestration intersection"
|
|
420
|
+
door: 0.000000, # (unspecified, defaults to 0)
|
|
421
|
+
skylight: 0.000000, # (unspecified, defaults to 0)
|
|
422
|
+
spandrel: 0.000000, # (unspecified, defaults to 0)
|
|
423
|
+
corner: 0.000001, # (unspecified, defaults to 0)
|
|
424
|
+
balcony: 0.084000, # "intermediate floor balcony/overhang" edge
|
|
425
|
+
balconysill: 0.171001, # same as :fenestration
|
|
426
|
+
balconydoorsill: 0.084000, # same as balcony
|
|
427
|
+
party: 0.000001, # (unspecified, defaults to 0)
|
|
428
|
+
grade: 0.000001, # (unspecified, defaults to 0)
|
|
429
|
+
joint: 0.074000, # placeholder for "cladding support"
|
|
430
|
+
transition: 0.000000 # defaults to 0
|
|
431
|
+
}.freeze
|
|
432
|
+
|
|
433
|
+
# ASHRAE 90.1 2022 (A10) "unmitigated" wood-framed (and other) walls.
|
|
434
|
+
@set["90.1.22|wood.fr|unmitigated"] =
|
|
435
|
+
{
|
|
436
|
+
rimjoist: 0.582000, # "intermediate floor to wall intersection"
|
|
437
|
+
parapet: 0.056000, # "parapet" edge
|
|
438
|
+
roof: 0.150000, # (non-parapet) "roof" edge
|
|
439
|
+
fenestration: 0.260000, # "wall to vertical fenestration intersection"
|
|
440
|
+
door: 0.000000, # (unspecified, defaults to 0)
|
|
441
|
+
skylight: 0.000000, # (unspecified, defaults to 0)
|
|
442
|
+
spandrel: 0.000000, # (unspecified, defaults to 0)
|
|
443
|
+
corner: 0.000001, # (unspecified, defaults to 0)
|
|
444
|
+
balcony: 0.582000, # same as :rimjoist
|
|
445
|
+
balconysill: 0.582000, # same as :rimjoist
|
|
446
|
+
balconydoorsill: 0.582000, # same as balcony
|
|
447
|
+
party: 0.000001, # (unspecified, defaults to 0)
|
|
448
|
+
grade: 0.000001, # (unspecified, defaults to 0)
|
|
449
|
+
joint: 0.322000, # placeholder for "cladding support"
|
|
450
|
+
transition: 0.000000 # defaults to 0
|
|
451
|
+
}.freeze
|
|
452
|
+
|
|
453
|
+
@set["(non thermal bridging)"] =
|
|
454
|
+
{
|
|
455
|
+
rimjoist: 0.000000, # defaults to 0
|
|
456
|
+
parapet: 0.000000, # defaults to 0
|
|
457
|
+
roof: 0.000000, # defaults to 0
|
|
458
|
+
fenestration: 0.000000, # defaults to 0
|
|
459
|
+
door: 0.000000, # defaults to 0
|
|
460
|
+
skylight: 0.000000, # defaults to 0
|
|
461
|
+
spandrel: 0.000000, # defaults to 0
|
|
462
|
+
corner: 0.000000, # defaults to 0
|
|
463
|
+
balcony: 0.000000, # defaults to 0
|
|
464
|
+
balconysill: 0.000000, # defaults to 0
|
|
465
|
+
party: 0.000000, # defaults to 0
|
|
466
|
+
grade: 0.000000, # defaults to 0
|
|
467
|
+
joint: 0.000000, # defaults to 0
|
|
468
|
+
transition: 0.000000 # defaults to 0
|
|
469
|
+
}.freeze
|
|
470
|
+
|
|
471
|
+
@set.keys.each { |k| self.gen(k) }
|
|
244
472
|
end
|
|
245
473
|
|
|
246
474
|
##
|
|
247
|
-
#
|
|
475
|
+
# Generates PSI set shorthand listings.
|
|
248
476
|
#
|
|
249
|
-
# @param id
|
|
477
|
+
# @param id PSI set identifier
|
|
250
478
|
#
|
|
251
|
-
# @return [Bool]
|
|
252
|
-
# @return [
|
|
479
|
+
# @return [Bool] whether successful in generating PSI set shorthands
|
|
480
|
+
# @return [false] if invalid input (see logs)
|
|
253
481
|
def gen(id = "")
|
|
254
482
|
mth = "TBD::#{__callee__}"
|
|
255
|
-
|
|
256
|
-
|
|
257
|
-
|
|
258
|
-
|
|
259
|
-
|
|
260
|
-
h
|
|
261
|
-
h[:
|
|
262
|
-
h[:
|
|
263
|
-
h[:
|
|
264
|
-
h[:
|
|
265
|
-
h[:
|
|
266
|
-
h[:
|
|
267
|
-
h[:
|
|
268
|
-
h[:
|
|
269
|
-
h[:
|
|
270
|
-
h[:
|
|
271
|
-
h[:
|
|
272
|
-
h[:
|
|
273
|
-
h[:
|
|
274
|
-
h[:
|
|
275
|
-
h[:
|
|
276
|
-
h[:
|
|
277
|
-
h[:
|
|
278
|
-
h[:
|
|
279
|
-
h[:
|
|
280
|
-
h[:
|
|
281
|
-
h[:
|
|
282
|
-
h[:
|
|
283
|
-
h[:
|
|
284
|
-
h[:
|
|
285
|
-
h[:
|
|
286
|
-
h[:
|
|
287
|
-
h[:
|
|
288
|
-
h[:
|
|
289
|
-
h[:
|
|
290
|
-
h[:
|
|
291
|
-
@
|
|
292
|
-
|
|
293
|
-
|
|
294
|
-
|
|
295
|
-
|
|
296
|
-
|
|
297
|
-
|
|
298
|
-
|
|
299
|
-
|
|
300
|
-
|
|
301
|
-
|
|
302
|
-
|
|
303
|
-
|
|
304
|
-
|
|
305
|
-
|
|
306
|
-
|
|
307
|
-
|
|
308
|
-
|
|
309
|
-
|
|
310
|
-
|
|
311
|
-
|
|
312
|
-
|
|
313
|
-
|
|
314
|
-
|
|
315
|
-
|
|
316
|
-
|
|
317
|
-
|
|
318
|
-
|
|
319
|
-
|
|
320
|
-
|
|
321
|
-
|
|
322
|
-
v
|
|
323
|
-
v[:
|
|
324
|
-
v[:
|
|
325
|
-
v[:
|
|
326
|
-
v[:
|
|
327
|
-
v[:
|
|
328
|
-
v[:
|
|
329
|
-
v[:
|
|
330
|
-
v[:
|
|
331
|
-
v[:
|
|
332
|
-
v[:
|
|
333
|
-
v[:
|
|
334
|
-
v[:
|
|
335
|
-
v[:
|
|
336
|
-
v[:
|
|
337
|
-
v[:
|
|
338
|
-
v[:
|
|
339
|
-
v[:
|
|
340
|
-
v[:
|
|
341
|
-
v[:
|
|
342
|
-
v[:
|
|
343
|
-
v[:
|
|
344
|
-
|
|
345
|
-
v[:
|
|
346
|
-
v[:
|
|
347
|
-
v[:
|
|
348
|
-
v[:
|
|
349
|
-
v[:
|
|
350
|
-
v[:
|
|
351
|
-
v[:
|
|
352
|
-
v[:
|
|
353
|
-
v[:
|
|
354
|
-
v[:
|
|
355
|
-
v[:
|
|
356
|
-
v[:
|
|
357
|
-
v[:
|
|
358
|
-
v[:
|
|
359
|
-
v[:
|
|
360
|
-
v[:
|
|
361
|
-
v[:
|
|
483
|
+
return hashkey(id, @set, id, mth, ERR, false) unless @set.key?(id)
|
|
484
|
+
|
|
485
|
+
h = {} # true/false if PSI set has PSI type
|
|
486
|
+
h[:joint ] = @set[id].key?(:joint)
|
|
487
|
+
h[:transition ] = @set[id].key?(:transition)
|
|
488
|
+
h[:fenestration ] = @set[id].key?(:fenestration)
|
|
489
|
+
h[:head ] = @set[id].key?(:head)
|
|
490
|
+
h[:headconcave ] = @set[id].key?(:headconcave)
|
|
491
|
+
h[:headconvex ] = @set[id].key?(:headconvex)
|
|
492
|
+
h[:sill ] = @set[id].key?(:sill)
|
|
493
|
+
h[:sillconcave ] = @set[id].key?(:sillconcave)
|
|
494
|
+
h[:sillconvex ] = @set[id].key?(:sillconvex)
|
|
495
|
+
h[:jamb ] = @set[id].key?(:jamb)
|
|
496
|
+
h[:jambconcave ] = @set[id].key?(:jambconcave)
|
|
497
|
+
h[:jambconvex ] = @set[id].key?(:jambconvex)
|
|
498
|
+
h[:door ] = @set[id].key?(:door)
|
|
499
|
+
h[:doorhead ] = @set[id].key?(:doorhead)
|
|
500
|
+
h[:doorheadconcave ] = @set[id].key?(:doorheadconcave)
|
|
501
|
+
h[:doorheadconvex ] = @set[id].key?(:doorheadconvex)
|
|
502
|
+
h[:doorsill ] = @set[id].key?(:doorsill)
|
|
503
|
+
h[:doorsillconcave ] = @set[id].key?(:doorsillconcave)
|
|
504
|
+
h[:doorsillconvex ] = @set[id].key?(:doorsillconvex)
|
|
505
|
+
h[:doorjamb ] = @set[id].key?(:doorjamb)
|
|
506
|
+
h[:doorjambconcave ] = @set[id].key?(:doorjambconcave)
|
|
507
|
+
h[:doorjambconvex ] = @set[id].key?(:doorjambconvex)
|
|
508
|
+
h[:skylight ] = @set[id].key?(:skylight)
|
|
509
|
+
h[:skylighthead ] = @set[id].key?(:skylighthead)
|
|
510
|
+
h[:skylightheadconcave ] = @set[id].key?(:skylightheadconcave)
|
|
511
|
+
h[:skylightheadconvex ] = @set[id].key?(:skylightheadconvex)
|
|
512
|
+
h[:skylightsill ] = @set[id].key?(:skylightsill)
|
|
513
|
+
h[:skylightsillconcave ] = @set[id].key?(:skylightsillconcave)
|
|
514
|
+
h[:skylightsillconvex ] = @set[id].key?(:skylightsillconvex)
|
|
515
|
+
h[:skylightjamb ] = @set[id].key?(:skylightjamb)
|
|
516
|
+
h[:skylightjambconcave ] = @set[id].key?(:skylightjambconcave)
|
|
517
|
+
h[:skylightjambconvex ] = @set[id].key?(:skylightjambconvex)
|
|
518
|
+
h[:spandrel ] = @set[id].key?(:spandrel)
|
|
519
|
+
h[:spandrelconcave ] = @set[id].key?(:spandrelconcave)
|
|
520
|
+
h[:spandrelconvex ] = @set[id].key?(:spandrelconvex)
|
|
521
|
+
h[:corner ] = @set[id].key?(:corner)
|
|
522
|
+
h[:cornerconcave ] = @set[id].key?(:cornerconcave)
|
|
523
|
+
h[:cornerconvex ] = @set[id].key?(:cornerconvex)
|
|
524
|
+
h[:party ] = @set[id].key?(:party)
|
|
525
|
+
h[:partyconcave ] = @set[id].key?(:partyconcave)
|
|
526
|
+
h[:partyconvex ] = @set[id].key?(:partyconvex)
|
|
527
|
+
h[:parapet ] = @set[id].key?(:parapet)
|
|
528
|
+
h[:partyconcave ] = @set[id].key?(:parapetconcave)
|
|
529
|
+
h[:parapetconvex ] = @set[id].key?(:parapetconvex)
|
|
530
|
+
h[:roof ] = @set[id].key?(:roof)
|
|
531
|
+
h[:roofconcave ] = @set[id].key?(:roofconcave)
|
|
532
|
+
h[:roofconvex ] = @set[id].key?(:roofconvex)
|
|
533
|
+
h[:grade ] = @set[id].key?(:grade)
|
|
534
|
+
h[:gradeconcave ] = @set[id].key?(:gradeconcave)
|
|
535
|
+
h[:gradeconvex ] = @set[id].key?(:gradeconvex)
|
|
536
|
+
h[:balcony ] = @set[id].key?(:balcony)
|
|
537
|
+
h[:balconyconcave ] = @set[id].key?(:balconyconcave)
|
|
538
|
+
h[:balconyconvex ] = @set[id].key?(:balconyconvex)
|
|
539
|
+
h[:balconysill ] = @set[id].key?(:balconysill)
|
|
540
|
+
h[:balconysillconcave ] = @set[id].key?(:balconysillconvex)
|
|
541
|
+
h[:balconysillconvex ] = @set[id].key?(:balconysillconvex)
|
|
542
|
+
h[:balconydoorsill ] = @set[id].key?(:balconydoorsill)
|
|
543
|
+
h[:balconydoorsillconcave] = @set[id].key?(:balconydoorsillconvex)
|
|
544
|
+
h[:balconydoorsillconvex ] = @set[id].key?(:balconydoorsillconvex)
|
|
545
|
+
h[:rimjoist ] = @set[id].key?(:rimjoist)
|
|
546
|
+
h[:rimjoistconcave ] = @set[id].key?(:rimjoistconcave)
|
|
547
|
+
h[:rimjoistconvex ] = @set[id].key?(:rimjoistconvex)
|
|
548
|
+
@has[id] = h
|
|
549
|
+
|
|
550
|
+
v = {} # PSI-value (W/K per linear meter)
|
|
551
|
+
v[:door ] = 0; v[:fenestration ] = 0; v[:skylight ] = 0
|
|
552
|
+
v[:head ] = 0; v[:headconcave ] = 0; v[:headconvex ] = 0
|
|
553
|
+
v[:sill ] = 0; v[:sillconcave ] = 0; v[:sillconvex ] = 0
|
|
554
|
+
v[:jamb ] = 0; v[:jambconcave ] = 0; v[:jambconvex ] = 0
|
|
555
|
+
v[:doorhead ] = 0; v[:doorheadconcave ] = 0; v[:doorconvex ] = 0
|
|
556
|
+
v[:doorsill ] = 0; v[:doorsillconcave ] = 0; v[:doorsillconvex ] = 0
|
|
557
|
+
v[:doorjamb ] = 0; v[:doorjambconcave ] = 0; v[:doorjambconvex ] = 0
|
|
558
|
+
v[:skylighthead ] = 0; v[:skylightheadconcave ] = 0; v[:skylightconvex ] = 0
|
|
559
|
+
v[:skylightsill ] = 0; v[:skylightsillconcave ] = 0; v[:skylightsillconvex ] = 0
|
|
560
|
+
v[:skylightjamb ] = 0; v[:skylightjambconcave ] = 0; v[:skylightjambconvex ] = 0
|
|
561
|
+
v[:spandrel ] = 0; v[:spandrelconcave ] = 0; v[:spandrelconvex ] = 0
|
|
562
|
+
v[:corner ] = 0; v[:cornerconcave ] = 0; v[:cornerconvex ] = 0
|
|
563
|
+
v[:parapet ] = 0; v[:parapetconcave ] = 0; v[:parapetconvex ] = 0
|
|
564
|
+
v[:roof ] = 0; v[:roofconcave ] = 0; v[:roofconvex ] = 0
|
|
565
|
+
v[:party ] = 0; v[:partyconcave ] = 0; v[:partyconvex ] = 0
|
|
566
|
+
v[:grade ] = 0; v[:gradeconcave ] = 0; v[:gradeconvex ] = 0
|
|
567
|
+
v[:balcony ] = 0; v[:balconyconcave ] = 0; v[:balconyconvex ] = 0
|
|
568
|
+
v[:balconysill ] = 0; v[:balconysillconcave ] = 0; v[:balconysillconvex ] = 0
|
|
569
|
+
v[:balconydoorsill] = 0; v[:balconydoorsillconcave] = 0; v[:balconydoorsillconvex] = 0
|
|
570
|
+
v[:rimjoist ] = 0; v[:rimjoistconcave ] = 0; v[:rimjoistconvex ] = 0
|
|
571
|
+
v[:joint ] = 0; v[:transition ] = 0
|
|
572
|
+
|
|
573
|
+
v[:joint ] = @set[id][:joint ] if h[:joint ]
|
|
574
|
+
v[:transition ] = @set[id][:transition ] if h[:transition ]
|
|
575
|
+
v[:fenestration ] = @set[id][:fenestration ] if h[:fenestration ]
|
|
576
|
+
v[:head ] = @set[id][:fenestration ] if h[:fenestration ]
|
|
577
|
+
v[:headconcave ] = @set[id][:fenestration ] if h[:fenestration ]
|
|
578
|
+
v[:headconvex ] = @set[id][:fenestration ] if h[:fenestration ]
|
|
579
|
+
v[:sill ] = @set[id][:fenestration ] if h[:fenestration ]
|
|
580
|
+
v[:sillconcave ] = @set[id][:fenestration ] if h[:fenestration ]
|
|
581
|
+
v[:sillconvex ] = @set[id][:fenestration ] if h[:fenestration ]
|
|
582
|
+
v[:jamb ] = @set[id][:fenestration ] if h[:fenestration ]
|
|
583
|
+
v[:jambconcave ] = @set[id][:fenestration ] if h[:fenestration ]
|
|
584
|
+
v[:jambconvex ] = @set[id][:fenestration ] if h[:fenestration ]
|
|
585
|
+
v[:door ] = @set[id][:fenestration ] if h[:fenestration ]
|
|
586
|
+
v[:doorhead ] = @set[id][:fenestration ] if h[:fenestration ]
|
|
587
|
+
v[:doorheadconcave ] = @set[id][:fenestration ] if h[:fenestration ]
|
|
588
|
+
v[:doorheadconvex ] = @set[id][:fenestration ] if h[:fenestration ]
|
|
589
|
+
v[:doorsill ] = @set[id][:fenestration ] if h[:fenestration ]
|
|
590
|
+
v[:doorsillconcave ] = @set[id][:fenestration ] if h[:fenestration ]
|
|
591
|
+
v[:doorsillconvex ] = @set[id][:fenestration ] if h[:fenestration ]
|
|
592
|
+
v[:doorjamb ] = @set[id][:fenestration ] if h[:fenestration ]
|
|
593
|
+
v[:doorjambconcave ] = @set[id][:fenestration ] if h[:fenestration ]
|
|
594
|
+
v[:doorjambconvex ] = @set[id][:fenestration ] if h[:fenestration ]
|
|
595
|
+
v[:skylight ] = @set[id][:fenestration ] if h[:fenestration ]
|
|
596
|
+
v[:skylighthead ] = @set[id][:fenestration ] if h[:fenestration ]
|
|
597
|
+
v[:skylightheadconcave ] = @set[id][:fenestration ] if h[:fenestration ]
|
|
598
|
+
v[:skylightheadconvex ] = @set[id][:fenestration ] if h[:fenestration ]
|
|
599
|
+
v[:skylightsill ] = @set[id][:fenestration ] if h[:fenestration ]
|
|
600
|
+
v[:skylightsillconcave ] = @set[id][:fenestration ] if h[:fenestration ]
|
|
601
|
+
v[:skylightsillconvex ] = @set[id][:fenestration ] if h[:fenestration ]
|
|
602
|
+
v[:skylightjamb ] = @set[id][:fenestration ] if h[:fenestration ]
|
|
603
|
+
v[:skylightjambconcave ] = @set[id][:fenestration ] if h[:fenestration ]
|
|
604
|
+
v[:skylightjambconvex ] = @set[id][:fenestration ] if h[:fenestration ]
|
|
605
|
+
v[:door ] = @set[id][:door ] if h[:door ]
|
|
606
|
+
v[:doorhead ] = @set[id][:door ] if h[:door ]
|
|
607
|
+
v[:doorheadconcave ] = @set[id][:door ] if h[:door ]
|
|
608
|
+
v[:doorheadconvex ] = @set[id][:door ] if h[:door ]
|
|
609
|
+
v[:doorsill ] = @set[id][:door ] if h[:door ]
|
|
610
|
+
v[:doorsillconcave ] = @set[id][:door ] if h[:door ]
|
|
611
|
+
v[:doorsillconvex ] = @set[id][:door ] if h[:door ]
|
|
612
|
+
v[:doorjamb ] = @set[id][:door ] if h[:door ]
|
|
613
|
+
v[:doorjambconcave ] = @set[id][:door ] if h[:door ]
|
|
614
|
+
v[:doorjambconvex ] = @set[id][:door ] if h[:door ]
|
|
615
|
+
v[:skylight ] = @set[id][:skylight ] if h[:skylight ]
|
|
616
|
+
v[:skylighthead ] = @set[id][:skylight ] if h[:skylight ]
|
|
617
|
+
v[:skylightheadconcave ] = @set[id][:skylight ] if h[:skylight ]
|
|
618
|
+
v[:skylightheadconvex ] = @set[id][:skylight ] if h[:skylight ]
|
|
619
|
+
v[:skylightsill ] = @set[id][:skylight ] if h[:skylight ]
|
|
620
|
+
v[:skylightsillconcave ] = @set[id][:skylight ] if h[:skylight ]
|
|
621
|
+
v[:skylightsillconvex ] = @set[id][:skylight ] if h[:skylight ]
|
|
622
|
+
v[:skylightjamb ] = @set[id][:skylight ] if h[:skylight ]
|
|
623
|
+
v[:skylightjambconcave ] = @set[id][:skylight ] if h[:skylight ]
|
|
624
|
+
v[:skylightjambconvex ] = @set[id][:skylight ] if h[:skylight ]
|
|
625
|
+
v[:head ] = @set[id][:head ] if h[:head ]
|
|
626
|
+
v[:headconcave ] = @set[id][:head ] if h[:head ]
|
|
627
|
+
v[:headconvex ] = @set[id][:head ] if h[:head ]
|
|
628
|
+
v[:sill ] = @set[id][:sill ] if h[:sill ]
|
|
629
|
+
v[:sillconcave ] = @set[id][:sill ] if h[:sill ]
|
|
630
|
+
v[:sillconvex ] = @set[id][:sill ] if h[:sill ]
|
|
631
|
+
v[:jamb ] = @set[id][:jamb ] if h[:jamb ]
|
|
632
|
+
v[:jambconcave ] = @set[id][:jamb ] if h[:jamb ]
|
|
633
|
+
v[:jambconvex ] = @set[id][:jamb ] if h[:jamb ]
|
|
634
|
+
v[:doorhead ] = @set[id][:doorhead ] if h[:doorhead ]
|
|
635
|
+
v[:doorheadconcave ] = @set[id][:doorhead ] if h[:doorhead ]
|
|
636
|
+
v[:doorheadconvex ] = @set[id][:doorhead ] if h[:doorhead ]
|
|
637
|
+
v[:doorsill ] = @set[id][:doorsill ] if h[:doorsill ]
|
|
638
|
+
v[:doorsillconcave ] = @set[id][:doorsill ] if h[:doorsill ]
|
|
639
|
+
v[:doorsillconvex ] = @set[id][:doorsill ] if h[:doorsill ]
|
|
640
|
+
v[:doorjamb ] = @set[id][:doorjamb ] if h[:doorjamb ]
|
|
641
|
+
v[:doorjambconcave ] = @set[id][:doorjamb ] if h[:doorjamb ]
|
|
642
|
+
v[:doorjambconvex ] = @set[id][:doorjamb ] if h[:doorjamb ]
|
|
643
|
+
v[:skylighthead ] = @set[id][:skylighthead ] if h[:skylighthead ]
|
|
644
|
+
v[:skylightheadconcave ] = @set[id][:skylighthead ] if h[:skylighthead ]
|
|
645
|
+
v[:skylightheadconvex ] = @set[id][:skylighthead ] if h[:skylighthead ]
|
|
646
|
+
v[:skylightsill ] = @set[id][:skylightsill ] if h[:skylightsill ]
|
|
647
|
+
v[:skylightsillconcave ] = @set[id][:skylightsill ] if h[:skylightsill ]
|
|
648
|
+
v[:skylightsillconvex ] = @set[id][:skylightsill ] if h[:skylightsill ]
|
|
649
|
+
v[:skylightjamb ] = @set[id][:skylightjamb ] if h[:skylightjamb ]
|
|
650
|
+
v[:skylightjambconcave ] = @set[id][:skylightjamb ] if h[:skylightjamb ]
|
|
651
|
+
v[:skylightjambconvex ] = @set[id][:skylightjamb ] if h[:skylightjamb ]
|
|
652
|
+
v[:headconcave ] = @set[id][:headconcave ] if h[:headconcave ]
|
|
653
|
+
v[:headconvex ] = @set[id][:headconvex ] if h[:headconvex ]
|
|
654
|
+
v[:sillconcave ] = @set[id][:sillconcave ] if h[:sillconcave ]
|
|
655
|
+
v[:sillconvex ] = @set[id][:sillconvex ] if h[:sillconvex ]
|
|
656
|
+
v[:jambconcave ] = @set[id][:jambconcave ] if h[:jambconcave ]
|
|
657
|
+
v[:jambconvex ] = @set[id][:jambconvex ] if h[:jambconvex ]
|
|
658
|
+
v[:doorheadconcave ] = @set[id][:doorheadconcave ] if h[:doorheadconcave ]
|
|
659
|
+
v[:doorheadconvex ] = @set[id][:doorheadconvex ] if h[:doorheadconvex ]
|
|
660
|
+
v[:doorsillconcave ] = @set[id][:doorsillconcave ] if h[:doorsillconcave ]
|
|
661
|
+
v[:doorsillconvex ] = @set[id][:doorsillconvex ] if h[:doorsillconvex ]
|
|
662
|
+
v[:doorjambconcave ] = @set[id][:doorjambconcave ] if h[:doorjambconcave ]
|
|
663
|
+
v[:doorjambconvex ] = @set[id][:doorjambconvex ] if h[:doorjambconvex ]
|
|
664
|
+
v[:skylightheadconcave ] = @set[id][:skylightheadconcave ] if h[:skylightheadconcave ]
|
|
665
|
+
v[:skylightheadconvex ] = @set[id][:skylightheadconvex ] if h[:skylightheadconvex ]
|
|
666
|
+
v[:skylightsillconcave ] = @set[id][:skylightsillconcave ] if h[:skylightsillconcave ]
|
|
667
|
+
v[:skylightsillconvex ] = @set[id][:skylightsillconvex ] if h[:skylightsillconvex ]
|
|
668
|
+
v[:skylightjambconcave ] = @set[id][:skylightjambconcave ] if h[:skylightjambconcave ]
|
|
669
|
+
v[:skylightjambconvex ] = @set[id][:skylightjambconvex ] if h[:skylightjambconvex ]
|
|
670
|
+
v[:spandrel ] = @set[id][:spandrel ] if h[:spandrel ]
|
|
671
|
+
v[:spandrelconcave ] = @set[id][:spandrel ] if h[:spandrel ]
|
|
672
|
+
v[:spandrelconvex ] = @set[id][:spandrel ] if h[:spandrel ]
|
|
673
|
+
v[:spandrelconcave ] = @set[id][:spandrelconcave ] if h[:spandrelconcave ]
|
|
674
|
+
v[:spandrelconvex ] = @set[id][:spandrelconvex ] if h[:spandrelconvex ]
|
|
675
|
+
v[:corner ] = @set[id][:corner ] if h[:corner ]
|
|
676
|
+
v[:cornerconcave ] = @set[id][:corner ] if h[:corner ]
|
|
677
|
+
v[:cornerconvex ] = @set[id][:corner ] if h[:corner ]
|
|
678
|
+
v[:cornerconcave ] = @set[id][:cornerconcave ] if h[:cornerconcave ]
|
|
679
|
+
v[:cornerconvex ] = @set[id][:cornerconvex ] if h[:cornerconvex ]
|
|
680
|
+
v[:parapet ] = @set[id][:roof ] if h[:roof ]
|
|
681
|
+
v[:parapetconcave ] = @set[id][:roof ] if h[:roof ]
|
|
682
|
+
v[:parapetconvex ] = @set[id][:roof ] if h[:roof ]
|
|
683
|
+
v[:parapetconcave ] = @set[id][:roofconcave ] if h[:roofconcave ]
|
|
684
|
+
v[:parapetconvex ] = @set[id][:roofconvex ] if h[:roofconvex ]
|
|
685
|
+
v[:parapet ] = @set[id][:parapet ] if h[:parapet ]
|
|
686
|
+
v[:parapetconcave ] = @set[id][:parapet ] if h[:parapet ]
|
|
687
|
+
v[:parapetconvex ] = @set[id][:parapet ] if h[:parapet ]
|
|
688
|
+
v[:parapetconcave ] = @set[id][:parapetconcave ] if h[:parapetconcave ]
|
|
689
|
+
v[:parapetconvex ] = @set[id][:parapetconvex ] if h[:parapetconvex ]
|
|
690
|
+
v[:roof ] = @set[id][:parapet ] if h[:parapet ]
|
|
691
|
+
v[:roofconcave ] = @set[id][:parapet ] if h[:parapet ]
|
|
692
|
+
v[:roofconvex ] = @set[id][:parapet ] if h[:parapet ]
|
|
693
|
+
v[:roofconcave ] = @set[id][:parapetconcave ] if h[:parapetconcave ]
|
|
694
|
+
v[:roofconvex ] = @set[id][:parapetxonvex ] if h[:parapetconvex ]
|
|
695
|
+
v[:roof ] = @set[id][:roof ] if h[:roof ]
|
|
696
|
+
v[:roofconcave ] = @set[id][:roof ] if h[:roof ]
|
|
697
|
+
v[:roofconvex ] = @set[id][:roof ] if h[:roof ]
|
|
698
|
+
v[:roofconcave ] = @set[id][:roofconcave ] if h[:roofconcave ]
|
|
699
|
+
v[:roofconvex ] = @set[id][:roofconvex ] if h[:roofconvex ]
|
|
700
|
+
v[:party ] = @set[id][:party ] if h[:party ]
|
|
701
|
+
v[:partyconcave ] = @set[id][:party ] if h[:party ]
|
|
702
|
+
v[:partyconvex ] = @set[id][:party ] if h[:party ]
|
|
703
|
+
v[:partyconcave ] = @set[id][:partyconcave ] if h[:partyconcave ]
|
|
704
|
+
v[:partyconvex ] = @set[id][:partyconvex ] if h[:partyconvex ]
|
|
705
|
+
v[:grade ] = @set[id][:grade ] if h[:grade ]
|
|
706
|
+
v[:gradeconcave ] = @set[id][:grade ] if h[:grade ]
|
|
707
|
+
v[:gradeconvex ] = @set[id][:grade ] if h[:grade ]
|
|
708
|
+
v[:gradeconcave ] = @set[id][:gradeconcave ] if h[:gradeconcave ]
|
|
709
|
+
v[:gradeconvex ] = @set[id][:gradeconvex ] if h[:gradeconvex ]
|
|
710
|
+
v[:balcony ] = @set[id][:balcony ] if h[:balcony ]
|
|
711
|
+
v[:balconyconcave ] = @set[id][:balcony ] if h[:balcony ]
|
|
712
|
+
v[:balconyconvex ] = @set[id][:balcony ] if h[:balcony ]
|
|
713
|
+
v[:balconyconcave ] = @set[id][:balconyconcave ] if h[:balconyconcave ]
|
|
714
|
+
v[:balconyconvex ] = @set[id][:balconyconvex ] if h[:balconyconvex ]
|
|
715
|
+
v[:balconysill ] = @set[id][:fenestration ] if h[:fenestration ]
|
|
716
|
+
v[:balconysillconcave ] = @set[id][:fenestration ] if h[:fenestration ]
|
|
717
|
+
v[:balconysillconvex ] = @set[id][:fenestration ] if h[:fenestration ]
|
|
718
|
+
v[:balconydoorsill ] = @set[id][:fenestration ] if h[:fenestration ]
|
|
719
|
+
v[:balconydoorsillconcave] = @set[id][:fenestration ] if h[:fenestration ]
|
|
720
|
+
v[:balconydoorsillconvex ] = @set[id][:fenestration ] if h[:fenestration ]
|
|
721
|
+
v[:balconysill ] = @set[id][:sill ] if h[:sill ]
|
|
722
|
+
v[:balconysillconcave ] = @set[id][:sill ] if h[:sill ]
|
|
723
|
+
v[:balconysillconvex ] = @set[id][:sill ] if h[:sill ]
|
|
724
|
+
v[:balconysillconcave ] = @set[id][:sillconcave ] if h[:sillconcave ]
|
|
725
|
+
v[:balconysillconvex ] = @set[id][:sillconvex ] if h[:sillconvex ]
|
|
726
|
+
v[:balconydoorsill ] = @set[id][:sill ] if h[:sill ]
|
|
727
|
+
v[:balconydoorsillconcave] = @set[id][:sill ] if h[:sill ]
|
|
728
|
+
v[:balconydoorsillconvex ] = @set[id][:sill ] if h[:sill ]
|
|
729
|
+
v[:balconydoorsillconcave] = @set[id][:sillconcave ] if h[:sillconcave ]
|
|
730
|
+
v[:balconydoorsillconvex ] = @set[id][:sillconvex ] if h[:sillconvex ]
|
|
731
|
+
v[:balconysill ] = @set[id][:balcony ] if h[:balcony ]
|
|
732
|
+
v[:balconysillconcave ] = @set[id][:balcony ] if h[:balcony ]
|
|
733
|
+
v[:balconysillconvex ] = @set[id][:balcony ] if h[:balcony ]
|
|
734
|
+
v[:balconysillconcave ] = @set[id][:balconyconcave ] if h[:balconyconcave ]
|
|
735
|
+
v[:balconysillconvex ] = @set[id][:balconyconvex ] if h[:balconycinvex ]
|
|
736
|
+
v[:balconydoorsill ] = @set[id][:balcony ] if h[:balcony ]
|
|
737
|
+
v[:balconydoorsillconcave] = @set[id][:balcony ] if h[:balcony ]
|
|
738
|
+
v[:balconydoorsillconvex ] = @set[id][:balcony ] if h[:balcony ]
|
|
739
|
+
v[:balconydoorsillconcave] = @set[id][:balconyconcave ] if h[:balconyconcave ]
|
|
740
|
+
v[:balconydoorsillconvex ] = @set[id][:balconyconvex ] if h[:balconycinvex ]
|
|
741
|
+
v[:balconysill ] = @set[id][:balconysill ] if h[:balconysill ]
|
|
742
|
+
v[:balconysillconcave ] = @set[id][:balconysill ] if h[:balconysill ]
|
|
743
|
+
v[:balconysillconvex ] = @set[id][:balconysill ] if h[:balconysill ]
|
|
744
|
+
v[:balconysillconcave ] = @set[id][:balconysillconcave ] if h[:balconysillconcave ]
|
|
745
|
+
v[:balconysillconvex ] = @set[id][:balconysillconvex ] if h[:balconysillconvex ]
|
|
746
|
+
v[:balconydoorsill ] = @set[id][:balconysill ] if h[:balconysill ]
|
|
747
|
+
v[:balconydoorsillconcave] = @set[id][:balconysill ] if h[:balconysill ]
|
|
748
|
+
v[:balconydoorsillconvex ] = @set[id][:balconysill ] if h[:balconysill ]
|
|
749
|
+
v[:balconydoorsillconcave] = @set[id][:balconysillconcave ] if h[:balconysillconcave ]
|
|
750
|
+
v[:balconydoorsillconvex ] = @set[id][:balconysillconvex ] if h[:balconysillconvex ]
|
|
751
|
+
v[:balconydoorsill ] = @set[id][:balconydoorsill ] if h[:balconydoorsill ]
|
|
752
|
+
v[:balconydoorsillconcave] = @set[id][:balconydoorsill ] if h[:balconydoorsill ]
|
|
753
|
+
v[:balconydoorsillconvex ] = @set[id][:balconydoorsill ] if h[:balconydoorsill ]
|
|
754
|
+
v[:balconydoorsillconcave] = @set[id][:balconydoorsillconcave] if h[:balconydoorsillconcave]
|
|
755
|
+
v[:balconydoorsillconvex ] = @set[id][:balconydoorsillconvex ] if h[:balconydoorsillconvex ]
|
|
756
|
+
v[:rimjoist ] = @set[id][:rimjoist ] if h[:rimjoist ]
|
|
757
|
+
v[:rimjoistconcave ] = @set[id][:rimjoist ] if h[:rimjoist ]
|
|
758
|
+
v[:rimjoistconvex ] = @set[id][:rimjoist ] if h[:rimjoist ]
|
|
759
|
+
v[:rimjoistconcave ] = @set[id][:rimjoistconcave ] if h[:rimjoistconcave ]
|
|
760
|
+
v[:rimjoistconvex ] = @set[id][:rimjoistconvex ] if h[:rimjoistconvex ]
|
|
362
761
|
|
|
363
762
|
max = [v[:parapetconcave], v[:parapetconvex]].max
|
|
364
763
|
v[:parapet] = max unless @has[:parapet]
|
|
764
|
+
|
|
765
|
+
max = [v[:roofconcave], v[:roofconvex]].max
|
|
766
|
+
v[:roof] = max unless @has[:roof]
|
|
365
767
|
@val[id] = v
|
|
366
768
|
|
|
367
769
|
true
|
|
368
770
|
end
|
|
369
771
|
|
|
370
772
|
##
|
|
371
|
-
#
|
|
372
|
-
# requires a valid, unique :id.
|
|
773
|
+
# Appends a new PSI set.
|
|
373
774
|
#
|
|
374
|
-
# @param
|
|
775
|
+
# @param [Hash] set a new PSI set
|
|
776
|
+
# @option set [#to_s] :id PSI set identifier
|
|
777
|
+
# @option set [#to_f] :rimjoist intermediate floor-to-wall intersection
|
|
778
|
+
# @option set [#to_f] :rimjoistconcave basilaire variant
|
|
779
|
+
# @option set [#to_f] :rimjoistconvex cantilever variant
|
|
780
|
+
# @option set [#to_f] :parapet roof-to-wall intersection
|
|
781
|
+
# @option set [#to_f] :parapetconcave basilaire variant
|
|
782
|
+
# @option set [#to_f] :parapetconvex typical
|
|
783
|
+
# @option set [#to_f] :roof roof-to-wall intersection
|
|
784
|
+
# @option set [#to_f] :roofconcave basilaire variant
|
|
785
|
+
# @option set [#to_f] :roofconvex typical
|
|
786
|
+
# @option set [#to_f] :fenestration head/sill/jamb interface
|
|
787
|
+
# @option set [#to_f] :head (fenestrated) header interface
|
|
788
|
+
# @option set [#to_f] :headconcave (fenestrated) basilaire variant
|
|
789
|
+
# @option set [#to_f] :headconvex (fenestrated) parapet variant
|
|
790
|
+
# @option set [#to_f] :sill (fenestrated) threshold/sill interface
|
|
791
|
+
# @option set [#to_f] :sillconcave (fenestrated) basilaire variant
|
|
792
|
+
# @option set [#to_f] :sillconvex (fenestrated) cantilever variant
|
|
793
|
+
# @option set [#to_f] :jamb (fenestrated) side jamb interface
|
|
794
|
+
# @option set [#to_f] :jambconcave (fenestrated) interior corner variant
|
|
795
|
+
# @option set [#to_f] :jambconvex (fenestrated) exterior corner variant
|
|
796
|
+
# @option set [#to_f] :door (opaque) head/sill/jamb interface
|
|
797
|
+
# @option set [#to_f] :doorhead (opaque) header interface
|
|
798
|
+
# @option set [#to_f] :doorheadconcave (opaque) basilaire variant
|
|
799
|
+
# @option set [#to_f] :doorheadconvex (opaque) parapet variant
|
|
800
|
+
# @option set [#to_f] :doorsill (opaque) threshold interface
|
|
801
|
+
# @option set [#to_f] :doorsillconcave (opaque) basilaire variant
|
|
802
|
+
# @option set [#to_f] :doorsillconvex (opaque) cantilever variant
|
|
803
|
+
# @option set [#to_f] :doorjamb (opaque) side jamb interface
|
|
804
|
+
# @option set [#to_f] :doorjambconcave (opaque) interior corner variant
|
|
805
|
+
# @option set [#to_f] :doorjambconvex (opaque) exterior corner variant
|
|
806
|
+
# @option set [#to_f] :skylight to roof interface
|
|
807
|
+
# @option set [#to_f] :skylighthead header interface
|
|
808
|
+
# @option set [#to_f] :skylightheadconcave basilaire variant
|
|
809
|
+
# @option set [#to_f] :skylightheadconvex parapet variant
|
|
810
|
+
# @option set [#to_f] :skylightsill sill interface
|
|
811
|
+
# @option set [#to_f] :skylightsillconcave basilaire variant
|
|
812
|
+
# @option set [#to_f] :skylightsillconvex cantilever variant
|
|
813
|
+
# @option set [#to_f] :skylightjamb side jamb interface
|
|
814
|
+
# @option set [#to_f] :skylightjambconcave (opaque) interior corner variant
|
|
815
|
+
# @option set [#to_f] :skylightjambconvex (opaque) parapet variant
|
|
816
|
+
# @option set [#to_f] :spandrel spandrel/other interface
|
|
817
|
+
# @option set [#to_f] :spandrelconcave interior corner variant
|
|
818
|
+
# @option set [#to_f] :spandrelconvex exterior corner variant
|
|
819
|
+
# @option set [#to_f] :corner corner intersection
|
|
820
|
+
# @option set [#to_f] :cornerconcave interior corner variant
|
|
821
|
+
# @option set [#to_f] :cornerconvex exterior corner variant
|
|
822
|
+
# @option set [#to_f] :balcony intermediate floor-balcony intersection
|
|
823
|
+
# @option set [#to_f] :balconyconcave basilaire variant
|
|
824
|
+
# @option set [#to_f] :balconyconvex cantilever variant
|
|
825
|
+
# @option set [#to_f] :balconysill intermediate floor-balcony-fenestration intersection
|
|
826
|
+
# @option set [#to_f] :balconysilloncave basilaire variant
|
|
827
|
+
# @option set [#to_f] :balconysillconvex cantilever variant
|
|
828
|
+
# @option set [#to_f] :balconydoorsill intermediate floor-balcony-door intersection
|
|
829
|
+
# @option set [#to_f] :balconydoorsilloncave basilaire variant
|
|
830
|
+
# @option set [#to_f] :balconydoorsillconvex cantilever variant
|
|
831
|
+
# @option set [#to_f] :party demising surface intersection
|
|
832
|
+
# @option set [#to_f] :partyconcave interior corner or basilaire variant
|
|
833
|
+
# @option set [#to_f] :partyconvex exterior corner or cantilever variant
|
|
834
|
+
# @option set [#to_f] :grade foundation wall or slab-on-grade intersection
|
|
835
|
+
# @option set [#to_f] :gradeconcave cantilever variant
|
|
836
|
+
# @option set [#to_f] :gradeconvex basilaire variant
|
|
837
|
+
# @option set [#to_f] :joint strong ~coplanar joint
|
|
838
|
+
# @option set [#to_f] :transition mild ~coplanar transition
|
|
375
839
|
#
|
|
376
|
-
# @return [Bool]
|
|
377
|
-
# @return [
|
|
840
|
+
# @return [Bool] whether PSI set is successfully appended
|
|
841
|
+
# @return [false] if invalid input (see logs)
|
|
378
842
|
def append(set = {})
|
|
379
843
|
mth = "TBD::#{__callee__}"
|
|
380
844
|
a = false
|
|
845
|
+
s = {}
|
|
846
|
+
return mismatch("set" , set, Hash, mth, DBG, a) unless set.is_a?(Hash)
|
|
847
|
+
return hashkey("set id", set, :id , mth, DBG, a) unless set.key?(:id)
|
|
381
848
|
|
|
382
|
-
|
|
383
|
-
return
|
|
849
|
+
id = trim(set[:id])
|
|
850
|
+
return mismatch("set ID", set[:id], String, mth, ERR, a) if id.empty?
|
|
384
851
|
|
|
385
|
-
|
|
386
|
-
|
|
387
|
-
|
|
852
|
+
if @set.key?(id)
|
|
853
|
+
log(ERR, "'#{id}': existing PSI set (#{mth})")
|
|
854
|
+
return a
|
|
855
|
+
end
|
|
388
856
|
|
|
389
|
-
s = {}
|
|
390
857
|
# Most PSI types have concave and convex variants, depending on the polar
|
|
391
858
|
# position of deratable surfaces about an edge-as-thermal-bridge. One
|
|
392
859
|
# exception is :fenestration, which TBD later breaks down into :head,
|
|
@@ -394,64 +861,97 @@ module TBD
|
|
|
394
861
|
# type that is not autoassigned to an edge (i.e., only via a TBD JSON
|
|
395
862
|
# input file). Finally, transitions are autoassigned by TBD when an edge
|
|
396
863
|
# is "flat", i.e, no noticeable polar angle difference between surfaces.
|
|
397
|
-
s[:rimjoist
|
|
398
|
-
s[:rimjoistconcave] = set[:rimjoistconcave] if set.key?(:rimjoistconcave)
|
|
399
|
-
s[:rimjoistconvex
|
|
400
|
-
s[:parapet
|
|
401
|
-
s[:parapetconcave
|
|
402
|
-
s[:parapetconvex
|
|
403
|
-
s[:
|
|
404
|
-
s[:
|
|
405
|
-
s[:
|
|
406
|
-
s[:
|
|
407
|
-
s[:
|
|
408
|
-
s[:
|
|
409
|
-
s[:
|
|
410
|
-
s[:
|
|
411
|
-
s[:
|
|
412
|
-
s[:
|
|
413
|
-
s[:
|
|
414
|
-
s[:
|
|
415
|
-
s[:
|
|
416
|
-
s[:
|
|
417
|
-
s[:
|
|
418
|
-
s[:
|
|
419
|
-
s[:
|
|
420
|
-
s[:
|
|
421
|
-
s[:
|
|
422
|
-
s[:
|
|
423
|
-
s[:
|
|
424
|
-
s[:
|
|
425
|
-
s[:
|
|
426
|
-
s[:
|
|
427
|
-
|
|
428
|
-
s[:
|
|
429
|
-
s[:
|
|
430
|
-
|
|
431
|
-
|
|
432
|
-
|
|
864
|
+
s[:rimjoist ] = set[:rimjoist ] if set.key?(:rimjoist)
|
|
865
|
+
s[:rimjoistconcave ] = set[:rimjoistconcave ] if set.key?(:rimjoistconcave)
|
|
866
|
+
s[:rimjoistconvex ] = set[:rimjoistconvex ] if set.key?(:rimjoistconvex)
|
|
867
|
+
s[:parapet ] = set[:parapet ] if set.key?(:parapet)
|
|
868
|
+
s[:parapetconcave ] = set[:parapetconcave ] if set.key?(:parapetconcave)
|
|
869
|
+
s[:parapetconvex ] = set[:parapetconvex ] if set.key?(:parapetconvex)
|
|
870
|
+
s[:roof ] = set[:roof ] if set.key?(:roof)
|
|
871
|
+
s[:roofconcave ] = set[:roofconcave ] if set.key?(:roofconcave)
|
|
872
|
+
s[:roofconvex ] = set[:roofconvex ] if set.key?(:roofconvex)
|
|
873
|
+
s[:fenestration ] = set[:fenestration ] if set.key?(:fenestration)
|
|
874
|
+
s[:head ] = set[:head ] if set.key?(:head)
|
|
875
|
+
s[:headconcave ] = set[:headconcave ] if set.key?(:headconcave)
|
|
876
|
+
s[:headconvex ] = set[:headconvex ] if set.key?(:headconvex)
|
|
877
|
+
s[:sill ] = set[:sill ] if set.key?(:sill)
|
|
878
|
+
s[:sillconcave ] = set[:sillconcave ] if set.key?(:sillconcave)
|
|
879
|
+
s[:sillconvex ] = set[:sillconvex ] if set.key?(:sillconvex)
|
|
880
|
+
s[:jamb ] = set[:jamb ] if set.key?(:jamb)
|
|
881
|
+
s[:jambconcave ] = set[:jambconcave ] if set.key?(:jambconcave)
|
|
882
|
+
s[:jambconvex ] = set[:jambconvex ] if set.key?(:jambconvex)
|
|
883
|
+
s[:door ] = set[:door ] if set.key?(:door)
|
|
884
|
+
s[:doorhead ] = set[:doorhead ] if set.key?(:doorhead)
|
|
885
|
+
s[:doorheadconcave ] = set[:doorheadconcave ] if set.key?(:doorheadconcave)
|
|
886
|
+
s[:doorheadconvex ] = set[:doorheadconvex ] if set.key?(:doorheadconvex)
|
|
887
|
+
s[:doorsill ] = set[:doorsill ] if set.key?(:doorsill)
|
|
888
|
+
s[:doorsillconcave ] = set[:doorsillconcave ] if set.key?(:doorsillconcave)
|
|
889
|
+
s[:doorsillconvex ] = set[:doorsillconvex ] if set.key?(:doorsillconvex)
|
|
890
|
+
s[:doorjamb ] = set[:doorjamb ] if set.key?(:doorjamb)
|
|
891
|
+
s[:doorjambconcave ] = set[:doorjambconcave ] if set.key?(:doorjambconcave)
|
|
892
|
+
s[:doorjambconvex ] = set[:doorjambconvex ] if set.key?(:doorjambconvex)
|
|
893
|
+
s[:skylight ] = set[:skylight ] if set.key?(:skylight)
|
|
894
|
+
s[:skylighthead ] = set[:skylighthead ] if set.key?(:skylighthead)
|
|
895
|
+
s[:skylightheadconcave ] = set[:skylightheadconcave ] if set.key?(:skylightheadconcave)
|
|
896
|
+
s[:skylightheadconvex ] = set[:skylightheadconvex ] if set.key?(:skylightheadconvex)
|
|
897
|
+
s[:skylightsill ] = set[:skylightsill ] if set.key?(:skylightsill)
|
|
898
|
+
s[:skylightsillconcave ] = set[:skylightsillconcave ] if set.key?(:skylightsillconcave)
|
|
899
|
+
s[:skylightsillconvex ] = set[:skylightsillconvex ] if set.key?(:skylightsillconvex)
|
|
900
|
+
s[:skylightjamb ] = set[:skylightjamb ] if set.key?(:skylightjamb)
|
|
901
|
+
s[:skylightjambconcave ] = set[:skylightjambconcave ] if set.key?(:skylightjambconcave)
|
|
902
|
+
s[:skylightjambconvex ] = set[:skylightjambconvex ] if set.key?(:skylightjambconvex)
|
|
903
|
+
s[:spandrel ] = set[:spandrel ] if set.key?(:spandrel)
|
|
904
|
+
s[:spandrelconcave ] = set[:spandrelconcave ] if set.key?(:spandrelconcave)
|
|
905
|
+
s[:spandrelconvex ] = set[:spandrelconvex ] if set.key?(:spandrelconvex)
|
|
906
|
+
s[:corner ] = set[:corner ] if set.key?(:corner)
|
|
907
|
+
s[:cornerconcave ] = set[:cornerconcave ] if set.key?(:cornerconcave)
|
|
908
|
+
s[:cornerconvex ] = set[:cornerconvex ] if set.key?(:cornerconvex)
|
|
909
|
+
s[:balcony ] = set[:balcony ] if set.key?(:balcony)
|
|
910
|
+
s[:balconyconcave ] = set[:balconyconcave ] if set.key?(:balconyconcave)
|
|
911
|
+
s[:balconyconvex ] = set[:balconyconvex ] if set.key?(:balconyconvex)
|
|
912
|
+
s[:balconysill ] = set[:balconysill ] if set.key?(:balconysill)
|
|
913
|
+
s[:balconysillconcave ] = set[:balconysillconcave ] if set.key?(:balconysillconcave)
|
|
914
|
+
s[:balconysillconvex ] = set[:balconysillconvex ] if set.key?(:balconysillconvex)
|
|
915
|
+
s[:balconydoorsill ] = set[:balconydoorsill ] if set.key?(:balconydoorsill)
|
|
916
|
+
s[:balconydoorsillconcave] = set[:balconydoorsillconcave] if set.key?(:balconydoorsillconcave)
|
|
917
|
+
s[:balconydoorsillconvex ] = set[:balconydoorsillconvex ] if set.key?(:balconydoorsillconvex)
|
|
918
|
+
s[:party ] = set[:party ] if set.key?(:party)
|
|
919
|
+
s[:partyconcave ] = set[:partyconcave ] if set.key?(:partyconcave)
|
|
920
|
+
s[:partyconvex ] = set[:partyconvex ] if set.key?(:partyconvex)
|
|
921
|
+
s[:grade ] = set[:grade ] if set.key?(:grade)
|
|
922
|
+
s[:gradeconcave ] = set[:gradeconcave ] if set.key?(:gradeconcave)
|
|
923
|
+
s[:gradeconvex ] = set[:gradeconvex ] if set.key?(:gradeconvex)
|
|
924
|
+
s[:joint ] = set[:joint ] if set.key?(:joint)
|
|
925
|
+
s[:transition ] = set[:transition ] if set.key?(:transition)
|
|
926
|
+
|
|
927
|
+
s[:joint ] = 0.000 unless set.key?(:joint)
|
|
928
|
+
s[:transition ] = 0.000 unless set.key?(:transition)
|
|
929
|
+
|
|
930
|
+
@set[id] = s
|
|
931
|
+
self.gen(id)
|
|
433
932
|
|
|
434
933
|
true
|
|
435
934
|
end
|
|
436
935
|
|
|
437
936
|
##
|
|
438
|
-
#
|
|
439
|
-
# of true/false (values) for any admissible PSI type (keys), and val: a
|
|
440
|
-
# of PSI-values for any admissible PSI type (
|
|
937
|
+
# Returns PSI set shorthands. The return Hash holds 2 keys, has: a Hash
|
|
938
|
+
# of true/false (values) for any admissible PSI type (keys), and val: a
|
|
939
|
+
# Hash of PSI-factors (values) for any admissible PSI type (keys).
|
|
940
|
+
# PSI-factors default to 0 W/K per linear meter if missing from set.
|
|
441
941
|
#
|
|
442
|
-
# @param id [
|
|
942
|
+
# @param id [#to_s] PSI set identifier
|
|
943
|
+
# @example intermediate floor slab intersection
|
|
944
|
+
# shorthands("A901")
|
|
443
945
|
#
|
|
444
|
-
# @return [Hash] has: Hash
|
|
445
|
-
# @return [Hash] has: empty Hash, val: empty Hash (if invalid/missing set)
|
|
946
|
+
# @return [Hash] has: Hash (Bool), val: Hash (PSI factors) see logs if empty
|
|
446
947
|
def shorthands(id = "")
|
|
447
948
|
mth = "TBD::#{__callee__}"
|
|
448
|
-
cl = String
|
|
449
949
|
sh = { has: {}, val: {} }
|
|
450
|
-
|
|
451
|
-
return
|
|
452
|
-
return
|
|
453
|
-
return
|
|
454
|
-
return
|
|
950
|
+
id = trim(id)
|
|
951
|
+
return mismatch("set ID", id, String, mth, ERR, a) if id.empty?
|
|
952
|
+
return hashkey(id, @set , id, mth, ERR, sh) unless @set.key?(id)
|
|
953
|
+
return hashkey(id, @has , id, mth, ERR, sh) unless @has.key?(id)
|
|
954
|
+
return hashkey(id, @val , id, mth, ERR, sh) unless @val.key?(id)
|
|
455
955
|
|
|
456
956
|
sh[:has] = @has[id]
|
|
457
957
|
sh[:val] = @val[id]
|
|
@@ -460,81 +960,98 @@ module TBD
|
|
|
460
960
|
end
|
|
461
961
|
|
|
462
962
|
##
|
|
463
|
-
#
|
|
963
|
+
# Validates whether a given PSI set has a complete list of PSI type:values.
|
|
464
964
|
#
|
|
465
|
-
# @param id [
|
|
965
|
+
# @param id [#to_s] PSI set identifier
|
|
466
966
|
#
|
|
467
|
-
# @return [Bool]
|
|
468
|
-
# @return [
|
|
967
|
+
# @return [Bool] whether provided PSI set is held in memory and is complete
|
|
968
|
+
# @return [false] if invalid input (see logs)
|
|
469
969
|
def complete?(id = "")
|
|
470
970
|
mth = "TBD::#{__callee__}"
|
|
471
971
|
a = false
|
|
472
|
-
|
|
473
|
-
return
|
|
474
|
-
return
|
|
475
|
-
return
|
|
476
|
-
return
|
|
972
|
+
id = trim(id)
|
|
973
|
+
return mismatch("set ID", id, String, mth, ERR, a) if id.empty?
|
|
974
|
+
return hashkey(id, @set , id, mth, ERR, a) unless @set.key?(id)
|
|
975
|
+
return hashkey(id, @has , id, mth, ERR, a) unless @has.key?(id)
|
|
976
|
+
return hashkey(id, @val , id, mth, ERR, a) unless @val.key?(id)
|
|
477
977
|
|
|
478
978
|
holes = []
|
|
479
|
-
holes << :head
|
|
480
|
-
holes << :sill
|
|
481
|
-
holes << :jamb
|
|
979
|
+
holes << :head if @has[id][:head ]
|
|
980
|
+
holes << :sill if @has[id][:sill ]
|
|
981
|
+
holes << :jamb if @has[id][:jamb ]
|
|
482
982
|
ok = holes.size == 3
|
|
483
|
-
ok = true
|
|
484
|
-
return false
|
|
983
|
+
ok = true if @has[id][:fenestration ]
|
|
984
|
+
return false unless ok
|
|
485
985
|
|
|
486
986
|
corners = []
|
|
487
|
-
corners << :concave
|
|
488
|
-
corners << :convex
|
|
987
|
+
corners << :concave if @has[id][:cornerconcave ]
|
|
988
|
+
corners << :convex if @has[id][:cornerconvex ]
|
|
489
989
|
ok = corners.size == 2
|
|
490
|
-
ok = true
|
|
491
|
-
return false
|
|
990
|
+
ok = true if @has[id][:corner ]
|
|
991
|
+
return false unless ok
|
|
492
992
|
|
|
493
993
|
parapets = []
|
|
494
|
-
|
|
495
|
-
parapets << :
|
|
496
|
-
|
|
497
|
-
|
|
498
|
-
|
|
499
|
-
|
|
500
|
-
|
|
501
|
-
|
|
502
|
-
return false
|
|
994
|
+
roofs = []
|
|
995
|
+
parapets << :concave if @has[id][:parapetconcave]
|
|
996
|
+
parapets << :convex if @has[id][:parapetconvex ]
|
|
997
|
+
roofs << :concave if @has[id][:roofconcave ]
|
|
998
|
+
parapets << :convex if @has[id][:roofconvex ]
|
|
999
|
+
ok = parapets.size == 2 || roofs.size == 2
|
|
1000
|
+
ok = true if @has[id][:parapet ]
|
|
1001
|
+
ok = true if @has[id][:roof ]
|
|
1002
|
+
return false unless ok
|
|
1003
|
+
return false unless @has[id][:party ]
|
|
1004
|
+
return false unless @has[id][:grade ]
|
|
1005
|
+
return false unless @has[id][:balcony ]
|
|
1006
|
+
return false unless @has[id][:rimjoist ]
|
|
503
1007
|
|
|
504
1008
|
ok
|
|
505
1009
|
end
|
|
506
1010
|
|
|
507
1011
|
##
|
|
508
|
-
#
|
|
1012
|
+
# Returns safe PSI type if missing from PSI set (based on inheritance).
|
|
509
1013
|
#
|
|
510
|
-
# @param id [
|
|
511
|
-
# @param type [
|
|
1014
|
+
# @param id [#to_s] PSI set identifier
|
|
1015
|
+
# @param type [#to_sym] PSI type
|
|
1016
|
+
# @example intermediate floor slab intersection
|
|
1017
|
+
# safe("90.1.22|wood.fr|unmitigated", :rimjoistconcave)
|
|
512
1018
|
#
|
|
513
1019
|
# @return [Symbol] safe PSI type
|
|
514
|
-
# @return [
|
|
1020
|
+
# @return [nil] if invalid inputs (see logs)
|
|
515
1021
|
def safe(id = "", type = nil)
|
|
516
1022
|
mth = "TBD::#{__callee__}"
|
|
517
|
-
|
|
518
|
-
|
|
1023
|
+
id = trim(id)
|
|
1024
|
+
ck1 = id.empty?
|
|
1025
|
+
ck2 = type.respond_to?(:to_sym)
|
|
1026
|
+
return mismatch("set ID", id, String, mth) if ck1
|
|
1027
|
+
return mismatch("type", type, Symbol, mth) unless ck2
|
|
1028
|
+
return hashkey(id, @set, id, mth, ERR) unless @set.key?(id)
|
|
1029
|
+
return hashkey(id, @has, id, mth, ERR) unless @has.key?(id)
|
|
519
1030
|
|
|
520
|
-
|
|
521
|
-
return TBD.mismatch("type", type, cl2, mth, ERR) unless type.is_a?(cl2)
|
|
522
|
-
return TBD.hashkey(id, @set, id, mth, ERR) unless @set.key?(id)
|
|
523
|
-
return TBD.hashkey(id, @has, id, mth, ERR) unless @has.key?(id)
|
|
1031
|
+
safer = type.to_sym
|
|
524
1032
|
|
|
525
|
-
safer
|
|
1033
|
+
unless @has[id][safer]
|
|
1034
|
+
concave = safer.to_s.include?("concave")
|
|
1035
|
+
convex = safer.to_s.include?("convex")
|
|
1036
|
+
safer = safer.to_s.chomp("concave").to_sym if concave
|
|
1037
|
+
safer = safer.to_s.chomp("convex").to_sym if convex
|
|
1038
|
+
end
|
|
526
1039
|
|
|
527
1040
|
unless @has[id][safer]
|
|
528
|
-
|
|
529
|
-
|
|
530
|
-
safer =
|
|
531
|
-
safer =
|
|
532
|
-
|
|
533
|
-
|
|
534
|
-
|
|
535
|
-
|
|
536
|
-
|
|
537
|
-
|
|
1041
|
+
safer = :fenestration if safer == :head
|
|
1042
|
+
safer = :fenestration if safer == :sill
|
|
1043
|
+
safer = :fenestration if safer == :jamb
|
|
1044
|
+
safer = :door if safer == :doorhead
|
|
1045
|
+
safer = :door if safer == :doorsill
|
|
1046
|
+
safer = :door if safer == :doorjamb
|
|
1047
|
+
safer = :skylight if safer == :skylighthead
|
|
1048
|
+
safer = :skylight if safer == :skylightsill
|
|
1049
|
+
safer = :skylight if safer == :skylightjamb
|
|
1050
|
+
end
|
|
1051
|
+
|
|
1052
|
+
unless @has[id][safer]
|
|
1053
|
+
safer = :fenestration if safer == :skylight
|
|
1054
|
+
safer = :fenestration if safer == :door
|
|
538
1055
|
end
|
|
539
1056
|
|
|
540
1057
|
return safer if @has[id][safer]
|
|
@@ -544,30 +1061,41 @@ module TBD
|
|
|
544
1061
|
end
|
|
545
1062
|
|
|
546
1063
|
##
|
|
547
|
-
#
|
|
548
|
-
# and retrieved corresponding Topolys model surface/edge
|
|
549
|
-
# inputs allow customization of default assumptions and
|
|
550
|
-
# If successful, "edges" (input) may inherit additional
|
|
551
|
-
# edge-specific PSI set (defined in TBD JSON file),
|
|
552
|
-
# (e.g. "corner", defined in TBD JSON file),
|
|
553
|
-
# from TBD JSON file).
|
|
1064
|
+
# Processes TBD JSON inputs, after TBD has preprocessed OpenStudio model
|
|
1065
|
+
# variables and retrieved corresponding Topolys model surface/edge
|
|
1066
|
+
# properties. TBD user inputs allow customization of default assumptions and
|
|
1067
|
+
# inferred values. If successful, "edges" (input) may inherit additional
|
|
1068
|
+
# properties, e.g.: edge-specific PSI set (defined in TBD JSON file),
|
|
1069
|
+
# edge-specific PSI type (e.g. "corner", defined in TBD JSON file),
|
|
1070
|
+
# project-wide PSI set (if absent from TBD JSON file).
|
|
554
1071
|
#
|
|
555
|
-
# @param
|
|
556
|
-
# @
|
|
557
|
-
# @
|
|
1072
|
+
# @param [Hash] s TBD surfaces (keys: Openstudio surface names)
|
|
1073
|
+
# @option s [Hash] :windows TBD surface-specific windows e.g. s[][:windows]
|
|
1074
|
+
# @option s [Hash] :doors TBD surface-specific doors
|
|
1075
|
+
# @option s [Hash] :skylights TBD surface-specific skylights
|
|
1076
|
+
# @option s [OpenStudio::Model::BuildingStory] :story OpenStudio story
|
|
1077
|
+
# @option s ["Wall", "RoofCeiling", "Floor"] :stype OpenStudio surface type
|
|
1078
|
+
# @option s [OpenStudio::Model::Space] :space OpenStudio space
|
|
1079
|
+
# @param [Hash] e TBD edges (keys: Topolys edge identifiers)
|
|
1080
|
+
# @option e [Hash] :surfaces linked TBD surfaces e.g. e[][:surfaces]
|
|
1081
|
+
# @option e [#to_f] :length edge length in m
|
|
1082
|
+
# @option e [Topolys::Point3D] :v0 origin vertex
|
|
1083
|
+
# @option e [Topolys::Point3D] :v1 terminal vertex
|
|
1084
|
+
# @param [Hash] argh TBD arguments
|
|
1085
|
+
# @option argh [#to_s] :option selected PSI set
|
|
1086
|
+
# @option argh [#to_s] :io_path tbd.json input file path
|
|
1087
|
+
# @option argh [#to_s] :schema_path TBD JSON schema file path
|
|
558
1088
|
#
|
|
559
|
-
# @return [Hash] io:
|
|
560
|
-
# @return [Hash] io: empty Hash if invalid input
|
|
1089
|
+
# @return [Hash] io: (Hash), psi:/khi: enriched sets (see logs if empty)
|
|
561
1090
|
def inputs(s = {}, e = {}, argh = {})
|
|
562
1091
|
mth = "TBD::#{__callee__}"
|
|
563
1092
|
opt = :option
|
|
564
1093
|
ipt = { io: {}, psi: PSI.new, khi: KHI.new }
|
|
565
1094
|
io = {}
|
|
566
|
-
|
|
567
|
-
return mismatch("
|
|
568
|
-
return mismatch("
|
|
569
|
-
return
|
|
570
|
-
return hashkey("argh", argh, opt, mth, DBG, ipt) unless argh.key?(opt)
|
|
1095
|
+
return mismatch("s" , s , Hash, mth, DBG, ipt) unless s.is_a?(Hash)
|
|
1096
|
+
return mismatch("e" , e , Hash, mth, DBG, ipt) unless e.is_a?(Hash)
|
|
1097
|
+
return mismatch("argh", argh, Hash, mth, DBG, ipt) unless argh.is_a?(Hash)
|
|
1098
|
+
return hashkey("argh" , argh, opt , mth, DBG, ipt) unless argh.key?(opt)
|
|
571
1099
|
|
|
572
1100
|
argh[:io_path ] = nil unless argh.key?(:io_path)
|
|
573
1101
|
argh[:schema_path] = nil unless argh.key?(:schema_path)
|
|
@@ -580,41 +1108,43 @@ module TBD
|
|
|
580
1108
|
io = pth
|
|
581
1109
|
else
|
|
582
1110
|
return empty("JSON file", mth, FTL, ipt) unless File.size?(pth)
|
|
1111
|
+
|
|
583
1112
|
io = File.read(pth)
|
|
584
1113
|
io = JSON.parse(io, symbolize_names: true)
|
|
585
1114
|
return mismatch("io", io, Hash, mth, FTL, ipt) unless io.is_a?(Hash)
|
|
586
1115
|
end
|
|
587
1116
|
|
|
588
1117
|
# Schema validation is not yet supported in the OpenStudio Application.
|
|
589
|
-
#
|
|
590
|
-
# online linter, prior to using TBD. The following checks focus on
|
|
591
|
-
# - ignoring bad JSON input otherwise caught via JSON validation.
|
|
1118
|
+
# It is nonetheless recommended that users rely on the json-schema gem,
|
|
1119
|
+
# or an online linter, prior to using TBD. The following checks focus on
|
|
1120
|
+
# content - ignoring bad JSON input otherwise caught via JSON validation.
|
|
592
1121
|
#
|
|
593
1122
|
# A side note: JSON validation relies on case-senitive string comparisons
|
|
594
1123
|
# (e.g. OpenStudio space or surface names, vs corresponding TBD JSON
|
|
595
|
-
# identifiers). So "Space-1" doesn't match "SPACE-1"
|
|
1124
|
+
# identifiers). So "Space-1" doesn't match "SPACE-1" ... head's up!
|
|
596
1125
|
if sch
|
|
597
1126
|
require "json-schema"
|
|
1127
|
+
return invalid("JSON schema", mth, 3, FTL, ipt) unless File.exist?(sch)
|
|
1128
|
+
return empty("JSON schema" , mth, FTL, ipt) if File.zero?(sch)
|
|
598
1129
|
|
|
599
|
-
return invalid("JSON schema", mth, 0, FTL, ipt) unless File.exist?(sch)
|
|
600
|
-
return empty("JSON schema", mth, FTL, ipt) if File.zero?(sch)
|
|
601
1130
|
schema = File.read(sch)
|
|
602
1131
|
schema = JSON.parse(schema, symbolize_names: true)
|
|
603
1132
|
valid = JSON::Validator.validate!(schema, io)
|
|
604
|
-
return invalid("JSON schema validation", mth,
|
|
1133
|
+
return invalid("JSON schema validation", mth, 3, FTL, ipt) unless valid
|
|
605
1134
|
end
|
|
606
1135
|
|
|
607
1136
|
# Append JSON entries to library of linear & point thermal bridges.
|
|
608
|
-
io[:psis].each { |psi| ipt[:psi].append(psi) }
|
|
609
|
-
io[:khis].each { |khi| ipt[:khi].append(khi) }
|
|
1137
|
+
io[:psis].each { |psi| ipt[:psi].append(psi) } if io.key?(:psis)
|
|
1138
|
+
io[:khis].each { |khi| ipt[:khi].append(khi) } if io.key?(:khis)
|
|
610
1139
|
|
|
611
1140
|
# JSON-defined or user-selected, building PSI set must be complete/valid.
|
|
612
1141
|
io[:building] = { psi: argh[opt] } unless io.key?(:building)
|
|
613
1142
|
bdg = io[:building]
|
|
614
|
-
ok
|
|
615
|
-
return hashkey("Building PSI", bdg, :psi, mth, FTL, ipt)
|
|
1143
|
+
ok = bdg.key?(:psi)
|
|
1144
|
+
return hashkey("Building PSI", bdg, :psi, mth, FTL, ipt) unless ok
|
|
1145
|
+
|
|
616
1146
|
ok = ipt[:psi].complete?(bdg[:psi])
|
|
617
|
-
return invalid("Complete building PSI", mth,
|
|
1147
|
+
return invalid("Complete building PSI", mth, 3, FTL, ipt) unless ok
|
|
618
1148
|
|
|
619
1149
|
# Validate remaining (optional) JSON entries.
|
|
620
1150
|
[:stories, :spacetypes, :spaces].each do |types|
|
|
@@ -625,14 +1155,16 @@ module TBD
|
|
|
625
1155
|
if io.key?(types)
|
|
626
1156
|
io[types].each do |type|
|
|
627
1157
|
next unless type.key?(:psi)
|
|
628
|
-
next unless type.key?(:id)
|
|
1158
|
+
next unless type.key?(:id )
|
|
1159
|
+
|
|
629
1160
|
s1 = "JSON/OSM '#{type[:id]}' (#{mth})"
|
|
630
1161
|
s2 = "JSON/PSI '#{type[:id]}' set (#{mth})"
|
|
631
1162
|
match = false
|
|
632
1163
|
|
|
633
|
-
s.values.each do |props|
|
|
634
|
-
break
|
|
1164
|
+
s.values.each do |props| # TBD surface linked to type?
|
|
1165
|
+
break if match
|
|
635
1166
|
next unless props.key?(key)
|
|
1167
|
+
|
|
636
1168
|
match = type[:id] == props[key].nameString
|
|
637
1169
|
end
|
|
638
1170
|
|
|
@@ -645,6 +1177,7 @@ module TBD
|
|
|
645
1177
|
if io.key?(:surfaces)
|
|
646
1178
|
io[:surfaces].each do |surface|
|
|
647
1179
|
next unless surface.key?(:id)
|
|
1180
|
+
|
|
648
1181
|
s1 = "JSON/OSM surface '#{surface[:id]}' (#{mth})"
|
|
649
1182
|
log(ERR, s1) unless s.key?(surface[:id])
|
|
650
1183
|
|
|
@@ -657,6 +1190,7 @@ module TBD
|
|
|
657
1190
|
if surface.key?(:khis)
|
|
658
1191
|
surface[:khis].each do |khi|
|
|
659
1192
|
next unless khi.key?(:id)
|
|
1193
|
+
|
|
660
1194
|
s3 = "JSON/KHI surface '#{surface[:id]}' '#{khi[:id]}' (#{mth})"
|
|
661
1195
|
log(ERR, s3) unless ipt[:khi].point.key?(khi[:id])
|
|
662
1196
|
end
|
|
@@ -668,6 +1202,7 @@ module TBD
|
|
|
668
1202
|
io[:subsurfaces].each do |sub|
|
|
669
1203
|
next unless sub.key?(:id)
|
|
670
1204
|
next unless sub.key?(:usi)
|
|
1205
|
+
|
|
671
1206
|
match = false
|
|
672
1207
|
|
|
673
1208
|
s.each do |id, surface|
|
|
@@ -677,6 +1212,7 @@ module TBD
|
|
|
677
1212
|
if surface.key?(holes)
|
|
678
1213
|
surface[holes].keys.each do |id|
|
|
679
1214
|
break if match
|
|
1215
|
+
|
|
680
1216
|
match = sub[:id] == id
|
|
681
1217
|
end
|
|
682
1218
|
end
|
|
@@ -691,30 +1227,33 @@ module TBD
|
|
|
691
1227
|
io[:edges].each do |edge|
|
|
692
1228
|
next unless edge.key?(:type)
|
|
693
1229
|
next unless edge.key?(:surfaces)
|
|
694
|
-
|
|
695
|
-
|
|
696
|
-
|
|
1230
|
+
|
|
1231
|
+
surfaces = edge[:surfaces]
|
|
1232
|
+
type = edge[:type].to_sym
|
|
1233
|
+
safer = ipt[:psi].safe(bdg[:psi], type) # fallback
|
|
697
1234
|
log(ERR, "Skipping invalid edge PSI '#{type}' (#{mth})") unless safer
|
|
698
1235
|
next unless safer
|
|
1236
|
+
|
|
699
1237
|
valid = true
|
|
700
1238
|
|
|
701
|
-
surfaces.each do |surface|
|
|
702
|
-
e.values.each do |ee|
|
|
703
|
-
break unless valid
|
|
704
|
-
next if ee.key?(:io_type)
|
|
1239
|
+
surfaces.each do |surface| # TBD edge's surfaces on file
|
|
1240
|
+
e.values.each do |ee| # TBD edges in memory
|
|
1241
|
+
break unless valid # if previous anomaly detected
|
|
1242
|
+
next if ee.key?(:io_type) # validated from previous loop
|
|
705
1243
|
next unless ee.key?(:surfaces)
|
|
1244
|
+
|
|
706
1245
|
surfs = ee[:surfaces]
|
|
707
1246
|
next unless surfs.key?(surface)
|
|
708
1247
|
|
|
709
1248
|
# An edge on file is valid if ALL of its listed surfaces together
|
|
710
|
-
# connect at least
|
|
711
|
-
# Each of the latter may connect e.g.
|
|
712
|
-
# but the list of surfaces on file may be shorter, e.g. only
|
|
1249
|
+
# connect at least 1 or more TBD/Topolys model edges in memory.
|
|
1250
|
+
# Each of the latter may connect e.g. 3 TBD/Topolys surfaces,
|
|
1251
|
+
# but the list of surfaces on file may be shorter, e.g. only 2.
|
|
713
1252
|
match = true
|
|
714
1253
|
surfaces.each { |id| match = false unless surfs.key?(id) }
|
|
715
1254
|
next unless match
|
|
716
1255
|
|
|
717
|
-
if edge.key?(:length)
|
|
1256
|
+
if edge.key?(:length) # optional
|
|
718
1257
|
next unless (ee[:length] - edge[:length]).abs < TOL
|
|
719
1258
|
end
|
|
720
1259
|
|
|
@@ -724,7 +1263,6 @@ module TBD
|
|
|
724
1263
|
|
|
725
1264
|
unless edge.key?(:v0x) && edge.key?(:v0y) && edge.key?(:v0z) &&
|
|
726
1265
|
edge.key?(:v1x) && edge.key?(:v1y) && edge.key?(:v1z)
|
|
727
|
-
|
|
728
1266
|
log(ERR, "Mismatch '#{surface}' edge vertices (#{mth})")
|
|
729
1267
|
valid = false
|
|
730
1268
|
next
|
|
@@ -743,17 +1281,17 @@ module TBD
|
|
|
743
1281
|
next unless matches?(e1, e2)
|
|
744
1282
|
end
|
|
745
1283
|
|
|
746
|
-
if edge.key?(:psi)
|
|
1284
|
+
if edge.key?(:psi) # optional
|
|
747
1285
|
set = edge[:psi]
|
|
748
1286
|
|
|
749
1287
|
if ipt[:psi].set.key?(set)
|
|
750
1288
|
saferr = ipt[:psi].safe(set, type)
|
|
751
|
-
ee[:io_set ] = set
|
|
752
|
-
ee[:io_type] = type
|
|
753
|
-
log(ERR, "Invalid
|
|
754
|
-
valid = false
|
|
1289
|
+
ee[:io_set ] = set if saferr
|
|
1290
|
+
ee[:io_type] = type if saferr
|
|
1291
|
+
log(ERR, "Invalid #{set}: #{type} (#{mth})") unless saferr
|
|
1292
|
+
valid = false unless saferr
|
|
755
1293
|
else
|
|
756
|
-
log(ERR, "Missing edge PSI
|
|
1294
|
+
log(ERR, "Missing edge PSI #{set} (#{mth})")
|
|
757
1295
|
valid = false
|
|
758
1296
|
end
|
|
759
1297
|
else
|
|
@@ -767,10 +1305,12 @@ module TBD
|
|
|
767
1305
|
# No (optional) user-defined TBD JSON input file. In such cases, provided
|
|
768
1306
|
# argh[:option] must refer to a valid PSI set. If valid, all edges inherit
|
|
769
1307
|
# a default PSI set (without KHI entries).
|
|
770
|
-
|
|
771
|
-
|
|
772
|
-
|
|
773
|
-
|
|
1308
|
+
msg = "Incomplete building PSI set '#{argh[opt]}' (#{mth})"
|
|
1309
|
+
ok = ipt[:psi].complete?(argh[opt])
|
|
1310
|
+
|
|
1311
|
+
io[:building] = { psi: argh[opt] } if ok
|
|
1312
|
+
log(FTL, msg) unless ok
|
|
1313
|
+
return ipt unless ok
|
|
774
1314
|
end
|
|
775
1315
|
|
|
776
1316
|
ipt[:io] = io
|
|
@@ -779,86 +1319,83 @@ module TBD
|
|
|
779
1319
|
end
|
|
780
1320
|
|
|
781
1321
|
##
|
|
782
|
-
# Thermally
|
|
1322
|
+
# Thermally derates insulating material within construction.
|
|
783
1323
|
#
|
|
784
|
-
# @param
|
|
785
|
-
# @param
|
|
786
|
-
# @
|
|
1324
|
+
# @param id [#to_s] surface identifier
|
|
1325
|
+
# @param [Hash] s TBD surface parameters
|
|
1326
|
+
# @option s [#to_f] :heatloss heat loss from major thermal bridging, in W/K
|
|
1327
|
+
# @option s [#to_f] :net surface net area, in m2
|
|
1328
|
+
# @option s [:massless, :standard] :ltype indexed layer type
|
|
1329
|
+
# @option s [#to_i] :index deratable construction layer index
|
|
1330
|
+
# @option s [#to_f] :r deratable layer Rsi-factor, in m2•K/W
|
|
787
1331
|
# @param lc [OpenStudio::Model::LayeredConstruction] a layered construction
|
|
788
1332
|
#
|
|
789
1333
|
# @return [OpenStudio::Model::Material] derated (cloned) material
|
|
790
|
-
# @return [
|
|
791
|
-
def derate(
|
|
1334
|
+
# @return [nil] if invalid input (see logs)
|
|
1335
|
+
def derate(id = "", s = {}, lc = nil)
|
|
792
1336
|
mth = "TBD::#{__callee__}"
|
|
793
1337
|
m = nil
|
|
794
|
-
|
|
795
|
-
|
|
796
|
-
|
|
797
|
-
|
|
798
|
-
|
|
799
|
-
|
|
800
|
-
|
|
801
|
-
|
|
802
|
-
|
|
803
|
-
|
|
804
|
-
|
|
805
|
-
|
|
806
|
-
|
|
807
|
-
|
|
808
|
-
|
|
809
|
-
|
|
810
|
-
|
|
811
|
-
|
|
812
|
-
|
|
813
|
-
|
|
814
|
-
|
|
815
|
-
|
|
816
|
-
|
|
817
|
-
|
|
818
|
-
|
|
819
|
-
|
|
820
|
-
|
|
821
|
-
|
|
822
|
-
|
|
823
|
-
|
|
824
|
-
|
|
825
|
-
|
|
826
|
-
|
|
827
|
-
|
|
828
|
-
|
|
829
|
-
|
|
830
|
-
|
|
831
|
-
|
|
832
|
-
|
|
833
|
-
|
|
834
|
-
log(WRN, "Won't derate '#{id}': already derated (#{mth})") if derated
|
|
835
|
-
return m if derated
|
|
836
|
-
|
|
837
|
-
index = s[:index]
|
|
838
|
-
ltype = s[:ltype]
|
|
839
|
-
r = s[:r]
|
|
840
|
-
u = s[:heatloss] / s[:net]
|
|
1338
|
+
id = trim(id)
|
|
1339
|
+
kys = [:heatloss, :net, :ltype, :index, :r]
|
|
1340
|
+
ck1 = s.is_a?(Hash)
|
|
1341
|
+
ck2 = lc.is_a?(OpenStudio::Model::LayeredConstruction)
|
|
1342
|
+
return mismatch("id" , id, cl6, mth) if id.empty?
|
|
1343
|
+
return mismatch("#{id} surface" , s , cl1, mth) unless ck1
|
|
1344
|
+
return mismatch("#{id} construction", lc, cl2, mth) unless ck2
|
|
1345
|
+
|
|
1346
|
+
kys.each do |k|
|
|
1347
|
+
tag = "#{id} #{k}"
|
|
1348
|
+
return hashkey(tag, s, k, mth, ERR) unless s.key?(k)
|
|
1349
|
+
|
|
1350
|
+
case k
|
|
1351
|
+
when :heatloss
|
|
1352
|
+
return mismatch(tag, s[k], Numeric, mth) unless s[k].respond_to?(:to_f)
|
|
1353
|
+
return zero(tag, mth, WRN) if s[k].to_f.abs < 0.001
|
|
1354
|
+
when :net, :r
|
|
1355
|
+
return mismatch(tag, s[k], Numeric, mth) unless s[k].respond_to?(:to_f)
|
|
1356
|
+
return negative(tag, mth, 2, ERR) if s[k].to_f < 0
|
|
1357
|
+
return zero(tag, mth, WRN) if s[k].to_f.abs < 0.001
|
|
1358
|
+
when :index
|
|
1359
|
+
return mismatch(tag, s[k], Numeric, mth) unless s[k].respond_to?(:to_i)
|
|
1360
|
+
return negative(tag, mth, 2, ERR) if s[k].to_f < 0
|
|
1361
|
+
else # :ltype
|
|
1362
|
+
next if [:massless, :standard].include?(s[k])
|
|
1363
|
+
return invalid(tag, mth, 2, ERR)
|
|
1364
|
+
end
|
|
1365
|
+
end
|
|
1366
|
+
|
|
1367
|
+
if lc.nameString.downcase.include?(" tbd")
|
|
1368
|
+
log(WRN, "Won't derate '#{id}': tagged as derated (#{mth})")
|
|
1369
|
+
return m
|
|
1370
|
+
end
|
|
1371
|
+
|
|
1372
|
+
model = lc.model
|
|
1373
|
+
ltype = s[:ltype ]
|
|
1374
|
+
index = s[:index ].to_i
|
|
1375
|
+
net = s[:net ].to_f
|
|
1376
|
+
r = s[:r ].to_f
|
|
1377
|
+
u = s[:heatloss].to_f / net
|
|
841
1378
|
loss = 0
|
|
842
|
-
de_u = 1 / r + u
|
|
843
|
-
de_r = 1 / de_u
|
|
1379
|
+
de_u = 1 / r + u # derated U
|
|
1380
|
+
de_r = 1 / de_u # derated R
|
|
844
1381
|
|
|
845
1382
|
if ltype == :massless
|
|
846
1383
|
m = lc.getLayer(index).to_MasslessOpaqueMaterial
|
|
847
|
-
return invalid("
|
|
1384
|
+
return invalid("#{id} massless layer?", mth, 0) if m.empty?
|
|
848
1385
|
m = m.get
|
|
849
1386
|
up = ""
|
|
850
|
-
up = "uprated "
|
|
1387
|
+
up = "uprated " if m.nameString.downcase.include?(" uprated")
|
|
851
1388
|
m = m.clone(model).to_MasslessOpaqueMaterial.get
|
|
852
1389
|
m.setName("#{id} #{up}m tbd")
|
|
853
|
-
de_r = 0.001
|
|
854
|
-
loss = (de_u - 1 / de_r) *
|
|
1390
|
+
de_r = 0.001 unless de_r > 0.001
|
|
1391
|
+
loss = (de_u - 1 / de_r) * net unless de_r > 0.001
|
|
855
1392
|
m.setThermalResistance(de_r)
|
|
856
1393
|
else
|
|
857
1394
|
m = lc.getLayer(index).to_StandardOpaqueMaterial
|
|
858
|
-
return invalid("
|
|
1395
|
+
return invalid("#{id} standard layer?", mth, 0) if m.empty?
|
|
859
1396
|
m = m.get
|
|
860
1397
|
up = ""
|
|
861
|
-
up = "uprated "
|
|
1398
|
+
up = "uprated " if m.nameString.downcase.include?(" uprated")
|
|
862
1399
|
m = m.clone(model).to_StandardOpaqueMaterial.get
|
|
863
1400
|
m.setName("#{id} #{up}m tbd")
|
|
864
1401
|
k = m.thermalConductivity
|
|
@@ -869,14 +1406,14 @@ module TBD
|
|
|
869
1406
|
unless d > 0.003
|
|
870
1407
|
d = 0.003
|
|
871
1408
|
k = d / de_r
|
|
872
|
-
k = 3
|
|
873
|
-
loss = (de_u - k / d) *
|
|
1409
|
+
k = 3 unless k < 3
|
|
1410
|
+
loss = (de_u - k / d) * net unless k < 3
|
|
874
1411
|
end
|
|
875
|
-
else
|
|
1412
|
+
else # de_r < 0.001 m2•K/W
|
|
876
1413
|
d = 0.001 * k
|
|
877
|
-
d = 0.003
|
|
878
|
-
k = d / 0.001
|
|
879
|
-
loss = (de_u - k / d) *
|
|
1414
|
+
d = 0.003 unless d > 0.003
|
|
1415
|
+
k = d / 0.001 unless d > 0.003
|
|
1416
|
+
loss = (de_u - k / d) * net
|
|
880
1417
|
end
|
|
881
1418
|
|
|
882
1419
|
m.setThickness(d)
|
|
@@ -885,50 +1422,78 @@ module TBD
|
|
|
885
1422
|
|
|
886
1423
|
if m && loss > TOL
|
|
887
1424
|
s[:r_heatloss] = loss
|
|
888
|
-
|
|
889
|
-
log(WRN, "Won't assign #{
|
|
1425
|
+
hl = format "%.3f", s[:r_heatloss]
|
|
1426
|
+
log(WRN, "Won't assign #{hl} W/K to '#{id}': too conductive (#{mth})")
|
|
890
1427
|
end
|
|
891
1428
|
|
|
892
1429
|
m
|
|
893
1430
|
end
|
|
894
1431
|
|
|
895
1432
|
##
|
|
896
|
-
#
|
|
897
|
-
# and
|
|
898
|
-
# within surface multilayered constructions
|
|
899
|
-
#
|
|
900
|
-
# surfaces: derated TBD surfaces.
|
|
1433
|
+
# Processes TBD objects, based on an OpenStudio and generated Topolys model,
|
|
1434
|
+
# and derates admissible envelope surfaces by substituting insulating
|
|
1435
|
+
# materials with derated clones, within surface multilayered constructions.
|
|
1436
|
+
# Returns a Hash holding 2 key:value pairs; io: objects for JSON
|
|
1437
|
+
# serialization, and surfaces: derated TBD surfaces (see exit method).
|
|
901
1438
|
#
|
|
902
1439
|
# @param model [OpenStudio::Model::Model] a model
|
|
903
|
-
# @param
|
|
1440
|
+
# @param [Hash] argh TBD arguments
|
|
1441
|
+
# @option argh [#to_s] :option selected PSI set
|
|
1442
|
+
# @option argh [#to_s] :io_path tbd.json input file path
|
|
1443
|
+
# @option argh [#to_s] :schema_path TBD JSON schema file path
|
|
1444
|
+
# @option argh [Bool] :parapet (true) wall-roof edge as parapet
|
|
1445
|
+
# @option argh [Bool] :uprate_walls whether to uprate walls
|
|
1446
|
+
# @option argh [Bool] :uprate_roofs whether to uprate roofs
|
|
1447
|
+
# @option argh [Bool] :uprate_floors whether to uprate floors
|
|
1448
|
+
# @option argh [Bool] :wall_ut uprated wall Ut target in W/m2•K
|
|
1449
|
+
# @option argh [Bool] :roof_ut uprated roof Ut target in W/m2•K
|
|
1450
|
+
# @option argh [Bool] :floor_ut uprated floor Ut target in W/m2•K
|
|
1451
|
+
# @option argh [#to_s] :wall_option wall construction to uprate (or "all")
|
|
1452
|
+
# @option argh [#to_s] :roof_option roof construction to uprate (or "all")
|
|
1453
|
+
# @option argh [#to_s] :floor_option floor construction to uprate (or "all")
|
|
1454
|
+
# @option argh [Bool] :gen_ua whether to generate a UA' report
|
|
1455
|
+
# @option argh [#to_s] :ua_ref selected UA' ruleset
|
|
1456
|
+
# @option argh [Bool] :gen_kiva whether to generate KIVA inputs
|
|
1457
|
+
# @option argh [#to_f] :sub_tol proximity tolerance between edges in m
|
|
904
1458
|
#
|
|
905
1459
|
# @return [Hash] io: (Hash), surfaces: (Hash)
|
|
906
|
-
# @return [Hash] io: nil, surfaces: nil
|
|
1460
|
+
# @return [Hash] io: nil, surfaces: nil if invalid input (see logs)
|
|
907
1461
|
def process(model = nil, argh = {})
|
|
908
1462
|
mth = "TBD::#{__callee__}"
|
|
909
1463
|
cl = OpenStudio::Model::Model
|
|
910
1464
|
tbd = { io: nil, surfaces: {} }
|
|
911
|
-
|
|
912
1465
|
return mismatch("model", model, cl, mth, DBG, tbd) unless model.is_a?(cl)
|
|
913
1466
|
return mismatch("argh", argh, Hash, mth, DBG, tbd) unless argh.is_a?(Hash)
|
|
914
1467
|
|
|
915
|
-
argh = {}
|
|
916
|
-
argh[:
|
|
917
|
-
argh[:
|
|
918
|
-
argh[:
|
|
919
|
-
argh[:
|
|
920
|
-
argh[:uprate_walls ] = false
|
|
921
|
-
argh[:uprate_roofs ] = false
|
|
922
|
-
argh[:uprate_floors] = false
|
|
923
|
-
argh[:wall_ut ] = 0
|
|
924
|
-
argh[:roof_ut ] = 0
|
|
925
|
-
argh[:floor_ut ] = 0
|
|
926
|
-
argh[:wall_option ] = ""
|
|
927
|
-
argh[:roof_option ] = ""
|
|
928
|
-
argh[:floor_option ] = ""
|
|
929
|
-
argh[:gen_ua ] = false
|
|
930
|
-
argh[:ua_ref ] = ""
|
|
931
|
-
argh[:gen_kiva ] = false
|
|
1468
|
+
argh = {} if argh.empty?
|
|
1469
|
+
argh[:option ] = "" unless argh.key?(:option)
|
|
1470
|
+
argh[:io_path ] = nil unless argh.key?(:io_path)
|
|
1471
|
+
argh[:schema_path ] = nil unless argh.key?(:schema_path)
|
|
1472
|
+
argh[:parapet ] = true unless argh.key?(:parapet)
|
|
1473
|
+
argh[:uprate_walls ] = false unless argh.key?(:uprate_walls)
|
|
1474
|
+
argh[:uprate_roofs ] = false unless argh.key?(:uprate_roofs)
|
|
1475
|
+
argh[:uprate_floors] = false unless argh.key?(:uprate_floors)
|
|
1476
|
+
argh[:wall_ut ] = 0 unless argh.key?(:wall_ut)
|
|
1477
|
+
argh[:roof_ut ] = 0 unless argh.key?(:roof_ut)
|
|
1478
|
+
argh[:floor_ut ] = 0 unless argh.key?(:floor_ut)
|
|
1479
|
+
argh[:wall_option ] = "" unless argh.key?(:wall_option)
|
|
1480
|
+
argh[:roof_option ] = "" unless argh.key?(:roof_option)
|
|
1481
|
+
argh[:floor_option ] = "" unless argh.key?(:floor_option)
|
|
1482
|
+
argh[:gen_ua ] = false unless argh.key?(:gen_ua)
|
|
1483
|
+
argh[:ua_ref ] = "" unless argh.key?(:ua_ref)
|
|
1484
|
+
argh[:gen_kiva ] = false unless argh.key?(:gen_kiva)
|
|
1485
|
+
argh[:reset_kiva ] = false unless argh.key?(:reset_kiva)
|
|
1486
|
+
argh[:sub_tol ] = TBD::TOL unless argh.key?(:sub_tol)
|
|
1487
|
+
|
|
1488
|
+
# Ensure true or false: whether to generate KIVA inputs.
|
|
1489
|
+
unless [true, false].include?(argh[:gen_kiva])
|
|
1490
|
+
return invalid("generate KIVA option", mth, 0, DBG, tbd)
|
|
1491
|
+
end
|
|
1492
|
+
|
|
1493
|
+
# Ensure true or false: whether to first purge (existing) KIVA inputs.
|
|
1494
|
+
unless [true, false].include?(argh[:reset_kiva])
|
|
1495
|
+
return invalid("reset KIVA option", mth, 0, DBG, tbd)
|
|
1496
|
+
end
|
|
932
1497
|
|
|
933
1498
|
# Create the Topolys Model.
|
|
934
1499
|
t_model = Topolys::Model.new
|
|
@@ -936,51 +1501,16 @@ module TBD
|
|
|
936
1501
|
# "true" if any space/zone holds valid setpoint temperatures. With invalid
|
|
937
1502
|
# inputs, these 2x methods return "false", ignoring any
|
|
938
1503
|
# setpoint-based logic, e.g. semi-heated spaces (DEBUG errors are logged).
|
|
939
|
-
|
|
940
|
-
|
|
941
|
-
|
|
942
|
-
# "true" if any space/zone is part of an HVAC air loop. With invalid inputs,
|
|
943
|
-
# the method returns "false", ignoring any air-loop related logic, e.g.
|
|
944
|
-
# plenum zones as HVAC objects (DEBUG errors are logged).
|
|
945
|
-
airloops = airLoopsHVAC?(model)
|
|
1504
|
+
heated = heatingTemperatureSetpoints?(model)
|
|
1505
|
+
cooled = coolingTemperatureSetpoints?(model)
|
|
1506
|
+
argh[:setpoints] = heated || cooled
|
|
946
1507
|
|
|
947
1508
|
model.getSurfaces.sort_by { |s| s.nameString }.each do |s|
|
|
948
|
-
# Fetch key attributes of opaque surfaces
|
|
949
|
-
#
|
|
950
|
-
surface = properties(
|
|
951
|
-
|
|
952
|
-
|
|
953
|
-
# Similar to "setpoints?" methods above, the boolean methods below also
|
|
954
|
-
# return "false" with invalid inputs, ignoring any space/zone
|
|
955
|
-
# conditioning-based logic (e.g. semi-heated spaces, mislabelling a
|
|
956
|
-
# plenum as an unconditioned zone).
|
|
957
|
-
if setpoints
|
|
958
|
-
if surface[:space].thermalZone.empty?
|
|
959
|
-
plenum = plenum?(surface[:space], airloops, setpoints)
|
|
960
|
-
surface[:conditioned] = false unless plenum
|
|
961
|
-
else
|
|
962
|
-
zone = surface[:space].thermalZone.get
|
|
963
|
-
heat = maxHeatScheduledSetpoint(zone)
|
|
964
|
-
cool = minCoolScheduledSetpoint(zone)
|
|
965
|
-
|
|
966
|
-
unless heat[:spt] || cool[:spt]
|
|
967
|
-
plenum = plenum?(surface[:space], airloops, setpoints)
|
|
968
|
-
heat[:spt] = 21 if plenum
|
|
969
|
-
cool[:spt] = 24 if plenum
|
|
970
|
-
surface[:conditioned] = false unless plenum
|
|
971
|
-
end
|
|
972
|
-
|
|
973
|
-
free = heat[:spt] && heat[:spt] < -40 && cool[:spt] && cool[:spt] > 40
|
|
974
|
-
surface[:conditioned] = false if free
|
|
975
|
-
end
|
|
976
|
-
end
|
|
977
|
-
|
|
978
|
-
# Recover if valid setpoints.
|
|
979
|
-
surface[:heating] = heat[:spt] if heat && heat[:spt]
|
|
980
|
-
surface[:cooling] = cool[:spt] if cool && cool[:spt]
|
|
981
|
-
|
|
982
|
-
tbd[:surfaces][s.nameString] = surface
|
|
983
|
-
end # (opaque) surfaces populated
|
|
1509
|
+
# Fetch key attributes of opaque surfaces (and any linked sub surfaces).
|
|
1510
|
+
# Method returns nil with invalid input (see logs); TBD ignores them.
|
|
1511
|
+
surface = properties(s, argh)
|
|
1512
|
+
tbd[:surfaces][s.nameString] = surface unless surface.nil?
|
|
1513
|
+
end
|
|
984
1514
|
|
|
985
1515
|
return empty("TBD surfaces", mth, ERR, tbd) if tbd[:surfaces].empty?
|
|
986
1516
|
|
|
@@ -988,74 +1518,77 @@ module TBD
|
|
|
988
1518
|
# ... if facing outdoors or facing UNENCLOSED/UNCONDITIONED spaces.
|
|
989
1519
|
tbd[:surfaces].each do |id, surface|
|
|
990
1520
|
surface[:deratable] = false
|
|
991
|
-
|
|
992
1521
|
next unless surface[:conditioned]
|
|
993
|
-
next if surface[:ground]
|
|
1522
|
+
next if surface[:ground ]
|
|
994
1523
|
|
|
995
1524
|
unless surface[:boundary].downcase == "outdoors"
|
|
996
1525
|
next unless tbd[:surfaces].key?(surface[:boundary])
|
|
997
|
-
next
|
|
1526
|
+
next if tbd[:surfaces][surface[:boundary]][:conditioned]
|
|
998
1527
|
end
|
|
999
1528
|
|
|
1000
|
-
|
|
1001
|
-
|
|
1002
|
-
|
|
1529
|
+
if surface.key?(:index)
|
|
1530
|
+
surface[:deratable] = true
|
|
1531
|
+
else
|
|
1532
|
+
log(ERR, "Skipping '#{id}': insulating layer? (#{mth})")
|
|
1533
|
+
end
|
|
1003
1534
|
end
|
|
1004
1535
|
|
|
1005
|
-
|
|
1536
|
+
# Sort subsurfaces before processing.
|
|
1537
|
+
[:windows, :doors, :skylights].each do |holes|
|
|
1006
1538
|
tbd[:surfaces].values.each do |surface|
|
|
1007
|
-
|
|
1008
|
-
|
|
1539
|
+
next unless surface.key?(holes)
|
|
1540
|
+
|
|
1541
|
+
surface[holes] = surface[holes].sort_by { |_, s| s[:minz] }.to_h
|
|
1009
1542
|
end
|
|
1010
1543
|
end
|
|
1011
1544
|
|
|
1012
1545
|
# Split "surfaces" hash into "floors", "ceilings" and "walls" hashes.
|
|
1013
|
-
floors = tbd[:surfaces].select { |_, s| s[:type] == :floor
|
|
1014
|
-
ceilings = tbd[:surfaces].select { |_, s| s[:type] == :ceiling
|
|
1015
|
-
walls = tbd[:surfaces].select { |_, s| s[:type] == :wall
|
|
1016
|
-
|
|
1017
|
-
|
|
1018
|
-
|
|
1546
|
+
floors = tbd[:surfaces].select { |_, s| s[:type] == :floor }
|
|
1547
|
+
ceilings = tbd[:surfaces].select { |_, s| s[:type] == :ceiling }
|
|
1548
|
+
walls = tbd[:surfaces].select { |_, s| s[:type] == :wall }
|
|
1549
|
+
|
|
1550
|
+
floors = floors.sort_by { |_, s| [s[:minz], s[:space]] }.to_h
|
|
1551
|
+
ceilings = ceilings.sort_by { |_, s| [s[:minz], s[:space]] }.to_h
|
|
1552
|
+
walls = walls.sort_by { |_, s| [s[:minz], s[:space]] }.to_h
|
|
1019
1553
|
|
|
1020
1554
|
# Fetch OpenStudio shading surfaces & key attributes.
|
|
1021
1555
|
shades = {}
|
|
1022
1556
|
|
|
1023
1557
|
model.getShadingSurfaces.each do |s|
|
|
1024
|
-
id
|
|
1025
|
-
|
|
1026
|
-
log(ERR, "Can't process '#{id}' transformation (#{mth})")
|
|
1027
|
-
next
|
|
1028
|
-
|
|
1029
|
-
|
|
1030
|
-
tr = transforms(
|
|
1031
|
-
|
|
1032
|
-
t = tr[:t]
|
|
1033
|
-
log(FTL, "Can't process '#{id}' transformation (#{mth})") unless ok
|
|
1034
|
-
return tbd unless ok
|
|
1035
|
-
|
|
1036
|
-
unless shading.empty?
|
|
1037
|
-
empty = shading.get.space.empty?
|
|
1038
|
-
tr[:r] += shading.get.space.get.directionofRelativeNorth unless empty
|
|
1039
|
-
end
|
|
1558
|
+
id = s.nameString
|
|
1559
|
+
group = s.shadingSurfaceGroup
|
|
1560
|
+
log(ERR, "Can't process '#{id}' transformation (#{mth})") if group.empty?
|
|
1561
|
+
next if group.empty?
|
|
1562
|
+
|
|
1563
|
+
group = group.get
|
|
1564
|
+
tr = transforms(group)
|
|
1565
|
+
t = tr[:t] if tr[:t] && tr[:r]
|
|
1040
1566
|
|
|
1041
|
-
|
|
1042
|
-
|
|
1043
|
-
|
|
1567
|
+
log(FTL, "Can't process '#{id}' transformation (#{mth})") unless t
|
|
1568
|
+
return tbd unless t
|
|
1569
|
+
|
|
1570
|
+
space = group.space
|
|
1571
|
+
tr[:r] += space.get.directionofRelativeNorth unless space.empty?
|
|
1572
|
+
n = trueNormal(s, tr[:r])
|
|
1573
|
+
log(FTL, "Can't process '#{id}' true normal (#{mth})") unless n
|
|
1574
|
+
return tbd unless n
|
|
1044
1575
|
|
|
1045
1576
|
points = (t * s.vertices).map { |v| Topolys::Point3D.new(v.x, v.y, v.z) }
|
|
1577
|
+
|
|
1046
1578
|
minz = ( points.map { |p| p.z } ).min
|
|
1047
|
-
|
|
1048
|
-
|
|
1579
|
+
|
|
1580
|
+
shades[id] = { group: group, points: points, minz: minz, n: n }
|
|
1581
|
+
end
|
|
1049
1582
|
|
|
1050
1583
|
# Mutually populate TBD & Topolys surfaces. Keep track of created "holes".
|
|
1051
1584
|
holes = {}
|
|
1052
|
-
floor_holes = dads(t_model, floors
|
|
1585
|
+
floor_holes = dads(t_model, floors)
|
|
1053
1586
|
ceiling_holes = dads(t_model, ceilings)
|
|
1054
|
-
wall_holes = dads(t_model, walls
|
|
1587
|
+
wall_holes = dads(t_model, walls)
|
|
1055
1588
|
|
|
1056
|
-
holes.merge!(floor_holes
|
|
1589
|
+
holes.merge!(floor_holes)
|
|
1057
1590
|
holes.merge!(ceiling_holes)
|
|
1058
|
-
holes.merge!(wall_holes
|
|
1591
|
+
holes.merge!(wall_holes)
|
|
1059
1592
|
dads(t_model, shades)
|
|
1060
1593
|
|
|
1061
1594
|
# Loop through Topolys edges and populate TBD edge hash. Initially, there
|
|
@@ -1063,25 +1596,44 @@ module TBD
|
|
|
1063
1596
|
# objects. Use Topolys-generated identifiers as unique edge hash keys.
|
|
1064
1597
|
edges = {}
|
|
1065
1598
|
|
|
1066
|
-
|
|
1599
|
+
# Start with hole edges.
|
|
1600
|
+
holes.each do |id, wire|
|
|
1067
1601
|
wire.edges.each do |e|
|
|
1068
|
-
i
|
|
1069
|
-
l
|
|
1070
|
-
|
|
1071
|
-
|
|
1072
|
-
|
|
1073
|
-
|
|
1602
|
+
i = e.id
|
|
1603
|
+
l = e.length
|
|
1604
|
+
ex = edges.key?(i)
|
|
1605
|
+
|
|
1606
|
+
edges[i] = { length: l, v0: e.v0, v1: e.v1, surfaces: {} } unless ex
|
|
1607
|
+
|
|
1608
|
+
next if edges[i][:surfaces].key?(wire.attributes[:id])
|
|
1609
|
+
|
|
1610
|
+
edges[i][:surfaces][wire.attributes[:id]] = { wire: wire.id }
|
|
1074
1611
|
end
|
|
1075
1612
|
end
|
|
1076
1613
|
|
|
1077
1614
|
# Next, floors, ceilings & walls; then shades.
|
|
1078
|
-
faces(floors, edges
|
|
1615
|
+
faces(floors , edges)
|
|
1079
1616
|
faces(ceilings, edges)
|
|
1080
|
-
faces(walls, edges
|
|
1081
|
-
faces(shades, edges
|
|
1617
|
+
faces(walls , edges)
|
|
1618
|
+
faces(shades , edges)
|
|
1619
|
+
|
|
1620
|
+
# Purge existing KIVA objects from model.
|
|
1621
|
+
if argh[:reset_kiva]
|
|
1622
|
+
kva = false
|
|
1623
|
+
kva = true unless model.getSurfacePropertyExposedFoundationPerimeters.empty?
|
|
1624
|
+
kva = true unless model.getFoundationKivas.empty?
|
|
1625
|
+
|
|
1626
|
+
if kva
|
|
1627
|
+
if argh[:gen_kiva]
|
|
1628
|
+
resetKIVA(model, "Foundation")
|
|
1629
|
+
else
|
|
1630
|
+
resetKIVA(model, "Ground")
|
|
1631
|
+
end
|
|
1632
|
+
end
|
|
1633
|
+
end
|
|
1082
1634
|
|
|
1083
1635
|
# Generate OSM Kiva settings and objects if foundation-facing floors.
|
|
1084
|
-
#
|
|
1636
|
+
# Returns false if partial failure (log failure eventually).
|
|
1085
1637
|
kiva(model, walls, floors, edges) if argh[:gen_kiva]
|
|
1086
1638
|
|
|
1087
1639
|
# Thermal bridging characteristics of edges are determined - in part - by
|
|
@@ -1113,8 +1665,10 @@ module TBD
|
|
|
1113
1665
|
vertical = dx < TOL && dy < TOL
|
|
1114
1666
|
edge_V = terminal - origin
|
|
1115
1667
|
|
|
1116
|
-
|
|
1117
|
-
|
|
1668
|
+
if edge_V.magnitude < TOL
|
|
1669
|
+
invalid("1x edge length < TOL", mth, 0, ERROR)
|
|
1670
|
+
next
|
|
1671
|
+
end
|
|
1118
1672
|
|
|
1119
1673
|
edge_plane = Topolys::Plane3D.new(origin, edge_V)
|
|
1120
1674
|
|
|
@@ -1122,7 +1676,7 @@ module TBD
|
|
|
1122
1676
|
reference_V = north.dup
|
|
1123
1677
|
elsif horizontal
|
|
1124
1678
|
reference_V = zenith.dup
|
|
1125
|
-
else
|
|
1679
|
+
else # project zenith vector unto edge plane
|
|
1126
1680
|
reference = edge_plane.project(origin + zenith)
|
|
1127
1681
|
reference_V = reference - origin
|
|
1128
1682
|
end
|
|
@@ -1131,12 +1685,13 @@ module TBD
|
|
|
1131
1685
|
# Loop through each linked wire and determine farthest point from
|
|
1132
1686
|
# edge while ensuring candidate point is not aligned with edge.
|
|
1133
1687
|
t_model.wires.each do |wire|
|
|
1134
|
-
next unless surface[:wire] == wire.id
|
|
1688
|
+
next unless surface[:wire] == wire.id # should be a unique match
|
|
1689
|
+
|
|
1135
1690
|
normal = tbd[:surfaces][id][:n] if tbd[:surfaces].key?(id)
|
|
1136
1691
|
normal = holes[id].attributes[:n] if holes.key?(id)
|
|
1137
1692
|
normal = shades[id][:n] if shades.key?(id)
|
|
1138
1693
|
farthest = Topolys::Point3D.new(origin.x, origin.y, origin.z)
|
|
1139
|
-
farthest_V = farthest - origin
|
|
1694
|
+
farthest_V = farthest - origin # zero magnitude, initially
|
|
1140
1695
|
inverted = false
|
|
1141
1696
|
i_origin = wire.points.index(origin)
|
|
1142
1697
|
i_terminal = wire.points.index(terminal)
|
|
@@ -1167,9 +1722,10 @@ module TBD
|
|
|
1167
1722
|
plane = Topolys::Plane3D.from_points(origin, terminal, point)
|
|
1168
1723
|
end
|
|
1169
1724
|
|
|
1170
|
-
|
|
1171
|
-
|
|
1172
|
-
|
|
1725
|
+
dnx = (normal.x - plane.normal.x).abs
|
|
1726
|
+
dny = (normal.y - plane.normal.y).abs
|
|
1727
|
+
dnz = (normal.z - plane.normal.z).abs
|
|
1728
|
+
next unless dnx < TOL && dny < TOL && dnz < TOL
|
|
1173
1729
|
|
|
1174
1730
|
farther = point_V_magnitude > farthest_V.magnitude
|
|
1175
1731
|
farthest = point if farther
|
|
@@ -1180,16 +1736,18 @@ module TBD
|
|
|
1180
1736
|
invalid("#{id} polar angle", mth, 0, ERROR, 0) if angle.nil?
|
|
1181
1737
|
angle = 0 if angle.nil?
|
|
1182
1738
|
|
|
1183
|
-
adjust = false
|
|
1739
|
+
adjust = false # adjust angle [180°, 360°] if necessary
|
|
1184
1740
|
|
|
1185
1741
|
if vertical
|
|
1186
1742
|
adjust = true if east.dot(farthest_V) < -TOL
|
|
1187
1743
|
else
|
|
1188
|
-
|
|
1189
|
-
|
|
1744
|
+
dN = north.dot(farthest_V)
|
|
1745
|
+
dN1 = north.dot(farthest_V).abs - 1
|
|
1746
|
+
|
|
1747
|
+
if dN.abs < TOL || dN1.abs < TOL
|
|
1190
1748
|
adjust = true if east.dot(farthest_V) < -TOL
|
|
1191
1749
|
else
|
|
1192
|
-
adjust = true if
|
|
1750
|
+
adjust = true if dN < -TOL
|
|
1193
1751
|
end
|
|
1194
1752
|
end
|
|
1195
1753
|
|
|
@@ -1199,13 +1757,13 @@ module TBD
|
|
|
1199
1757
|
farthest_V.normalize!
|
|
1200
1758
|
surface[:polar ] = farthest_V
|
|
1201
1759
|
surface[:normal] = normal
|
|
1202
|
-
end
|
|
1203
|
-
end
|
|
1760
|
+
end # end of edge-linked, surface-to-wire loop
|
|
1761
|
+
end # end of edge-linked surface loop
|
|
1204
1762
|
|
|
1205
1763
|
edge[:horizontal] = horizontal
|
|
1206
1764
|
edge[:vertical ] = vertical
|
|
1207
|
-
edge[:surfaces ] = edge[:surfaces].sort_by{ |
|
|
1208
|
-
end
|
|
1765
|
+
edge[:surfaces ] = edge[:surfaces].sort_by{ |_, p| p[:angle] }.to_h
|
|
1766
|
+
end # end of edge loop
|
|
1209
1767
|
|
|
1210
1768
|
# Topolys edges may constitute thermal bridges (and therefore thermally
|
|
1211
1769
|
# derate linked OpenStudio opaque surfaces), depending on a number of
|
|
@@ -1251,23 +1809,27 @@ module TBD
|
|
|
1251
1809
|
# EnergyPlus simulation). This is similar to accessing an invalid .osm file.
|
|
1252
1810
|
return tbd if fatal?
|
|
1253
1811
|
|
|
1254
|
-
psi = json[:io][:building][:psi]
|
|
1812
|
+
psi = json[:io][:building][:psi] # default building PSI on file
|
|
1255
1813
|
shorts = json[:psi].shorthands(psi)
|
|
1256
|
-
|
|
1257
|
-
|
|
1258
|
-
|
|
1814
|
+
|
|
1815
|
+
if shorts[:has].empty? || shorts[:val].empty?
|
|
1816
|
+
log(FTL, "Invalid or incomplete building PSI set (#{mth})")
|
|
1817
|
+
return tbd
|
|
1818
|
+
end
|
|
1259
1819
|
|
|
1260
1820
|
edges.values.each do |edge|
|
|
1261
1821
|
next unless edge.key?(:surfaces)
|
|
1822
|
+
|
|
1262
1823
|
deratables = []
|
|
1824
|
+
set = {}
|
|
1263
1825
|
|
|
1264
1826
|
edge[:surfaces].keys.each do |id|
|
|
1265
1827
|
next unless tbd[:surfaces].key?(id)
|
|
1828
|
+
|
|
1266
1829
|
deratables << id if tbd[:surfaces][id][:deratable]
|
|
1267
1830
|
end
|
|
1268
1831
|
|
|
1269
1832
|
next if deratables.empty?
|
|
1270
|
-
set = {}
|
|
1271
1833
|
|
|
1272
1834
|
if edge.key?(:io_type)
|
|
1273
1835
|
bdg = json[:psi].safe(psi, edge[:io_type]) # building safe type fallback
|
|
@@ -1290,97 +1852,226 @@ module TBD
|
|
|
1290
1852
|
next unless deratables.include?(id)
|
|
1291
1853
|
|
|
1292
1854
|
# Evaluate current set content before processing a new linked surface.
|
|
1293
|
-
is
|
|
1294
|
-
is[:head
|
|
1295
|
-
is[:sill
|
|
1296
|
-
is[:jamb
|
|
1297
|
-
is[:
|
|
1298
|
-
is[:
|
|
1299
|
-
is[:
|
|
1300
|
-
is[:
|
|
1301
|
-
is[:
|
|
1302
|
-
is[:
|
|
1303
|
-
|
|
1304
|
-
|
|
1305
|
-
|
|
1855
|
+
is = {}
|
|
1856
|
+
is[:head ] = set.keys.to_s.include?("head")
|
|
1857
|
+
is[:sill ] = set.keys.to_s.include?("sill")
|
|
1858
|
+
is[:jamb ] = set.keys.to_s.include?("jamb")
|
|
1859
|
+
is[:doorhead ] = set.keys.to_s.include?("doorhead")
|
|
1860
|
+
is[:doorsill ] = set.keys.to_s.include?("doorsill")
|
|
1861
|
+
is[:doorjamb ] = set.keys.to_s.include?("doorjamb")
|
|
1862
|
+
is[:skylighthead ] = set.keys.to_s.include?("skylighthead")
|
|
1863
|
+
is[:skylightsill ] = set.keys.to_s.include?("skylightsill")
|
|
1864
|
+
is[:skylightjamb ] = set.keys.to_s.include?("skylightjamb")
|
|
1865
|
+
is[:spandrel ] = set.keys.to_s.include?("spandrel")
|
|
1866
|
+
is[:corner ] = set.keys.to_s.include?("corner")
|
|
1867
|
+
is[:parapet ] = set.keys.to_s.include?("parapet")
|
|
1868
|
+
is[:roof ] = set.keys.to_s.include?("roof")
|
|
1869
|
+
is[:party ] = set.keys.to_s.include?("party")
|
|
1870
|
+
is[:grade ] = set.keys.to_s.include?("grade")
|
|
1871
|
+
is[:balcony ] = set.keys.to_s.include?("balcony")
|
|
1872
|
+
is[:balconysill ] = set.keys.to_s.include?("balconysill")
|
|
1873
|
+
is[:balconydoorsill ] = set.keys.to_s.include?("balconydoorsill")
|
|
1874
|
+
is[:rimjoist ] = set.keys.to_s.include?("rimjoist")
|
|
1875
|
+
|
|
1876
|
+
# Label edge as ...
|
|
1877
|
+
# :head, :sill, :jamb (vertical fenestration)
|
|
1878
|
+
# :doorhead, :doorsill, :doorjamb (opaque door)
|
|
1879
|
+
# :skylighthead, :skylightsill, :skylightjamb (all other cases)
|
|
1880
|
+
#
|
|
1881
|
+
# ... if linked to:
|
|
1882
|
+
# 1x subsurface (vertical or non-vertical)
|
|
1306
1883
|
edge[:surfaces].keys.each do |i|
|
|
1307
|
-
break if is[:head]
|
|
1884
|
+
break if is[:head ]
|
|
1885
|
+
break if is[:sill ]
|
|
1886
|
+
break if is[:jamb ]
|
|
1887
|
+
break if is[:doorhead ]
|
|
1888
|
+
break if is[:doorsill ]
|
|
1889
|
+
break if is[:doorjamb ]
|
|
1890
|
+
break if is[:skylighthead]
|
|
1891
|
+
break if is[:skylightsill]
|
|
1892
|
+
break if is[:skylightjamb]
|
|
1308
1893
|
next if deratables.include?(i)
|
|
1309
1894
|
next unless holes.key?(i)
|
|
1310
1895
|
|
|
1311
|
-
|
|
1312
|
-
|
|
1313
|
-
|
|
1314
|
-
|
|
1315
|
-
|
|
1316
|
-
|
|
1317
|
-
|
|
1318
|
-
|
|
1319
|
-
|
|
1320
|
-
|
|
1321
|
-
|
|
1322
|
-
|
|
1323
|
-
|
|
1324
|
-
|
|
1325
|
-
|
|
1326
|
-
|
|
1327
|
-
|
|
1328
|
-
|
|
1329
|
-
|
|
1330
|
-
|
|
1331
|
-
|
|
1332
|
-
|
|
1333
|
-
|
|
1334
|
-
|
|
1335
|
-
|
|
1336
|
-
gardian =
|
|
1337
|
-
|
|
1896
|
+
# In most cases, subsurface edges simply delineate the rough opening
|
|
1897
|
+
# of its base surface (here, a "gardian"). Door sills, corner windows,
|
|
1898
|
+
# as well as a subsurface header aligned with a plenum "floor"
|
|
1899
|
+
# (ceiling tiles), are common instances where a subsurface edge links
|
|
1900
|
+
# 2x (opaque) surfaces. Deratable surface "id" may not be the gardian
|
|
1901
|
+
# of subsurface "i" - the latter may be a neighbour. The single
|
|
1902
|
+
# surface to derate is not the gardian in such cases.
|
|
1903
|
+
gardian = deratables.size == 1 ? id : ""
|
|
1904
|
+
target = gardian
|
|
1905
|
+
|
|
1906
|
+
# Retrieve base surface's subsurfaces.
|
|
1907
|
+
windows = tbd[:surfaces][id].key?(:windows)
|
|
1908
|
+
doors = tbd[:surfaces][id].key?(:doors)
|
|
1909
|
+
skylights = tbd[:surfaces][id].key?(:skylights)
|
|
1910
|
+
|
|
1911
|
+
windows = windows ? tbd[:surfaces][id][:windows ] : {}
|
|
1912
|
+
doors = doors ? tbd[:surfaces][id][:doors ] : {}
|
|
1913
|
+
skylights = skylights ? tbd[:surfaces][id][:skylights] : {}
|
|
1914
|
+
|
|
1915
|
+
# The gardian is "id" if subsurface "ids" holds "i".
|
|
1916
|
+
ids = windows.keys + doors.keys + skylights.keys
|
|
1917
|
+
|
|
1918
|
+
if gardian.empty?
|
|
1919
|
+
other = deratables.first == id ? deratables.last : deratables.first
|
|
1920
|
+
|
|
1921
|
+
gardian = ids.include?(i) ? id : other
|
|
1922
|
+
target = ids.include?(i) ? other : id
|
|
1923
|
+
|
|
1924
|
+
windows = tbd[:surfaces][gardian].key?(:windows)
|
|
1925
|
+
doors = tbd[:surfaces][gardian].key?(:doors)
|
|
1926
|
+
skylights = tbd[:surfaces][gardian].key?(:skylights)
|
|
1927
|
+
|
|
1928
|
+
windows = windows ? tbd[:surfaces][gardian][:windows ] : {}
|
|
1929
|
+
doors = doors ? tbd[:surfaces][gardian][:doors ] : {}
|
|
1930
|
+
skylights = skylights ? tbd[:surfaces][gardian][:skylights] : {}
|
|
1931
|
+
|
|
1932
|
+
ids = windows.keys + doors.keys + skylights.keys
|
|
1338
1933
|
end
|
|
1339
1934
|
|
|
1340
|
-
|
|
1341
|
-
|
|
1342
|
-
|
|
1935
|
+
unless ids.include?(i)
|
|
1936
|
+
log(ERR, "Orphaned subsurface #{i} (mth)")
|
|
1937
|
+
next
|
|
1938
|
+
end
|
|
1939
|
+
|
|
1940
|
+
window = windows.key?(i) ? windows[i] : {}
|
|
1941
|
+
door = doors.key?(i) ? doors[i] : {}
|
|
1942
|
+
skylight = skylights.key?(i) ? skylights[i] : {}
|
|
1943
|
+
|
|
1944
|
+
sub = window unless window.empty?
|
|
1945
|
+
sub = door unless door.empty?
|
|
1946
|
+
sub = skylight unless skylight.empty?
|
|
1947
|
+
|
|
1948
|
+
window = sub[:type] == :window
|
|
1949
|
+
door = sub[:type] == :door
|
|
1950
|
+
glazed = door && sub.key?(:glazed) && sub[:glazed]
|
|
1951
|
+
|
|
1952
|
+
s1 = edge[:surfaces][target]
|
|
1953
|
+
s2 = edge[:surfaces][i ]
|
|
1343
1954
|
concave = concave?(s1, s2)
|
|
1344
1955
|
convex = convex?(s1, s2)
|
|
1345
1956
|
flat = !concave && !convex
|
|
1346
1957
|
|
|
1347
|
-
# Subsurface edges are tagged as
|
|
1348
|
-
#
|
|
1349
|
-
# :fenestration, then its
|
|
1350
|
-
#
|
|
1351
|
-
# concave or convex variants also inherit from base type.
|
|
1958
|
+
# Subsurface edges are tagged as head, sill or jamb, regardless of
|
|
1959
|
+
# building PSI set subsurface-related tags. If the latter is simply
|
|
1960
|
+
# :fenestration, then its single PSI factor is systematically
|
|
1961
|
+
# assigned to e.g. a window's :head, :sill & :jamb edges.
|
|
1352
1962
|
#
|
|
1353
|
-
#
|
|
1354
|
-
#
|
|
1355
|
-
#
|
|
1356
|
-
#
|
|
1357
|
-
|
|
1358
|
-
|
|
1359
|
-
|
|
1360
|
-
|
|
1361
|
-
|
|
1362
|
-
else
|
|
1363
|
-
if edge[:horizontal]
|
|
1364
|
-
if s2[:polar].dot(zenith) < 0
|
|
1365
|
-
set[:head ] = shorts[:val][:head ] if flat
|
|
1366
|
-
set[:headconcave] = shorts[:val][:headconcave] if concave
|
|
1367
|
-
set[:headconvex ] = shorts[:val][:headconvex ] if convex
|
|
1368
|
-
is[:head ] = true
|
|
1369
|
-
else
|
|
1370
|
-
set[:sill ] = shorts[:val][:sill ] if flat
|
|
1371
|
-
set[:sillconcave] = shorts[:val][:sillconcave] if concave
|
|
1372
|
-
set[:sillconvex ] = shorts[:val][:sillconvex ] if convex
|
|
1373
|
-
is[:sill ] = true
|
|
1374
|
-
end
|
|
1375
|
-
else
|
|
1963
|
+
# Additionally, concave or convex variants also inherit from the base
|
|
1964
|
+
# type if undefined in the PSI set.
|
|
1965
|
+
#
|
|
1966
|
+
# If a subsurface is not horizontal, TBD tags any horizontal edge as
|
|
1967
|
+
# either :head or :sill based on the polar angle of the subsurface
|
|
1968
|
+
# around the edge vs sky zenith. Otherwise, all other subsurface edges
|
|
1969
|
+
# are tagged as :jamb.
|
|
1970
|
+
if ((s2[:normal].dot(zenith)).abs - 1).abs < TOL # horizontal surface
|
|
1971
|
+
if glazed || window
|
|
1376
1972
|
set[:jamb ] = shorts[:val][:jamb ] if flat
|
|
1377
1973
|
set[:jambconcave] = shorts[:val][:jambconcave] if concave
|
|
1378
1974
|
set[:jambconvex ] = shorts[:val][:jambconvex ] if convex
|
|
1379
1975
|
is[:jamb ] = true
|
|
1976
|
+
elsif door
|
|
1977
|
+
set[:doorjamb ] = shorts[:val][:doorjamb ] if flat
|
|
1978
|
+
set[:doorjambconcave] = shorts[:val][:doorjambconcave] if concave
|
|
1979
|
+
set[:doorjambconvex ] = shorts[:val][:doorjambconvex ] if convex
|
|
1980
|
+
is[:doorjamb ] = true
|
|
1981
|
+
else
|
|
1982
|
+
set[:skylightjamb ] = shorts[:val][:skylightjamb ] if flat
|
|
1983
|
+
set[:skylightjambconcave] = shorts[:val][:skylightjambconcave] if concave
|
|
1984
|
+
set[:skylightjambconvex ] = shorts[:val][:skylightjambconvex ] if convex
|
|
1985
|
+
is[:skylightjamb ] = true
|
|
1986
|
+
end
|
|
1987
|
+
else
|
|
1988
|
+
if glazed || window
|
|
1989
|
+
if edge[:horizontal]
|
|
1990
|
+
if s2[:polar].dot(zenith) < 0
|
|
1991
|
+
set[:head ] = shorts[:val][:head ] if flat
|
|
1992
|
+
set[:headconcave] = shorts[:val][:headconcave] if concave
|
|
1993
|
+
set[:headconvex ] = shorts[:val][:headconvex ] if convex
|
|
1994
|
+
is[:head ] = true
|
|
1995
|
+
else
|
|
1996
|
+
set[:sill ] = shorts[:val][:sill ] if flat
|
|
1997
|
+
set[:sillconcave] = shorts[:val][:sillconcave] if concave
|
|
1998
|
+
set[:sillconvex ] = shorts[:val][:sillconvex ] if convex
|
|
1999
|
+
is[:sill ] = true
|
|
2000
|
+
end
|
|
2001
|
+
else
|
|
2002
|
+
set[:jamb ] = shorts[:val][:jamb ] if flat
|
|
2003
|
+
set[:jambconcave] = shorts[:val][:jambconcave] if concave
|
|
2004
|
+
set[:jambconvex ] = shorts[:val][:jambconvex ] if convex
|
|
2005
|
+
is[:jamb ] = true
|
|
2006
|
+
end
|
|
2007
|
+
elsif door
|
|
2008
|
+
if edge[:horizontal]
|
|
2009
|
+
if s2[:polar].dot(zenith) < 0
|
|
2010
|
+
|
|
2011
|
+
set[:doorhead ] = shorts[:val][:doorhead ] if flat
|
|
2012
|
+
set[:doorheadconcave] = shorts[:val][:doorheadconcave] if concave
|
|
2013
|
+
set[:doorheadconvex ] = shorts[:val][:doorheadconvex ] if convex
|
|
2014
|
+
is[:doorhead ] = true
|
|
2015
|
+
else
|
|
2016
|
+
set[:doorsill ] = shorts[:val][:doorsill ] if flat
|
|
2017
|
+
set[:doorsillconcave] = shorts[:val][:doorsillconcave] if concave
|
|
2018
|
+
set[:doorsillconvex ] = shorts[:val][:doorsillconvex ] if convex
|
|
2019
|
+
is[:doorsill ] = true
|
|
2020
|
+
end
|
|
2021
|
+
else
|
|
2022
|
+
set[:doorjamb ] = shorts[:val][:doorjamb ] if flat
|
|
2023
|
+
set[:doorjambconcave] = shorts[:val][:doorjambconcave] if concave
|
|
2024
|
+
set[:doorjambconvex ] = shorts[:val][:doorjambconvex ] if convex
|
|
2025
|
+
is[:doorjamb ] = true
|
|
2026
|
+
end
|
|
2027
|
+
else
|
|
2028
|
+
if edge[:horizontal]
|
|
2029
|
+
if s2[:polar].dot(zenith) < 0
|
|
2030
|
+
set[:skylighthead ] = shorts[:val][:skylighthead ] if flat
|
|
2031
|
+
set[:skylightheadconcave] = shorts[:val][:skylightheadconcave] if concave
|
|
2032
|
+
set[:skylightheadconvex ] = shorts[:val][:skylightheadconvex ] if convex
|
|
2033
|
+
is[:skylighthead ] = true
|
|
2034
|
+
else
|
|
2035
|
+
set[:skylightsill ] = shorts[:val][:skylightsill ] if flat
|
|
2036
|
+
set[:skylightsillconcave] = shorts[:val][:skylightsillconcave] if concave
|
|
2037
|
+
set[:skylightsillconvex ] = shorts[:val][:skylightsillconvex ] if convex
|
|
2038
|
+
is[:skylightsill ] = true
|
|
2039
|
+
end
|
|
2040
|
+
else
|
|
2041
|
+
set[:skylightjamb ] = shorts[:val][:skylightjamb ] if flat
|
|
2042
|
+
set[:skylightjambconcave] = shorts[:val][:skylightjambconcave] if concave
|
|
2043
|
+
set[:skylightjambconvex ] = shorts[:val][:skylightjambconvex ] if convex
|
|
2044
|
+
is[:skylightjamb ] = true
|
|
2045
|
+
end
|
|
1380
2046
|
end
|
|
1381
2047
|
end
|
|
1382
2048
|
end
|
|
1383
2049
|
|
|
2050
|
+
# Label edge as :spandrel if linked to:
|
|
2051
|
+
# 1x deratable, non-spandrel wall
|
|
2052
|
+
# 1x deratable, spandrel wall
|
|
2053
|
+
edge[:surfaces].keys.each do |i|
|
|
2054
|
+
break if is[:spandrel]
|
|
2055
|
+
break unless deratables.size == 2
|
|
2056
|
+
break unless walls.key?(id)
|
|
2057
|
+
break unless walls[id][:spandrel]
|
|
2058
|
+
next if i == id
|
|
2059
|
+
next unless deratables.include?(i)
|
|
2060
|
+
next unless walls.key?(i)
|
|
2061
|
+
next if walls[i][:spandrel]
|
|
2062
|
+
|
|
2063
|
+
s1 = edge[:surfaces][id]
|
|
2064
|
+
s2 = edge[:surfaces][i ]
|
|
2065
|
+
concave = concave?(s1, s2)
|
|
2066
|
+
convex = convex?(s1, s2)
|
|
2067
|
+
flat = !concave && !convex
|
|
2068
|
+
|
|
2069
|
+
set[:spandrel ] = shorts[:val][:spandrel ] if flat
|
|
2070
|
+
set[:spandrelconcave] = shorts[:val][:spandrelconcave] if concave
|
|
2071
|
+
set[:spandrelconvex ] = shorts[:val][:spandrelconvex ] if convex
|
|
2072
|
+
is[:spandrel ] = true
|
|
2073
|
+
end
|
|
2074
|
+
|
|
1384
2075
|
# Label edge as :cornerconcave or :cornerconvex if linked to:
|
|
1385
2076
|
# 2x deratable walls & f(relative polar wall vectors around edge)
|
|
1386
2077
|
edge[:surfaces].keys.each do |i|
|
|
@@ -1388,8 +2079,8 @@ module TBD
|
|
|
1388
2079
|
break unless deratables.size == 2
|
|
1389
2080
|
break unless walls.key?(id)
|
|
1390
2081
|
next if i == id
|
|
1391
|
-
next
|
|
1392
|
-
next
|
|
2082
|
+
next unless deratables.include?(i)
|
|
2083
|
+
next unless walls.key?(i)
|
|
1393
2084
|
|
|
1394
2085
|
s1 = edge[:surfaces][id]
|
|
1395
2086
|
s2 = edge[:surfaces][i]
|
|
@@ -1401,11 +2092,12 @@ module TBD
|
|
|
1401
2092
|
is[:corner ] = true
|
|
1402
2093
|
end
|
|
1403
2094
|
|
|
1404
|
-
# Label edge as :parapet if linked to:
|
|
2095
|
+
# Label edge as :parapet/:roof if linked to:
|
|
1405
2096
|
# 1x deratable wall
|
|
1406
2097
|
# 1x deratable ceiling
|
|
1407
2098
|
edge[:surfaces].keys.each do |i|
|
|
1408
2099
|
break if is[:parapet]
|
|
2100
|
+
break if is[:roof ]
|
|
1409
2101
|
break unless deratables.size == 2
|
|
1410
2102
|
break unless ceilings.key?(id)
|
|
1411
2103
|
next if i == id
|
|
@@ -1413,15 +2105,22 @@ module TBD
|
|
|
1413
2105
|
next unless walls.key?(i)
|
|
1414
2106
|
|
|
1415
2107
|
s1 = edge[:surfaces][id]
|
|
1416
|
-
s2 = edge[:surfaces][i]
|
|
2108
|
+
s2 = edge[:surfaces][i ]
|
|
1417
2109
|
concave = concave?(s1, s2)
|
|
1418
2110
|
convex = convex?(s1, s2)
|
|
1419
2111
|
flat = !concave && !convex
|
|
1420
2112
|
|
|
1421
|
-
|
|
1422
|
-
|
|
1423
|
-
|
|
1424
|
-
|
|
2113
|
+
if argh[:parapet]
|
|
2114
|
+
set[:parapet ] = shorts[:val][:parapet ] if flat
|
|
2115
|
+
set[:parapetconcave] = shorts[:val][:parapetconcave] if concave
|
|
2116
|
+
set[:parapetconvex ] = shorts[:val][:parapetconvex ] if convex
|
|
2117
|
+
is[:parapet ] = true
|
|
2118
|
+
else
|
|
2119
|
+
set[:roof ] = shorts[:val][:roof ] if flat
|
|
2120
|
+
set[:roofconcave] = shorts[:val][:roofconcave] if concave
|
|
2121
|
+
set[:roofconvex ] = shorts[:val][:roofconvex ] if convex
|
|
2122
|
+
is[:roof ] = true
|
|
2123
|
+
end
|
|
1425
2124
|
end
|
|
1426
2125
|
|
|
1427
2126
|
# Label edge as :party if linked to:
|
|
@@ -1439,7 +2138,7 @@ module TBD
|
|
|
1439
2138
|
next unless facing == "othersidecoefficients"
|
|
1440
2139
|
|
|
1441
2140
|
s1 = edge[:surfaces][id]
|
|
1442
|
-
s2 = edge[:surfaces][i]
|
|
2141
|
+
s2 = edge[:surfaces][i ]
|
|
1443
2142
|
concave = concave?(s1, s2)
|
|
1444
2143
|
convex = convex?(s1, s2)
|
|
1445
2144
|
flat = !concave && !convex
|
|
@@ -1473,30 +2172,106 @@ module TBD
|
|
|
1473
2172
|
is[:grade ] = true
|
|
1474
2173
|
end
|
|
1475
2174
|
|
|
1476
|
-
# Label edge as :rimjoist
|
|
2175
|
+
# Label edge as :rimjoist, :balcony, :balconysill or :balconydoorsill if linked to:
|
|
1477
2176
|
# 1x deratable surface
|
|
1478
2177
|
# 1x CONDITIONED floor
|
|
1479
2178
|
# 1x shade (optional)
|
|
1480
|
-
|
|
2179
|
+
# 1x subsurface (optional)
|
|
2180
|
+
#
|
|
2181
|
+
# Despite referring to 'sill' or 'doorsill', a 'balconysill' or
|
|
2182
|
+
# 'balconydoorsill' edge may instead link (rarer) cases of balcony and a
|
|
2183
|
+
# fenestratio/door head. ASHRAE 90.1 2022 does not make the distinction
|
|
2184
|
+
# between sill vs head when intermediatre floor, balcony and vertical
|
|
2185
|
+
# fenestration meet. 'Sills' are simply the most common occurrence.
|
|
2186
|
+
balcony = false
|
|
2187
|
+
balconysill = false # vertical fenestration
|
|
2188
|
+
balconydoorsill = false # opaque door
|
|
1481
2189
|
|
|
1482
2190
|
edge[:surfaces].keys.each do |i|
|
|
1483
|
-
break
|
|
1484
|
-
next
|
|
1485
|
-
|
|
2191
|
+
break if balcony
|
|
2192
|
+
next if i == id
|
|
2193
|
+
|
|
2194
|
+
balcony = shades.key?(i)
|
|
1486
2195
|
end
|
|
1487
2196
|
|
|
1488
2197
|
edge[:surfaces].keys.each do |i|
|
|
1489
|
-
break
|
|
2198
|
+
break unless balcony
|
|
2199
|
+
break if balconysill
|
|
2200
|
+
break if balconydoorsill
|
|
2201
|
+
next if i == id
|
|
2202
|
+
next unless holes.key?(i)
|
|
2203
|
+
|
|
2204
|
+
# Deratable surface "id" may not be the gardian of "i" (see sills).
|
|
2205
|
+
gardian = deratables.size == 1 ? id : ""
|
|
2206
|
+
target = gardian
|
|
2207
|
+
|
|
2208
|
+
# Retrieve base surface's subsurfaces.
|
|
2209
|
+
windows = tbd[:surfaces][id].key?(:windows)
|
|
2210
|
+
doors = tbd[:surfaces][id].key?(:doors)
|
|
2211
|
+
skylights = tbd[:surfaces][id].key?(:skylights)
|
|
2212
|
+
|
|
2213
|
+
windows = windows ? tbd[:surfaces][id][:windows ] : {}
|
|
2214
|
+
doors = doors ? tbd[:surfaces][id][:doors ] : {}
|
|
2215
|
+
skylights = skylights ? tbd[:surfaces][id][:skylights] : {}
|
|
2216
|
+
|
|
2217
|
+
# The gardian is "id" if subsurface "ids" holds "i".
|
|
2218
|
+
ids = windows.keys + doors.keys + skylights.keys
|
|
2219
|
+
|
|
2220
|
+
if gardian.empty?
|
|
2221
|
+
other = deratables.first == id ? deratables.last : deratables.first
|
|
2222
|
+
|
|
2223
|
+
gardian = ids.include?(i) ? id : other
|
|
2224
|
+
target = ids.include?(i) ? other : id
|
|
2225
|
+
|
|
2226
|
+
windows = tbd[:surfaces][gardian].key?(:windows)
|
|
2227
|
+
doors = tbd[:surfaces][gardian].key?(:doors)
|
|
2228
|
+
skylights = tbd[:surfaces][gardian].key?(:skylights)
|
|
2229
|
+
|
|
2230
|
+
windows = windows ? tbd[:surfaces][gardian][:windows ] : {}
|
|
2231
|
+
doors = doors ? tbd[:surfaces][gardian][:doors ] : {}
|
|
2232
|
+
skylights = skylights ? tbd[:surfaces][gardian][:skylights] : {}
|
|
2233
|
+
|
|
2234
|
+
ids = windows.keys + doors.keys + skylights.keys
|
|
2235
|
+
end
|
|
2236
|
+
|
|
2237
|
+
unless ids.include?(i)
|
|
2238
|
+
log(ERR, "Balcony sill: orphaned subsurface #{i} (mth)")
|
|
2239
|
+
next
|
|
2240
|
+
end
|
|
2241
|
+
|
|
2242
|
+
window = windows.key?(i) ? windows[i] : {}
|
|
2243
|
+
door = doors.key?(i) ? doors[i] : {}
|
|
2244
|
+
skylight = skylights.key?(i) ? skylights[i] : {}
|
|
2245
|
+
|
|
2246
|
+
sub = window unless window.empty?
|
|
2247
|
+
sub = door unless door.empty?
|
|
2248
|
+
sub = skylight unless skylight.empty?
|
|
2249
|
+
|
|
2250
|
+
window = sub[:type] == :window
|
|
2251
|
+
door = sub[:type] == :door
|
|
2252
|
+
glazed = door && sub.key?(:glazed) && sub[:glazed]
|
|
2253
|
+
|
|
2254
|
+
if window || glazed
|
|
2255
|
+
balconysill = true
|
|
2256
|
+
elsif door
|
|
2257
|
+
balconydoorsill = true
|
|
2258
|
+
end
|
|
2259
|
+
end
|
|
2260
|
+
|
|
2261
|
+
edge[:surfaces].keys.each do |i|
|
|
2262
|
+
break if is[:rimjoist ] || is[:balcony ] ||
|
|
2263
|
+
is[:balconysill] || is[:balconydoorsill]
|
|
1490
2264
|
break unless deratables.size > 0
|
|
1491
2265
|
break if floors.key?(id)
|
|
1492
2266
|
next if i == id
|
|
1493
2267
|
next unless floors.key?(i)
|
|
1494
2268
|
next unless floors[i].key?(:conditioned)
|
|
1495
2269
|
next unless floors[i][:conditioned]
|
|
1496
|
-
next if floors[i][:ground]
|
|
2270
|
+
next if floors[i][:ground ]
|
|
1497
2271
|
|
|
1498
2272
|
other = deratables.first unless deratables.first == id
|
|
1499
2273
|
other = deratables.last unless deratables.last == id
|
|
2274
|
+
other = id if deratables.size == 1
|
|
1500
2275
|
|
|
1501
2276
|
s1 = edge[:surfaces][id]
|
|
1502
2277
|
s2 = edge[:surfaces][other]
|
|
@@ -1504,38 +2279,50 @@ module TBD
|
|
|
1504
2279
|
convex = convex?(s1, s2)
|
|
1505
2280
|
flat = !concave && !convex
|
|
1506
2281
|
|
|
1507
|
-
if
|
|
1508
|
-
set[:
|
|
1509
|
-
set[:
|
|
1510
|
-
set[:
|
|
1511
|
-
is[:
|
|
2282
|
+
if balconydoorsill
|
|
2283
|
+
set[:balconydoorsill ] = shorts[:val][:balconydoorsill ] if flat
|
|
2284
|
+
set[:balconydoorsillconcave] = shorts[:val][:balconydoorsillconcave] if concave
|
|
2285
|
+
set[:balconydoorsillconvex ] = shorts[:val][:balconydoorsillconvex ] if convex
|
|
2286
|
+
is[:balconydoorsill ] = true
|
|
2287
|
+
elsif balconysill
|
|
2288
|
+
set[:balconysill ] = shorts[:val][:balconysill ] if flat
|
|
2289
|
+
set[:balconysillconcave ] = shorts[:val][:balconysillconcave ] if concave
|
|
2290
|
+
set[:balconysillconvex ] = shorts[:val][:balconysillconvex ] if convex
|
|
2291
|
+
is[:balconysill ] = true
|
|
2292
|
+
elsif balcony
|
|
2293
|
+
set[:balcony ] = shorts[:val][:balcony ] if flat
|
|
2294
|
+
set[:balconyconcave ] = shorts[:val][:balconyconcave ] if concave
|
|
2295
|
+
set[:balconyconvex ] = shorts[:val][:balconyconvex ] if convex
|
|
2296
|
+
is[:balcony ] = true
|
|
1512
2297
|
else
|
|
1513
|
-
set[:rimjoist
|
|
1514
|
-
set[:rimjoistconcave] = shorts[:val][:rimjoistconcave] if concave
|
|
1515
|
-
set[:rimjoistconvex
|
|
1516
|
-
is[:rimjoist
|
|
2298
|
+
set[:rimjoist ] = shorts[:val][:rimjoist ] if flat
|
|
2299
|
+
set[:rimjoistconcave ] = shorts[:val][:rimjoistconcave ] if concave
|
|
2300
|
+
set[:rimjoistconvex ] = shorts[:val][:rimjoistconvex ] if convex
|
|
2301
|
+
is[:rimjoist ] = true
|
|
1517
2302
|
end
|
|
1518
2303
|
end
|
|
1519
|
-
end
|
|
2304
|
+
end # edge's surfaces loop
|
|
1520
2305
|
|
|
1521
2306
|
edge[:psi] = set unless set.empty?
|
|
1522
2307
|
edge[:set] = psi unless set.empty?
|
|
1523
|
-
end
|
|
2308
|
+
end # edge loop
|
|
1524
2309
|
|
|
1525
2310
|
# Tracking (mild) transitions between deratable surfaces around edges that
|
|
1526
2311
|
# have not been previously tagged.
|
|
1527
2312
|
edges.values.each do |edge|
|
|
2313
|
+
deratable = false
|
|
1528
2314
|
next if edge.key?(:psi)
|
|
1529
2315
|
next unless edge.key?(:surfaces)
|
|
1530
|
-
deratable = false
|
|
1531
2316
|
|
|
1532
2317
|
edge[:surfaces].keys.each do |id|
|
|
1533
2318
|
next unless tbd[:surfaces].key?(id)
|
|
1534
2319
|
next unless tbd[:surfaces][id][:deratable]
|
|
2320
|
+
|
|
1535
2321
|
deratable = tbd[:surfaces][id][:deratable]
|
|
1536
2322
|
end
|
|
1537
2323
|
|
|
1538
2324
|
next unless deratable
|
|
2325
|
+
|
|
1539
2326
|
edge[:psi] = { transition: 0.000 }
|
|
1540
2327
|
edge[:set] = json[:io][:building][:psi]
|
|
1541
2328
|
end
|
|
@@ -1547,6 +2334,7 @@ module TBD
|
|
|
1547
2334
|
next if edge.key?(:psi)
|
|
1548
2335
|
next unless edge.key?(:surfaces)
|
|
1549
2336
|
next unless edge[:surfaces].size == 1
|
|
2337
|
+
|
|
1550
2338
|
id = edge[:surfaces].first.first
|
|
1551
2339
|
next unless holes.key?(id)
|
|
1552
2340
|
next unless holes[id].attributes.key?(:unhinged)
|
|
@@ -1554,9 +2342,11 @@ module TBD
|
|
|
1554
2342
|
|
|
1555
2343
|
subsurface = model.getSubSurfaceByName(id)
|
|
1556
2344
|
next if subsurface.empty?
|
|
2345
|
+
|
|
1557
2346
|
subsurface = subsurface.get
|
|
1558
2347
|
surface = subsurface.surface
|
|
1559
2348
|
next if surface.empty?
|
|
2349
|
+
|
|
1560
2350
|
nom = surface.get.nameString
|
|
1561
2351
|
next unless tbd[:surfaces].key?(nom)
|
|
1562
2352
|
next unless tbd[:surfaces][nom].key?(:conditioned)
|
|
@@ -1570,90 +2360,197 @@ module TBD
|
|
|
1570
2360
|
edge[:set] = json[:io][:building][:psi]
|
|
1571
2361
|
end
|
|
1572
2362
|
|
|
1573
|
-
# A priori, TBD applies (default) :building PSI types and values to
|
|
1574
|
-
# individual edges. If a TBD JSON input file holds custom PSI sets for:
|
|
1575
|
-
# :stories
|
|
1576
|
-
# :spacetypes
|
|
1577
|
-
# :surfaces
|
|
1578
|
-
# :edges
|
|
1579
|
-
# ... that may apply to individual edges, then the default :building PSI
|
|
1580
|
-
# types and/or values are overridden, as follows:
|
|
1581
|
-
# custom :stories PSI sets trump :building PSI sets
|
|
1582
|
-
# custom :spacetypes PSI sets trump aforementioned PSI sets
|
|
1583
|
-
# custom :spaces PSI sets trump aforementioned PSI sets
|
|
1584
|
-
# custom :surfaces PSI sets trump aforementioned PSI sets
|
|
1585
|
-
# custom :edges PSI sets trump aforementioned PSI sets
|
|
1586
2363
|
if json[:io]
|
|
1587
|
-
|
|
2364
|
+
# Reset subsurface U-factors (if on file).
|
|
2365
|
+
if json[:io].key?(:subsurfaces)
|
|
1588
2366
|
json[:io][:subsurfaces].each do |sub|
|
|
2367
|
+
match = false
|
|
1589
2368
|
next unless sub.key?(:id)
|
|
1590
2369
|
next unless sub.key?(:usi)
|
|
1591
|
-
match = false
|
|
1592
2370
|
|
|
1593
2371
|
tbd[:surfaces].values.each do |surface|
|
|
1594
2372
|
break if match
|
|
1595
2373
|
|
|
1596
2374
|
[:windows, :doors, :skylights].each do |types|
|
|
1597
|
-
if
|
|
1598
|
-
|
|
1599
|
-
|
|
1600
|
-
|
|
1601
|
-
|
|
1602
|
-
|
|
1603
|
-
|
|
2375
|
+
break if match
|
|
2376
|
+
next unless surface.key?(types)
|
|
2377
|
+
|
|
2378
|
+
surface[types].each do |id, opening|
|
|
2379
|
+
break if match
|
|
2380
|
+
next unless opening.key?(:u)
|
|
2381
|
+
next unless sub[:id] == id
|
|
2382
|
+
|
|
2383
|
+
opening[:u] = sub[:usi]
|
|
2384
|
+
match = true
|
|
1604
2385
|
end
|
|
1605
2386
|
end
|
|
1606
2387
|
end
|
|
1607
2388
|
end
|
|
1608
2389
|
end
|
|
1609
2390
|
|
|
2391
|
+
# Reset wall-to-roof intersection type (if on file) ... per group.
|
|
2392
|
+
[:stories, :spacetypes, :spaces].each do |groups|
|
|
2393
|
+
key = :story
|
|
2394
|
+
key = :stype if groups == :spacetypes
|
|
2395
|
+
key = :space if groups == :spaces
|
|
2396
|
+
next unless json[:io].key?(groups)
|
|
2397
|
+
|
|
2398
|
+
json[:io][groups].each do |group|
|
|
2399
|
+
next unless group.key?(:id)
|
|
2400
|
+
next unless group.key?(:parapet)
|
|
2401
|
+
|
|
2402
|
+
edges.values.each do |edge|
|
|
2403
|
+
match = false
|
|
2404
|
+
next unless edge.key?(:psi)
|
|
2405
|
+
next unless edge.key?(:surfaces)
|
|
2406
|
+
next if edge.key?(:io_type)
|
|
2407
|
+
|
|
2408
|
+
edge[:surfaces].keys.each do |id|
|
|
2409
|
+
break if match
|
|
2410
|
+
next unless tbd[:surfaces].key?(id)
|
|
2411
|
+
next unless tbd[:surfaces][id].key?(key)
|
|
2412
|
+
|
|
2413
|
+
match = group[:id] == tbd[:surfaces][id][key].nameString
|
|
2414
|
+
end
|
|
2415
|
+
|
|
2416
|
+
next unless match
|
|
2417
|
+
|
|
2418
|
+
parapets = edge[:psi].keys.select {|ty| ty.to_s.include?("parapet")}
|
|
2419
|
+
roofs = edge[:psi].keys.select {|ty| ty.to_s.include?("roof")}
|
|
2420
|
+
|
|
2421
|
+
if group[:parapet]
|
|
2422
|
+
next unless parapets.empty?
|
|
2423
|
+
next if roofs.empty?
|
|
2424
|
+
|
|
2425
|
+
type = :parapet
|
|
2426
|
+
type = :parapetconcave if roofs.first.to_s.include?("concave")
|
|
2427
|
+
type = :parapetconvex if roofs.first.to_s.include?("convex")
|
|
2428
|
+
|
|
2429
|
+
edge[:psi][type] = shorts[:val][type]
|
|
2430
|
+
roofs.each {|ty| edge[:psi].delete(ty)}
|
|
2431
|
+
else
|
|
2432
|
+
next unless roofs.empty?
|
|
2433
|
+
next if parapets.empty?
|
|
2434
|
+
|
|
2435
|
+
type = :roof
|
|
2436
|
+
type = :roofconcave if parapets.first.to_s.include?("concave")
|
|
2437
|
+
type = :roofconvex if parapets.first.to_s.include?("convex")
|
|
2438
|
+
|
|
2439
|
+
edge[:psi][type] = shorts[:val][type]
|
|
2440
|
+
|
|
2441
|
+
parapets.each { |ty| edge[:psi].delete(ty) }
|
|
2442
|
+
end
|
|
2443
|
+
end
|
|
2444
|
+
end
|
|
2445
|
+
end
|
|
2446
|
+
|
|
2447
|
+
# Reset wall-to-roof intersection type (if on file) - individual surfaces.
|
|
2448
|
+
if json[:io].key?(:surfaces)
|
|
2449
|
+
json[:io][:surfaces].each do |surface|
|
|
2450
|
+
next unless surface.key?(:parapet)
|
|
2451
|
+
next unless surface.key?(:id)
|
|
2452
|
+
|
|
2453
|
+
edges.values.each do |edge|
|
|
2454
|
+
next if edge.key?(:io_type)
|
|
2455
|
+
next unless edge.key?(:psi)
|
|
2456
|
+
next unless edge.key?(:surfaces)
|
|
2457
|
+
next unless edge[:surfaces].keys.include?(surface[:id])
|
|
2458
|
+
|
|
2459
|
+
parapets = edge[:psi].keys.select {|ty| ty.to_s.include?("parapet")}
|
|
2460
|
+
roofs = edge[:psi].keys.select {|ty| ty.to_s.include?("roof")}
|
|
2461
|
+
|
|
2462
|
+
|
|
2463
|
+
if surface[:parapet]
|
|
2464
|
+
next unless parapets.empty?
|
|
2465
|
+
next if roofs.empty?
|
|
2466
|
+
|
|
2467
|
+
type = :parapet
|
|
2468
|
+
type = :parapetconcave if roofs.first.to_s.include?("concave")
|
|
2469
|
+
type = :parapetconvex if roofs.first.to_s.include?("convex")
|
|
2470
|
+
|
|
2471
|
+
edge[:psi][type] = shorts[:val][type]
|
|
2472
|
+
roofs.each {|ty| edge[:psi].delete(ty)}
|
|
2473
|
+
else
|
|
2474
|
+
next unless roofs.empty?
|
|
2475
|
+
next if parapets.empty?
|
|
2476
|
+
|
|
2477
|
+
type = :roof
|
|
2478
|
+
type = :roofconcave if parapets.first.to_s.include?("concave")
|
|
2479
|
+
type = :roofconvex if parapets.first.to_s.include?("convex")
|
|
2480
|
+
|
|
2481
|
+
edge[:psi][type] = shorts[:val][type]
|
|
2482
|
+
parapets.each {|ty| edge[:psi].delete(ty)}
|
|
2483
|
+
end
|
|
2484
|
+
end
|
|
2485
|
+
end
|
|
2486
|
+
end
|
|
2487
|
+
|
|
2488
|
+
# A priori, TBD applies (default) :building PSI types and values to
|
|
2489
|
+
# individual edges. If a TBD JSON input file holds custom PSI sets for:
|
|
2490
|
+
# :stories
|
|
2491
|
+
# :spacetypes
|
|
2492
|
+
# :surfaces
|
|
2493
|
+
# :edges
|
|
2494
|
+
# ... that may apply to individual edges, then the default :building PSI
|
|
2495
|
+
# types and/or values are overridden, as follows:
|
|
2496
|
+
# custom :stories PSI sets trump :building PSI sets
|
|
2497
|
+
# custom :spacetypes PSI sets trump aforementioned PSI sets
|
|
2498
|
+
# custom :spaces PSI sets trump aforementioned PSI sets
|
|
2499
|
+
# custom :surfaces PSI sets trump aforementioned PSI sets
|
|
2500
|
+
# custom :edges PSI sets trump aforementioned PSI sets
|
|
1610
2501
|
[:stories, :spacetypes, :spaces].each do |groups|
|
|
1611
2502
|
key = :story
|
|
1612
2503
|
key = :stype if groups == :spacetypes
|
|
1613
2504
|
key = :space if groups == :spaces
|
|
1614
|
-
next
|
|
2505
|
+
next unless json[:io].key?(groups)
|
|
1615
2506
|
|
|
1616
2507
|
json[:io][groups].each do |group|
|
|
1617
2508
|
next unless group.key?(:id)
|
|
1618
2509
|
next unless group.key?(:psi)
|
|
1619
2510
|
next unless json[:psi].set.key?(group[:psi])
|
|
1620
|
-
|
|
1621
|
-
|
|
2511
|
+
|
|
2512
|
+
sh = json[:psi].shorthands(group[:psi])
|
|
2513
|
+
next if sh[:val].empty?
|
|
1622
2514
|
|
|
1623
2515
|
edges.values.each do |edge|
|
|
1624
|
-
|
|
2516
|
+
match = false
|
|
1625
2517
|
next unless edge.key?(:psi)
|
|
1626
2518
|
next unless edge.key?(:surfaces)
|
|
2519
|
+
next if edge.key?(:io_set)
|
|
1627
2520
|
|
|
1628
2521
|
edge[:surfaces].keys.each do |id|
|
|
2522
|
+
break if match
|
|
1629
2523
|
next unless tbd[:surfaces].key?(id)
|
|
1630
2524
|
next unless tbd[:surfaces][id].key?(key)
|
|
1631
|
-
next unless group[:id] == tbd[:surfaces][id][key].nameString
|
|
1632
2525
|
|
|
1633
|
-
|
|
1634
|
-
|
|
1635
|
-
set = {}
|
|
2526
|
+
match = group[:id] == tbd[:surfaces][id][key].nameString
|
|
2527
|
+
end
|
|
1636
2528
|
|
|
1637
|
-
|
|
1638
|
-
|
|
1639
|
-
|
|
1640
|
-
|
|
1641
|
-
|
|
1642
|
-
safer = json[:psi].safe(group[:psi], type)
|
|
1643
|
-
set[type] = sh[:val][safer] if safer
|
|
1644
|
-
end
|
|
1645
|
-
end
|
|
2529
|
+
next unless match
|
|
2530
|
+
|
|
2531
|
+
set = {}
|
|
2532
|
+
edge[groups] = {} unless edge.key?(groups)
|
|
2533
|
+
edge[groups][group[:psi]] = {}
|
|
1646
2534
|
|
|
1647
|
-
|
|
2535
|
+
if edge.key?(:io_type)
|
|
2536
|
+
safer = json[:psi].safe(group[:psi], edge[:io_type])
|
|
2537
|
+
set[edge[:io_type]] = sh[:val][safer] if safer
|
|
2538
|
+
else
|
|
2539
|
+
edge[:psi].keys.each do |type|
|
|
2540
|
+
safer = json[:psi].safe(group[:psi], type)
|
|
2541
|
+
set[type] = sh[:val][safer] if safer
|
|
2542
|
+
end
|
|
1648
2543
|
end
|
|
2544
|
+
|
|
2545
|
+
edge[groups][group[:psi]] = set unless set.empty?
|
|
1649
2546
|
end
|
|
1650
2547
|
end
|
|
1651
2548
|
|
|
1652
2549
|
# TBD/Topolys edges will generally be linked to more than one surface
|
|
1653
|
-
# and hence to more than one
|
|
1654
|
-
# to hold 2x
|
|
1655
|
-
# common to both
|
|
1656
|
-
# PSI type/value from either
|
|
2550
|
+
# and hence to more than one group. It is possible for a TBD JSON file
|
|
2551
|
+
# to hold 2x group PSI sets that end up targetting one or more edges
|
|
2552
|
+
# common to both groups. In such cases, TBD retains the most conductive
|
|
2553
|
+
# PSI type/value from either group PSI set.
|
|
1657
2554
|
edges.values.each do |edge|
|
|
1658
2555
|
next unless edge.key?(:psi)
|
|
1659
2556
|
next unless edge.key?(groups)
|
|
@@ -1662,13 +2559,15 @@ module TBD
|
|
|
1662
2559
|
vals = {}
|
|
1663
2560
|
|
|
1664
2561
|
edge[groups].keys.each do |set|
|
|
1665
|
-
sh
|
|
1666
|
-
next if
|
|
2562
|
+
sh = json[:psi].shorthands(set)
|
|
2563
|
+
next if sh[:val].empty?
|
|
2564
|
+
|
|
1667
2565
|
safer = json[:psi].safe(set, type)
|
|
1668
2566
|
vals[set] = sh[:val][safer] if safer
|
|
1669
2567
|
end
|
|
1670
2568
|
|
|
1671
|
-
next if
|
|
2569
|
+
next if vals.empty?
|
|
2570
|
+
|
|
1672
2571
|
edge[:psi ][type] = vals.values.max
|
|
1673
2572
|
edge[:sets] = {} unless edge.key?(:sets)
|
|
1674
2573
|
edge[:sets][type] = vals.key(vals.values.max)
|
|
@@ -1678,35 +2577,37 @@ module TBD
|
|
|
1678
2577
|
|
|
1679
2578
|
if json[:io].key?(:surfaces)
|
|
1680
2579
|
json[:io][:surfaces].each do |surface|
|
|
1681
|
-
next unless surface.key?(:id)
|
|
1682
2580
|
next unless surface.key?(:psi)
|
|
2581
|
+
next unless surface.key?(:id)
|
|
2582
|
+
next unless tbd[:surfaces].key?(surface[:id ])
|
|
1683
2583
|
next unless json[:psi].set.key?(surface[:psi])
|
|
1684
|
-
|
|
1685
|
-
|
|
2584
|
+
|
|
2585
|
+
sh = json[:psi].shorthands(surface[:psi])
|
|
2586
|
+
next if sh[:val].empty?
|
|
1686
2587
|
|
|
1687
2588
|
edges.values.each do |edge|
|
|
1688
2589
|
next if edge.key?(:io_set)
|
|
1689
2590
|
next unless edge.key?(:psi)
|
|
1690
2591
|
next unless edge.key?(:surfaces)
|
|
2592
|
+
next unless edge[:surfaces].keys.include?(surface[:id])
|
|
1691
2593
|
|
|
1692
|
-
edge[:surfaces]
|
|
1693
|
-
|
|
1694
|
-
next unless surface[:id] == id
|
|
1695
|
-
set = {}
|
|
2594
|
+
s = edge[:surfaces][surface[:id]]
|
|
2595
|
+
set = {}
|
|
1696
2596
|
|
|
1697
|
-
|
|
1698
|
-
|
|
1699
|
-
|
|
1700
|
-
|
|
1701
|
-
|
|
1702
|
-
|
|
1703
|
-
|
|
1704
|
-
end
|
|
2597
|
+
if edge.key?(:io_type)
|
|
2598
|
+
safer = json[:psi].safe(surface[:psi], edge[:io_type])
|
|
2599
|
+
set[:io_type] = sh[:val][safer] if safer
|
|
2600
|
+
else
|
|
2601
|
+
edge[:psi].keys.each do |type|
|
|
2602
|
+
safer = json[:psi].safe(surface[:psi], type)
|
|
2603
|
+
set[type] = sh[:val][safer] if safer
|
|
1705
2604
|
end
|
|
1706
|
-
|
|
1707
|
-
s[:psi] = set unless set.empty?
|
|
1708
|
-
s[:set] = surface[:psi] unless set.empty?
|
|
1709
2605
|
end
|
|
2606
|
+
|
|
2607
|
+
next if set.empty?
|
|
2608
|
+
|
|
2609
|
+
s[:psi] = set
|
|
2610
|
+
s[:set] = surface[:psi]
|
|
1710
2611
|
end
|
|
1711
2612
|
end
|
|
1712
2613
|
|
|
@@ -1721,17 +2622,20 @@ module TBD
|
|
|
1721
2622
|
vals = {}
|
|
1722
2623
|
|
|
1723
2624
|
edge[:surfaces].each do |id, s|
|
|
1724
|
-
next
|
|
1725
|
-
next
|
|
1726
|
-
next
|
|
1727
|
-
|
|
1728
|
-
|
|
2625
|
+
next unless s.key?(:psi)
|
|
2626
|
+
next unless s.key?(:set)
|
|
2627
|
+
next if s[:set].empty?
|
|
2628
|
+
|
|
2629
|
+
sh = json[:psi].shorthands(s[:set])
|
|
2630
|
+
next if sh[:val].empty?
|
|
2631
|
+
|
|
1729
2632
|
safer = json[:psi].safe(s[:set], type)
|
|
1730
2633
|
vals[s[:set]] = sh[:val][safer] if safer
|
|
1731
2634
|
end
|
|
1732
2635
|
|
|
1733
|
-
next
|
|
1734
|
-
|
|
2636
|
+
next if vals.empty?
|
|
2637
|
+
|
|
2638
|
+
edge[:psi ][type] = vals.values.max
|
|
1735
2639
|
edge[:sets] = {} unless edge.key?(:sets)
|
|
1736
2640
|
edge[:sets][type] = vals.key(vals.values.max)
|
|
1737
2641
|
end
|
|
@@ -1746,15 +2650,18 @@ module TBD
|
|
|
1746
2650
|
|
|
1747
2651
|
if edge.key?(:io_set)
|
|
1748
2652
|
next unless json[:psi].set.key?(edge[:io_set])
|
|
2653
|
+
|
|
1749
2654
|
set = edge[:io_set]
|
|
1750
2655
|
else
|
|
1751
2656
|
next unless edge[:sets].key?(edge[:io_type])
|
|
1752
2657
|
next unless json[:psi].set.key?(edge[:sets][edge[:io_type]])
|
|
2658
|
+
|
|
1753
2659
|
set = edge[:sets][edge[:io_type]]
|
|
1754
2660
|
end
|
|
1755
2661
|
|
|
1756
2662
|
sh = json[:psi].shorthands(set)
|
|
1757
2663
|
next if sh[:val].empty?
|
|
2664
|
+
|
|
1758
2665
|
safer = json[:psi].safe(set, edge[:io_type])
|
|
1759
2666
|
next unless safer
|
|
1760
2667
|
|
|
@@ -1772,9 +2679,10 @@ module TBD
|
|
|
1772
2679
|
|
|
1773
2680
|
# Fetch edge multipliers for subsurfaces, if applicable.
|
|
1774
2681
|
edges.values.each do |edge|
|
|
1775
|
-
next if edge.key?(:mult)
|
|
2682
|
+
next if edge.key?(:mult) # skip if already assigned
|
|
1776
2683
|
next unless edge.key?(:surfaces)
|
|
1777
2684
|
next unless edge.key?(:psi)
|
|
2685
|
+
|
|
1778
2686
|
ok = false
|
|
1779
2687
|
|
|
1780
2688
|
edge[:psi].keys.each do |k|
|
|
@@ -1786,10 +2694,10 @@ module TBD
|
|
|
1786
2694
|
ok = jamb || sill || head
|
|
1787
2695
|
end
|
|
1788
2696
|
|
|
1789
|
-
next unless ok
|
|
2697
|
+
next unless ok # if OK, edge links subsurface(s) ... yet which one(s)?
|
|
1790
2698
|
|
|
1791
2699
|
edge[:surfaces].each do |id, surface|
|
|
1792
|
-
next unless tbd[:surfaces].key?(id)
|
|
2700
|
+
next unless tbd[:surfaces].key?(id) # look up parent (opaque) surface
|
|
1793
2701
|
|
|
1794
2702
|
[:windows, :doors, :skylights].each do |subtypes|
|
|
1795
2703
|
next unless tbd[:surfaces][id].key?(subtypes)
|
|
@@ -1801,7 +2709,7 @@ module TBD
|
|
|
1801
2709
|
# An edge may be tagged with (potentially conflicting) multipliers.
|
|
1802
2710
|
# This is only possible if the edge links 2 subsurfaces, e.g. a
|
|
1803
2711
|
# shared jamb between window & door. By default, TBD tags common
|
|
1804
|
-
# subsurface edges as (mild) "transitions" (i.e. PSI 0 W/K
|
|
2712
|
+
# subsurface edges as (mild) "transitions" (i.e. PSI 0 W/K•m), so
|
|
1805
2713
|
# there would be no point in assigning an edge multiplier. Users
|
|
1806
2714
|
# can however reset an edge type via a TBD JSON input file (e.g.
|
|
1807
2715
|
# "joint" instead of "transition"). It would be a very odd choice,
|
|
@@ -1820,9 +2728,9 @@ module TBD
|
|
|
1820
2728
|
# edges' origin and terminal vertices must be in close proximity. Edges
|
|
1821
2729
|
# of unhinged subsurfaces are ignored.
|
|
1822
2730
|
edges.each do |id, edge|
|
|
1823
|
-
nb = 0
|
|
2731
|
+
nb = 0 # linked subsurfaces (i.e. "holes")
|
|
1824
2732
|
match = false
|
|
1825
|
-
next if edge.key?(:io_type)
|
|
2733
|
+
next if edge.key?(:io_type) # skip if set in JSON
|
|
1826
2734
|
next unless edge.key?(:v0)
|
|
1827
2735
|
next unless edge.key?(:v1)
|
|
1828
2736
|
next unless edge.key?(:psi)
|
|
@@ -1879,6 +2787,7 @@ module TBD
|
|
|
1879
2787
|
# Loop through each edge and assign heat loss to linked surfaces.
|
|
1880
2788
|
edges.each do |identifier, edge|
|
|
1881
2789
|
next unless edge.key?(:psi)
|
|
2790
|
+
|
|
1882
2791
|
rsi = 0
|
|
1883
2792
|
max = edge[:psi ].values.max
|
|
1884
2793
|
type = edge[:psi ].key(max)
|
|
@@ -1896,11 +2805,12 @@ module TBD
|
|
|
1896
2805
|
edge[:surfaces].each do |id, s|
|
|
1897
2806
|
next unless tbd[:surfaces].key?(id)
|
|
1898
2807
|
next unless tbd[:surfaces][id][:deratable]
|
|
2808
|
+
|
|
1899
2809
|
deratables[id] = s
|
|
1900
2810
|
end
|
|
1901
2811
|
|
|
1902
2812
|
edge[:surfaces].each { |id, s| apertures[id] = s if holes.key?(id) }
|
|
1903
|
-
next if apertures.size > 1
|
|
2813
|
+
next if apertures.size > 1 # edge links 2x openings
|
|
1904
2814
|
|
|
1905
2815
|
# Prune dad if edge links an opening, its dad and an uncle.
|
|
1906
2816
|
if deratables.size > 1 && apertures.size > 0
|
|
@@ -1920,6 +2830,7 @@ module TBD
|
|
|
1920
2830
|
# Sum RSI of targeted insulating layer from each deratable surface.
|
|
1921
2831
|
deratables.each do |id, deratable|
|
|
1922
2832
|
next unless tbd[:surfaces][id].key?(:r)
|
|
2833
|
+
|
|
1923
2834
|
rsi += tbd[:surfaces][id][:r]
|
|
1924
2835
|
end
|
|
1925
2836
|
|
|
@@ -1938,8 +2849,10 @@ module TBD
|
|
|
1938
2849
|
# Assign thermal bridging heat loss [in W/K] to each deratable surface.
|
|
1939
2850
|
tbd[:surfaces].each do |id, surface|
|
|
1940
2851
|
next unless surface.key?(:edges)
|
|
2852
|
+
|
|
1941
2853
|
surface[:heatloss] = 0
|
|
1942
2854
|
e = surface[:edges].values
|
|
2855
|
+
|
|
1943
2856
|
e.each { |edge| surface[:heatloss] += edge[:psi] * edge[:length] }
|
|
1944
2857
|
end
|
|
1945
2858
|
|
|
@@ -1959,9 +2872,11 @@ module TBD
|
|
|
1959
2872
|
next unless k.key?(:count)
|
|
1960
2873
|
next unless json[:khi].point.key?(k[:id])
|
|
1961
2874
|
next unless json[:khi].point[k[:id]] > 0.001
|
|
1962
|
-
|
|
1963
|
-
s[:heatloss]
|
|
1964
|
-
s[:
|
|
2875
|
+
|
|
2876
|
+
s[:heatloss] = 0 unless s.key?(:heatloss)
|
|
2877
|
+
s[:heatloss] += json[:khi].point[k[:id]] * k[:count]
|
|
2878
|
+
s[:pts ] = {} unless s.key?(:pts)
|
|
2879
|
+
|
|
1965
2880
|
s[:pts][k[:id]] = { val: json[:khi].point[k[:id]], n: k[:count] }
|
|
1966
2881
|
end
|
|
1967
2882
|
end
|
|
@@ -1970,8 +2885,8 @@ module TBD
|
|
|
1970
2885
|
# If user has selected a Ut to meet, e.g. argh'ments:
|
|
1971
2886
|
# :uprate_walls
|
|
1972
2887
|
# :wall_ut
|
|
1973
|
-
# :wall_option
|
|
1974
|
-
#
|
|
2888
|
+
# :wall_option ... (same triple arguments for roofs and exposed floors)
|
|
2889
|
+
#
|
|
1975
2890
|
# ... first 'uprate' targeted insulation layers (see ua.rb) before derating.
|
|
1976
2891
|
# Check for new argh keys [:wall_uo], [:roof_uo] and/or [:floor_uo].
|
|
1977
2892
|
up = argh[:uprate_walls] || argh[:uprate_roofs] || argh[:uprate_floors]
|
|
@@ -1985,74 +2900,75 @@ module TBD
|
|
|
1985
2900
|
# (or rather layered materials) having " tbd" in their OpenStudio name.
|
|
1986
2901
|
tbd[:surfaces].each do |id, surface|
|
|
1987
2902
|
next unless surface.key?(:construction)
|
|
1988
|
-
next unless surface.key?(:index
|
|
1989
|
-
next unless surface.key?(:ltype
|
|
1990
|
-
next unless surface.key?(:r
|
|
1991
|
-
next unless surface.key?(:edges
|
|
1992
|
-
next unless surface.key?(:heatloss
|
|
2903
|
+
next unless surface.key?(:index)
|
|
2904
|
+
next unless surface.key?(:ltype)
|
|
2905
|
+
next unless surface.key?(:r)
|
|
2906
|
+
next unless surface.key?(:edges)
|
|
2907
|
+
next unless surface.key?(:heatloss)
|
|
1993
2908
|
next unless surface[:heatloss].abs > TOL
|
|
1994
2909
|
|
|
1995
|
-
model.
|
|
1996
|
-
|
|
1997
|
-
|
|
1998
|
-
|
|
1999
|
-
|
|
2000
|
-
|
|
2001
|
-
|
|
2002
|
-
|
|
2003
|
-
|
|
2004
|
-
|
|
2005
|
-
|
|
2006
|
-
|
|
2007
|
-
|
|
2008
|
-
|
|
2009
|
-
|
|
2010
|
-
|
|
2011
|
-
|
|
2012
|
-
|
|
2013
|
-
|
|
2014
|
-
|
|
2015
|
-
|
|
2016
|
-
|
|
2017
|
-
|
|
2018
|
-
|
|
2019
|
-
|
|
2020
|
-
|
|
2021
|
-
|
|
2022
|
-
|
|
2023
|
-
|
|
2024
|
-
|
|
2025
|
-
|
|
2026
|
-
|
|
2027
|
-
|
|
2028
|
-
|
|
2029
|
-
|
|
2030
|
-
|
|
2031
|
-
|
|
2032
|
-
|
|
2033
|
-
|
|
2034
|
-
|
|
2035
|
-
|
|
2036
|
-
|
|
2037
|
-
|
|
2038
|
-
|
|
2039
|
-
|
|
2040
|
-
|
|
2041
|
-
|
|
2042
|
-
|
|
2043
|
-
|
|
2044
|
-
|
|
2910
|
+
s = model.getSurfaceByName(id)
|
|
2911
|
+
next if s.empty?
|
|
2912
|
+
|
|
2913
|
+
s = s.get
|
|
2914
|
+
|
|
2915
|
+
index = surface[:index ]
|
|
2916
|
+
current_c = surface[:construction]
|
|
2917
|
+
c = current_c.clone(model).to_LayeredConstruction.get
|
|
2918
|
+
m = nil
|
|
2919
|
+
m = derate(id, surface, c) if index
|
|
2920
|
+
# m may be nilled simply because the targeted construction has already
|
|
2921
|
+
# been derated, i.e. holds " tbd" in its name. Names of cloned/derated
|
|
2922
|
+
# constructions (due to TBD) include the surface name (since derated
|
|
2923
|
+
# constructions are now unique to each surface) and the suffix " c tbd".
|
|
2924
|
+
if m
|
|
2925
|
+
c.setLayer(index, m)
|
|
2926
|
+
c.setName("#{id} c tbd")
|
|
2927
|
+
current_R = rsi(current_c, s.filmResistance)
|
|
2928
|
+
|
|
2929
|
+
# In principle, the derated "ratio" could be calculated simply by
|
|
2930
|
+
# accessing a surface's uFactor. Yet air layers within constructions
|
|
2931
|
+
# (not air films) are ignored in OpenStudio's uFactor calculation.
|
|
2932
|
+
# An example would be 25mm-50mm pressure-equalized air gaps behind
|
|
2933
|
+
# brick veneer. This is not always compliant to some energy codes.
|
|
2934
|
+
# TBD currently factors-in air gap (and exterior cladding) R-values.
|
|
2935
|
+
#
|
|
2936
|
+
# If one comments out the following loop (3 lines), tested surfaces
|
|
2937
|
+
# with air layers will generate discrepencies between the calculed RSi
|
|
2938
|
+
# value above and the inverse of the uFactor. All other surface
|
|
2939
|
+
# constructions pass the test.
|
|
2940
|
+
#
|
|
2941
|
+
# if ((1/current_R) - s.uFactor.to_f).abs > 0.005
|
|
2942
|
+
# puts "#{s.nameString} - Usi:#{1/current_R} UFactor: #{s.uFactor}"
|
|
2943
|
+
# end
|
|
2944
|
+
s.setConstruction(c)
|
|
2945
|
+
|
|
2946
|
+
# If the derated surface construction separates CONDITIONED space from
|
|
2947
|
+
# UNCONDITIONED or UNENCLOSED space, then derate the adjacent surface
|
|
2948
|
+
# construction as well (unless defaulted).
|
|
2949
|
+
if s.outsideBoundaryCondition.downcase == "surface"
|
|
2950
|
+
unless s.adjacentSurface.empty?
|
|
2951
|
+
adjacent = s.adjacentSurface.get
|
|
2952
|
+
nom = adjacent.nameString
|
|
2953
|
+
default = adjacent.isConstructionDefaulted == false
|
|
2954
|
+
|
|
2955
|
+
if default && tbd[:surfaces].key?(nom)
|
|
2956
|
+
current_cc = tbd[:surfaces][nom][:construction]
|
|
2957
|
+
cc = current_cc.clone(model).to_LayeredConstruction.get
|
|
2958
|
+
cc.setLayer(tbd[:surfaces][nom][:index], m)
|
|
2959
|
+
cc.setName("#{nom} c tbd")
|
|
2960
|
+
adjacent.setConstruction(cc)
|
|
2045
2961
|
end
|
|
2046
2962
|
end
|
|
2963
|
+
end
|
|
2047
2964
|
|
|
2048
|
-
|
|
2049
|
-
|
|
2050
|
-
|
|
2051
|
-
|
|
2965
|
+
# Compute updated RSi value from layers.
|
|
2966
|
+
updated_c = s.construction.get.to_LayeredConstruction.get
|
|
2967
|
+
updated_R = rsi(updated_c, s.filmResistance)
|
|
2968
|
+
ratio = -(current_R - updated_R) * 100 / current_R
|
|
2052
2969
|
|
|
2053
|
-
|
|
2054
|
-
|
|
2055
|
-
end
|
|
2970
|
+
surface[:ratio] = ratio if ratio.abs > TOL
|
|
2971
|
+
surface[:u ] = 1 / current_R # un-derated U-factors (for UA')
|
|
2056
2972
|
end
|
|
2057
2973
|
end
|
|
2058
2974
|
|
|
@@ -2061,9 +2977,12 @@ module TBD
|
|
|
2061
2977
|
next unless surface[:deratable]
|
|
2062
2978
|
next unless surface.key?(:construction)
|
|
2063
2979
|
next if surface.key?(:u)
|
|
2064
|
-
|
|
2065
|
-
|
|
2066
|
-
|
|
2980
|
+
|
|
2981
|
+
s = model.getSurfaceByName(id)
|
|
2982
|
+
msg = "Skipping missing surface '#{id}' (#{mth})"
|
|
2983
|
+
log(ERR, msg) if s.empty?
|
|
2984
|
+
next if s.empty?
|
|
2985
|
+
|
|
2067
2986
|
surface[:u] = 1.0 / rsi(surface[:construction], s.get.filmResistance)
|
|
2068
2987
|
end
|
|
2069
2988
|
|
|
@@ -2075,14 +2994,16 @@ module TBD
|
|
|
2075
2994
|
# 4. edge origin & end vertices
|
|
2076
2995
|
# 5. array of linked outside- or ground-facing surfaces
|
|
2077
2996
|
edges.values.each do |e|
|
|
2078
|
-
next
|
|
2079
|
-
next
|
|
2080
|
-
|
|
2081
|
-
|
|
2082
|
-
|
|
2083
|
-
|
|
2084
|
-
l
|
|
2085
|
-
|
|
2997
|
+
next unless e.key?(:psi)
|
|
2998
|
+
next unless e.key?(:set)
|
|
2999
|
+
|
|
3000
|
+
v = e[:psi].values.max
|
|
3001
|
+
set = e[:set]
|
|
3002
|
+
t = e[:psi].key(v)
|
|
3003
|
+
l = e[:length]
|
|
3004
|
+
l *= e[:mult] if e.key?(:mult)
|
|
3005
|
+
edge = { psi: set, type: t, length: l, surfaces: e[:surfaces].keys }
|
|
3006
|
+
|
|
2086
3007
|
edge[:v0x] = e[:v0].point.x
|
|
2087
3008
|
edge[:v0y] = e[:v0].point.y
|
|
2088
3009
|
edge[:v0z] = e[:v0].point.z
|
|
@@ -2093,42 +3014,71 @@ module TBD
|
|
|
2093
3014
|
json[:io][:edges] << edge
|
|
2094
3015
|
end
|
|
2095
3016
|
|
|
2096
|
-
|
|
2097
|
-
|
|
2098
|
-
|
|
2099
|
-
|
|
3017
|
+
if json[:io][:edges].empty?
|
|
3018
|
+
json[:io].delete(:edges)
|
|
3019
|
+
else
|
|
3020
|
+
json[:io][:edges].sort_by { |e| [ e[:v0x], e[:v0y], e[:v0z],
|
|
3021
|
+
e[:v1x], e[:v1y], e[:v1z] ] }
|
|
3022
|
+
end
|
|
2100
3023
|
|
|
2101
3024
|
# Populate UA' trade-off reference values (optional).
|
|
2102
|
-
|
|
2103
|
-
|
|
3025
|
+
if argh[:gen_ua] && argh[:ua_ref]
|
|
3026
|
+
case argh[:ua_ref]
|
|
3027
|
+
when "code (Quebec)"
|
|
3028
|
+
qc33(tbd[:surfaces], json[:psi], argh[:setpoints])
|
|
3029
|
+
end
|
|
3030
|
+
end
|
|
2104
3031
|
|
|
2105
|
-
tbd[:io] = json[:io]
|
|
3032
|
+
tbd[:io ] = json[:io ]
|
|
3033
|
+
argh[:io ] = tbd[:io ]
|
|
3034
|
+
argh[:surfaces] = tbd[:surfaces]
|
|
3035
|
+
argh[:version ] = model.getVersion.versionIdentifier
|
|
2106
3036
|
|
|
2107
3037
|
tbd
|
|
2108
3038
|
end
|
|
2109
3039
|
|
|
2110
3040
|
##
|
|
2111
|
-
# TBD
|
|
2112
|
-
#
|
|
2113
|
-
# (see tbd.out.json).
|
|
3041
|
+
# Exits TBD Measures. Writes out TBD model content and results if requested.
|
|
3042
|
+
# Always writes out minimal logs (see "tbd.out.json" file).
|
|
2114
3043
|
#
|
|
2115
3044
|
# @param runner [Runner] OpenStudio Measure runner
|
|
2116
|
-
# @param
|
|
3045
|
+
# @param [Hash] argh TBD arguments
|
|
3046
|
+
# @option argh [Hash] :io TBD input/output variables (see TBD JSON schema)
|
|
3047
|
+
# @option argh [Hash] :surfaces TBD surfaces (keys: Openstudio surface names)
|
|
3048
|
+
# @option argh [#to_s] :seed OpenStudio file, e.g. "school23.osm"
|
|
3049
|
+
# @option argh [#to_s] :version :version OpenStudio SDK, e.g. "3.6.1"
|
|
3050
|
+
# @option argh [Bool] :gen_ua whether to generate a UA' report
|
|
3051
|
+
# @option argh [#to_s] :ua_ref selected UA' ruleset
|
|
3052
|
+
# @option argh [Bool] :setpoints whether OpenStudio model holds setpoints
|
|
3053
|
+
# @option argh [Bool] :write_tbd whether to output a JSON file
|
|
3054
|
+
# @option argh [Bool] :uprate_walls whether to uprate walls
|
|
3055
|
+
# @option argh [Bool] :uprate_roofs whether to uprate roofs
|
|
3056
|
+
# @option argh [Bool] :uprate_floors whether to uprate floors
|
|
3057
|
+
# @option argh [#to_f] :wall_ut uprated wall Ut target in W/m2•K
|
|
3058
|
+
# @option argh [#to_f] :roof_ut uprated roof Ut target in W/m2•K
|
|
3059
|
+
# @option argh [#to_f] :floor_ut uprated floor Ut target in W/m2•K
|
|
3060
|
+
# @option argh [#to_s] :wall_option wall construction to uprate (or "all")
|
|
3061
|
+
# @option argh [#to_s] :roof_option roof construction to uprate (or "all")
|
|
3062
|
+
# @option argh [#to_s] :floor_option floor construction to uprate (or "all")
|
|
3063
|
+
# @option argh [#to_f] :wall_uo required wall Uo to achieve Ut in W/m2•K
|
|
3064
|
+
# @option argh [#to_f] :roof_uo required roof Uo to achieve Ut in W/m2•K
|
|
3065
|
+
# @option argh [#to_f] :floor_uo required floor Uo to achieve Ut in W/m2•K
|
|
2117
3066
|
#
|
|
2118
|
-
# @return [Bool]
|
|
3067
|
+
# @return [Bool] whether TBD Measure is successful (see logs)
|
|
2119
3068
|
def exit(runner = nil, argh = {})
|
|
2120
3069
|
# Generated files target a design context ( >= WARN ) ... change TBD log
|
|
2121
3070
|
# level for debugging purposes. By default, log status is set < DBG
|
|
2122
3071
|
# while log level is set @INF.
|
|
2123
|
-
|
|
2124
|
-
state
|
|
3072
|
+
groups = { wall: {}, roof: {}, floor: {} }
|
|
3073
|
+
state = msg(status)
|
|
3074
|
+
state = msg(INF) if status.zero?
|
|
2125
3075
|
argh = {} unless argh.is_a?(Hash)
|
|
2126
3076
|
argh[:io ] = nil unless argh.key?(:io)
|
|
2127
3077
|
argh[:surfaces] = nil unless argh.key?(:surfaces)
|
|
2128
3078
|
|
|
2129
3079
|
unless argh[:io] && argh[:surfaces]
|
|
2130
3080
|
state = "Halting all TBD processes, yet running OpenStudio"
|
|
2131
|
-
state = "Halting all TBD processes, and halting OpenStudio"
|
|
3081
|
+
state = "Halting all TBD processes, and halting OpenStudio" if fatal?
|
|
2132
3082
|
end
|
|
2133
3083
|
|
|
2134
3084
|
argh[:io ] = {} unless argh[:io]
|
|
@@ -2151,7 +3101,6 @@ module TBD
|
|
|
2151
3101
|
argh[:roof_uo ] = nil unless argh.key?(:roof_ut )
|
|
2152
3102
|
argh[:floor_uo ] = nil unless argh.key?(:floor_ut )
|
|
2153
3103
|
|
|
2154
|
-
groups = { wall: {}, roof: {}, floor: {} }
|
|
2155
3104
|
groups[:wall ][:up] = argh[:uprate_walls ]
|
|
2156
3105
|
groups[:roof ][:up] = argh[:uprate_roofs ]
|
|
2157
3106
|
groups[:floor][:up] = argh[:uprate_floors]
|
|
@@ -2184,7 +3133,7 @@ module TBD
|
|
|
2184
3133
|
|
|
2185
3134
|
uo = format("%.3f", g[:uo])
|
|
2186
3135
|
ut = format("%.3f", g[:ut])
|
|
2187
|
-
output = "An initial #{label.to_s} Uo of #{uo} W/m2•K is required to "
|
|
3136
|
+
output = "An initial #{label.to_s} Uo of #{uo} W/m2•K is required to " \
|
|
2188
3137
|
"achieve an overall Ut of #{ut} W/m2•K for #{g[:op]}"
|
|
2189
3138
|
u_t << output
|
|
2190
3139
|
runner.registerInfo(output)
|
|
@@ -2195,16 +3144,16 @@ module TBD
|
|
|
2195
3144
|
ua_md_fr = nil
|
|
2196
3145
|
ua = nil
|
|
2197
3146
|
ok = argh[:surfaces] && argh[:gen_ua]
|
|
2198
|
-
ua = ua_summary(tbd_log[:date], argh)
|
|
3147
|
+
ua = ua_summary(tbd_log[:date], argh) if ok
|
|
2199
3148
|
|
|
2200
3149
|
unless fatal? || ua.nil? || ua.empty?
|
|
2201
3150
|
if ua.key?(:en)
|
|
2202
3151
|
if ua[:en].key?(:b1) || ua[:en].key?(:b2)
|
|
3152
|
+
tbd_log[:ua] = {}
|
|
2203
3153
|
runner.registerInfo("-")
|
|
2204
3154
|
runner.registerInfo(ua[:model])
|
|
2205
|
-
|
|
2206
|
-
|
|
2207
|
-
ua_md_fr = ua_md(ua, :fr)
|
|
3155
|
+
ua_md_en = ua_md(ua, :en)
|
|
3156
|
+
ua_md_fr = ua_md(ua, :fr)
|
|
2208
3157
|
end
|
|
2209
3158
|
|
|
2210
3159
|
if ua[:en].key?(:b1) && ua[:en][:b1].key?(:summary)
|
|
@@ -2237,9 +3186,9 @@ module TBD
|
|
|
2237
3186
|
argh[:surfaces].each do |id, surface|
|
|
2238
3187
|
next if fatal?
|
|
2239
3188
|
next unless surface.key?(:ratio)
|
|
2240
|
-
ratio = format("%4.1f", surface[:ratio])
|
|
2241
|
-
output = "RSi derated by #{ratio}% : #{id}"
|
|
2242
3189
|
|
|
3190
|
+
ratio = format("%4.1f", surface[:ratio])
|
|
3191
|
+
output = "RSi derated by #{ratio}% : #{id}"
|
|
2243
3192
|
results << output
|
|
2244
3193
|
runner.registerInfo(output)
|
|
2245
3194
|
end
|
|
@@ -2285,14 +3234,14 @@ module TBD
|
|
|
2285
3234
|
file_paths = runner.workflow.absoluteFilePaths
|
|
2286
3235
|
|
|
2287
3236
|
# 'Apply Measure Now' won't cp files from 1st path back to generated_files.
|
|
2288
|
-
match1 = /WorkingFiles/.match(file_paths[1].to_s)
|
|
2289
|
-
match2 = /files/.match(file_paths[1].to_s)
|
|
3237
|
+
match1 = /WorkingFiles/.match(file_paths[1].to_s.strip)
|
|
3238
|
+
match2 = /files/.match(file_paths[1].to_s.strip)
|
|
2290
3239
|
match = match1 || match2
|
|
2291
3240
|
|
|
2292
|
-
if file_paths.size >= 2 && File.exists?(file_paths[1].to_s) && match
|
|
2293
|
-
out_dir = file_paths[1].to_s
|
|
2294
|
-
elsif !file_paths.empty? && File.exists?(file_paths.first.to_s)
|
|
2295
|
-
out_dir = file_paths.first.to_s
|
|
3241
|
+
if file_paths.size >= 2 && File.exists?(file_paths[1].to_s.strip) && match
|
|
3242
|
+
out_dir = file_paths[1].to_s.strip
|
|
3243
|
+
elsif !file_paths.empty? && File.exists?(file_paths.first.to_s.strip)
|
|
3244
|
+
out_dir = file_paths.first.to_s.strip
|
|
2296
3245
|
end
|
|
2297
3246
|
|
|
2298
3247
|
out_path = File.join(out_dir, "tbd.out.json")
|
|
@@ -2307,7 +3256,7 @@ module TBD
|
|
|
2307
3256
|
end
|
|
2308
3257
|
end
|
|
2309
3258
|
|
|
2310
|
-
unless
|
|
3259
|
+
unless fatal? || ua.nil? || ua.empty?
|
|
2311
3260
|
unless ua_md_en.nil? || ua_md_en.empty?
|
|
2312
3261
|
ua_path = File.join(out_dir, "ua_en.md")
|
|
2313
3262
|
|