tbd 3.1.0 → 3.2.0

data/lib/measures/tbd/resources/psi.rb

@@ -1,6 +1,6 @@
 # MIT License
 #
-# Copyright (c) 2020-2022 Denis Bourgeois & Dan Macumber
+# Copyright (c) 2020-2023 Denis Bourgeois & Dan Macumber
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -211,7 +211,7 @@ module TBD
         grade:         0.450, # *
         joint:         0.200, # *
         transition:    0.000
-      }.freeze               # based on EXTERIOR dimensions (art. 3.1.1.6)
+      }.freeze
       self.gen("code (Quebec)")
 
       @set["uncompliant (Quebec)"] = # NECB-QC (non-code-compliant) defaults:
@@ -225,7 +225,7 @@ module TBD
         grade:         0.850, # *
         joint:         0.500, # *
         transition:    0.000
-      }.freeze               # based on EXTERIOR dimensions (art. 3.1.1.6)
+      }.freeze
       self.gen("uncompliant (Quebec)")
 
       @set["(non thermal bridging)"] = # ... would not derate surfaces:
@@ -913,6 +913,7 @@ module TBD
     return mismatch("argh", argh, Hash, mth, DBG, tbd) unless argh.is_a?(Hash)
 
     argh                 = {}                       if argh.empty?
+    argh[:sub_tol      ] = TBD::TOL             unless argh.key?(:sub_tol      )
     argh[:option       ] = ""                   unless argh.key?(:option       )
     argh[:io_path      ] = nil                  unless argh.key?(:io_path      )
     argh[:schema_path  ] = nil                  unless argh.key?(:schema_path  )
@@ -1174,9 +1175,6 @@ module TBD
             farthest_V = origin_point_V if farther
           end
 
-          puts "ADDITION!!"                      if id == "ADDITION"
-          puts "#{reference_V} vs #{farthest_V}" if id == "ADDITION"
-
           angle = reference_V.angle(farthest_V)
           invalid("#{id} polar angle", mth, 0, ERROR, 0) if angle.nil?
           angle = 0                                      if angle.nil?
@@ -1426,7 +1424,7 @@ module TBD
         end
 
         # Label edge as :party if linked to:
-        #   1x adiabatic surface
+        #   1x OtherSideCoefficients surface
         #   1x (only) deratable surface
         edge[:surfaces].keys.each do |i|
           break     if is[:party]
@@ -1435,7 +1433,9 @@ module TBD
           next  unless tbd[:surfaces].key?(i)
           next      if holes.key?(i)
           next      if shades.key?(i)
-          next  unless tbd[:surfaces][i][:boundary].downcase == "adiabatic"
+
+          facing = tbd[:surfaces][i][:boundary].downcase
+          next unless facing == "othersidecoefficients"
 
           s1      = edge[:surfaces][id]
           s2      = edge[:surfaces][i]
@@ -1769,13 +1769,120 @@ module TBD
       end
     end
 
+    # Fetch edge multipliers for subsurfaces, if applicable.
+    edges.values.each do |edge|
+      next     if edge.key?(:mult)                    # skip if already assigned
+      next unless edge.key?(:surfaces)
+      next unless edge.key?(:psi)
+      ok = false
+
+      edge[:psi].keys.each do |k|
+        break if ok
+
+        jamb = k.to_s.include?("jamb")
+        sill = k.to_s.include?("sill")
+        head = k.to_s.include?("head")
+        ok   = jamb || sill || head
+      end
+
+      next unless ok     # if OK, edge links subsurface(s) ... yet which one(s)?
+
+      edge[:surfaces].each do |id, surface|
+        next unless tbd[:surfaces].key?(id)    # look up parent (opaque) surface
+
+        [:windows, :doors, :skylights].each do |subtypes|
+          next unless tbd[:surfaces][id].key?(subtypes)
+
+          tbd[:surfaces][id][subtypes].each do |nom, sub|
+            next unless edge[:surfaces].key?(nom)
+            next unless sub[:mult] > 1
+
+            # An edge may be tagged with (potentially conflicting) multipliers.
+            # This is only possible if the edge links 2 subsurfaces, e.g. a
+            # shared jamb between window & door. By default, TBD tags common
+            # subsurface edges as (mild) "transitions" (i.e. PSI 0 W/K.m), so
+            # there would be no point in assigning an edge multiplier. Users
+            # can however reset an edge type via a TBD JSON input file (e.g.
+            # "joint" instead of "transition"). It would be a very odd choice,
+            # but TBD doesn't prohibit it. If linked subsurfaces have different
+            # multipliers (e.g. 2 vs 3), TBD tracks the highest value.
+            edge[:mult] = sub[:mult] unless edge.key?(:mult)
+            edge[:mult] = sub[:mult]     if sub[:mult] > edge[:mult]
+          end
+        end
+      end
+    end
+
+    # Unless a user has set the thermal bridge type of an individual edge via
+    # JSON input, reset any subsurface's head, sill or jamb edges as (mild)
+    # transitions when in close proximity to another subsurface edge. Both
+    # edges' origin and terminal vertices must be in close proximity. Edges
+    # of unhinged subsurfaces are ignored.
+    edges.each do |id, edge|
+      nb    = 0                            # linked subsurfaces (i.e. "holes")
+      match = false
+      next if edge.key?(:io_type)          # skip if set in JSON
+      next unless edge.key?(:v0)
+      next unless edge.key?(:v1)
+      next unless edge.key?(:psi)
+      next unless edge.key?(:surfaces)
+
+      edge[:surfaces].keys.each do |identifier|
+        break    if match
+        next unless holes.key?(identifier)
+
+        if holes[identifier].attributes.key?(:unhinged)
+          nb = 0 if holes[identifier].attributes[:unhinged]
+          break  if holes[identifier].attributes[:unhinged]
+        end
+
+        nb += 1
+        match = true if nb > 1
+      end
+
+      if nb == 1 # linking 1x subsurface, search for 1x other.
+        e1 = { v0: edge[:v0].point, v1: edge[:v1].point }
+
+        edges.each do |nom, e|
+          nb = 0
+          break    if match
+          next     if nom == id
+          next     if e.key?(:io_type)
+          next unless e.key?(:psi)
+          next unless e.key?(:surfaces)
+
+          e[:surfaces].keys.each do |identifier|
+            next unless holes.key?(identifier)
+
+            if holes[identifier].attributes.key?(:unhinged)
+              nb = 0 if holes[identifier].attributes[:unhinged]
+              break  if holes[identifier].attributes[:unhinged]
+            end
+
+            nb += 1
+          end
+
+          next unless nb == 1 # only process edge if linking 1x subsurface
+
+          e2 = { v0: e[:v0].point, v1: e[:v1].point }
+          match = matches?(e1, e2, argh[:sub_tol])
+        end
+      end
+
+      next unless match
+
+      edge[:psi] = { transition: 0.000 }
+      edge[:set] = json[:io][:building][:psi]
+    end
+
     # Loop through each edge and assign heat loss to linked surfaces.
     edges.each do |identifier, edge|
       next unless  edge.key?(:psi)
       rsi        = 0
-      max        = edge[:psi].values.max
-      type       = edge[:psi].key(max)
+      max        = edge[:psi   ].values.max
+      type       = edge[:psi   ].key(max)
       length     = edge[:length]
+      length    *= edge[:mult  ] if edge.key?(:mult)
       bridge     = { psi: max, type: type, length: length }
       deratables = {}
       apertures  = {}
@@ -1867,7 +1974,7 @@ module TBD
     # ... first 'uprate' targeted insulation layers (see ua.rb) before derating.
     # Check for new argh keys [:wall_uo], [:roof_uo] and/or [:floor_uo].
     up = argh[:uprate_walls] || argh[:uprate_roofs] || argh[:uprate_floors]
-    uprate(model, tbd[:surfaces], argh)                                    if up
+    uprate(model, tbd[:surfaces], argh) if up
 
     # Derated (cloned) constructions are unique to each deratable surface.
     # Unique construction names are prefixed with the surface name,
@@ -1973,6 +2080,7 @@ module TBD
       set        = e[:set]
       t          = e[:psi].key(v)
       l          = e[:length]
+      l         *= e[:mult] if e.key?(:mult)
       edge       = { psi: set, type: t, length: l, surfaces: e[:surfaces].keys }
       edge[:v0x] = e[:v0].point.x
       edge[:v0y] = e[:v0].point.y

data/lib/measures/tbd/resources/tbd.rb

@@ -1,6 +1,6 @@
 # MIT License
 #
-# Copyright (c) 2020-2022 Denis Bourgeois & Dan Macumber
+# Copyright (c) 2020-2023 Denis Bourgeois & Dan Macumber
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal

data/lib/measures/tbd/resources/ua.rb

@@ -1,6 +1,6 @@
 # MIT License
 #
-# Copyright (c) 2020-2022 Denis Bourgeois & Dan Macumber
+# Copyright (c) 2020-2023 Denis Bourgeois & Dan Macumber
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -47,6 +47,8 @@ module TBD
     return mismatch("film", film, cl3, mth, DBG, res)    unless film.is_a?(cl3)
     return mismatch("Ut", ut, cl3, mth, DBG, res)        unless ut.is_a?(cl3)
 
+    loss        = 0.0                   # residual heatloss (not assigned) [W/K]
+    area        = lc.getNetArea
     lyr         = insulatingLayer(lc)
     lyr[:index] = nil unless lyr[:index].is_a?(Numeric)
     lyr[:index] = nil unless lyr[:index] >= 0
@@ -57,8 +59,6 @@ module TBD
     return zero("'#{id}': films", mth, WRN, res)              unless film > TOL
     return zero("'#{id}': Ut", mth, WRN, res)                 unless ut > TOL
     return invalid("'#{id}': Ut", mth, 0, WRN, res)           unless ut < 5.678
-
-    area = lc.getNetArea
     return zero("'#{id}': net area (m2)", mth, ERR, res)      unless area > TOL
 
     # First, calculate initial layer RSi to initially meet Ut target.
@@ -74,8 +74,6 @@ module TBD
 
     return zero("'#{id}': new Rsi", mth, ERR, res)          unless new_r > 0.001
 
-    loss   = 0.0                        # residual heatloss (not assigned) [W/K]
-
     if lyr[:type] == :massless
       m     = lc.getLayer(lyr[:index]).to_MasslessOpaqueMaterial
       return  invalid("'#{id}' massless layer?", mth, 0)             if m.empty?
@@ -85,7 +83,7 @@ module TBD
       new_r = 0.001                                         unless new_r > 0.001
       loss  = (new_u - 1 / new_r) * area                    unless new_r > 0.001
               m.setThermalResistance(new_r)
-    else                                                     # type == :standard
+    else # type == :standard
       m     = lc.getLayer(lyr[:index]).to_StandardOpaqueMaterial
       return  invalid("'#{id}' standard layer?", mth, 0)             if m.empty?
 
@@ -595,77 +593,46 @@ module TBD
       next unless surface[:net] > TOL
       next unless surface.key?(:u)
       next unless surface[:u] > TOL
-      heating = 21.0
-      heating = surface[:heating] if surface.key?(:heating)
-      bloc    = b1
-      bloc    = b2 if heating < 18
-
+      heating   = 21.0
+      heating   = surface[:heating] if surface.key?(:heating)
+      bloc      = b1
+      bloc      = b2 if heating < 18
       reference = surface.key?(:ref)
+
       if type == :wall
         areas[:walls][:net ] += surface[:net]
-         bloc[:pro][:walls ] += surface[:net] * surface[:u  ]
-         bloc[:ref][:walls ] += surface[:net] * surface[:ref]       if reference
-         bloc[:ref][:walls ] += surface[:net] * surface[:u  ]   unless reference
+        bloc[:pro][:walls  ] += surface[:net] * surface[:u  ]
+        bloc[:ref][:walls  ] += surface[:net] * surface[:ref]       if reference
+        bloc[:ref][:walls  ] += surface[:net] * surface[:u  ]   unless reference
       elsif type == :ceiling
         areas[:roofs][:net ] += surface[:net]
-         bloc[:pro][:roofs ] += surface[:net] * surface[:u  ]
-         bloc[:ref][:roofs ] += surface[:net] * surface[:ref]       if reference
-         bloc[:ref][:roofs ] += surface[:net] * surface[:u  ]   unless reference
+        bloc[:pro][:roofs  ] += surface[:net] * surface[:u  ]
+        bloc[:ref][:roofs  ] += surface[:net] * surface[:ref]       if reference
+        bloc[:ref][:roofs  ] += surface[:net] * surface[:u  ]   unless reference
       else
         areas[:floors][:net] += surface[:net]
-         bloc[:pro][:floors] += surface[:net] * surface[:u  ]
-         bloc[:ref][:floors] += surface[:net] * surface[:ref]       if reference
-         bloc[:ref][:floors] += surface[:net] * surface[:u  ]   unless reference
-      end
-
-      if surface.key?(:doors)
-        surface[:doors].values.each do |door|
-          next unless door.key?(:gross)
-          next unless door[:gross] > TOL
-          next unless door.key?(:u)
-          next unless door[:u] > TOL
-          areas[:walls][:subs ] += door[:gross]              if type == :wall
-          areas[:roofs][:subs ] += door[:gross]              if type == :ceiling
-          areas[:floors][:subs] += door[:gross]              if type == :floor
-           bloc[:pro][:doors  ] += door[:gross] * door[:u]
-
-           ok = door.key?(:ref)
-           bloc[:ref][:doors  ] += door[:gross] * door[:ref]               if ok
-           bloc[:ref][:doors  ] += door[:gross] * door[:u ]            unless ok
-        end
-      end
-
-      if surface.key?(:windows)
-        surface[:windows].values.each do |window|
-          next unless window.key?(:gross)
-          next unless window[:gross] > TOL
-          next unless window.key?(:u)
-          next unless window[:u] > TOL
-          areas[:walls][:subs ]  += window[:gross]           if type == :wall
-          areas[:roofs][:subs ]  += window[:gross]           if type == :ceiling
-          areas[:floors][:subs]  += window[:gross]           if type == :floor
-           bloc[:pro][:windows]  += window[:gross] * window[:u]
-
-          ok = window.key?(:ref)
-          bloc[:ref][:windows ] += window[:gross] * window[:ref]           if ok
-          bloc[:ref][:windows ] += window[:gross] * window[:u  ]       unless ok
-        end
+        bloc[:pro][:floors ] += surface[:net] * surface[:u  ]
+        bloc[:ref][:floors ] += surface[:net] * surface[:ref]       if reference
+        bloc[:ref][:floors ] += surface[:net] * surface[:u  ]   unless reference
       end
 
-      if surface.key?(:skylights)
-        surface[:skylights].values.each do |sky|
-          next unless sky.key?(:gross)
-          next unless sky[:gross] > TOL
-          next unless sky.key?(:u)
-          next unless sky[:u] > TOL
-          areas[:walls][:subs  ] += sky[:gross]              if type == :wall
-          areas[:roofs][:subs  ] += sky[:gross]              if type == :ceiling
-          areas[:floors][:subs ] += sky[:gross]              if type == :floor
-          bloc[:pro][:skylights] += sky[:gross] * sky[:u]
-
-          ok = sky.key?(:ref)
-          bloc[:ref][:skylights] += sky[:gross] * sky[:ref]                if ok
-          bloc[:ref][:skylights] += sky[:gross] * sky[:u  ]            unless ok
+      [:doors, :windows, :skylights].each do |subs|
+        next unless surface.key?(subs)
+
+        surface[subs].values.each do |sub|
+          next unless sub.key?(:gross)
+          next unless sub.key?(:u    )
+          next unless sub[:gross] > TOL
+          next unless sub[:u    ] > TOL
+
+          gross  = sub[:gross]
+          gross *= sub[:mult ]                               if sub.key?(:mult)
+          areas[:walls ][:subs] += gross                     if type == :wall
+          areas[:roofs ][:subs] += gross                     if type == :ceiling
+          areas[:floors][:subs] += gross                     if type == :floor
+          bloc[:pro    ][subs ] += gross * sub[:u  ]
+          bloc[:ref    ][subs ] += gross * sub[:ref]         if sub.key?(:ref)
+          bloc[:ref    ][subs ] += gross * sub[:u  ]     unless sub.key?(:ref)
         end
       end
 
@@ -953,7 +920,7 @@ module TBD
       model  = "* modèle : #{ua[:file]}"       if ua.key?(:file)  && lang == :fr
       model += " (v#{ua[:version]})"           if ua.key?(:version)
       report << model                      unless model.empty?
-      report << "* TBD : v3.1.0"
+      report << "* TBD : v3.2.0"
       report << "* date : #{ua[:date]}"
 
       if lang == :en