tbd 3.2.1 → 3.2.3

data/lib/tbd/geo.rb

@@ -218,42 +218,6 @@ module TBD
     true
   end
 
-  ##
-  # Validate whether an OpenStudio planar surface is safe for TBD to process.
-  #
-  # @param s [OpenStudio::Model::PlanarSurface] a surface
-  #
-  # @return [Bool] true if valid surface
-  def validate(s = nil)
-    mth = "TBD::#{__callee__}"
-    cl = OpenStudio::Model::PlanarSurface
-
-    return mismatch("surface", s, cl, mth, DBG, false)        unless s.is_a?(cl)
-
-    id   = s.nameString
-    size = s.vertices.size
-    last = size - 1
-
-    log(ERR, "#{id} #{size} vertices? need +3 (#{mth})")         unless size > 2
-    return false                                                 unless size > 2
-
-    [0, last].each do |i|
-      v1 = s.vertices[i]
-      v2 = s.vertices[i + 1]                                    unless i == last
-      v2 = s.vertices.first                                         if i == last
-      vector = v2 - v1
-      bad = vector.length < TOL
-
-      # As is, this comparison also catches collinear vertices (< 10mm apart)
-      # along an edge. Should avoid red-flagging such cases. TO DO.
-      log(ERR, "#{id}: < #{TOL}m (#{mth})")                               if bad
-      return false                                                        if bad
-    end
-
-    # Add as many extra tests as needed ...
-    true
-  end
-
   ##
   # Return site-specific (or true) Topolys normal vector of OpenStudio surface.
   #
@@ -290,30 +254,33 @@ module TBD
     cl2 = OpenStudio::Model::Surface
     cl3 = OpenStudio::Model::LayeredConstruction
 
-    return mismatch("model", model, cl1, mth)          unless model.is_a?(cl1)
-    return mismatch("surface", surface, cl2, mth)      unless surface.is_a?(cl2)
-
-    return nil unless validate(surface)
+    return mismatch("model", model, cl1, mth)     unless model.is_a?(cl1)
+    return mismatch("surface", surface, cl2, mth) unless surface.is_a?(cl2)
+    return nil                                    unless surface_valid?(surface)
 
     nom    = surface.nameString
     surf   = {}
     subs   = {}
     fd     = false
     return   empty("'#{nom}' space", mth, ERR)           if surface.space.empty?
+
     space  = surface.space.get
     stype  = space.spaceType
     story  = space.buildingStory
     tr     = transforms(model, space)
     return   invalid("'#{nom}' transform", mth, 0, FTL)  unless tr[:t] && tr[:r]
+
     t      = tr[:t]
     n      = trueNormal(surface, tr[:r])
     return   invalid("'#{nom}' normal", mth, 0, FTL)     unless n
+
     type   = surface.surfaceType.downcase
     facing = surface.outsideBoundaryCondition
 
     if facing.downcase == "surface"
       empty = surface.adjacentSurface.empty?
-      return invalid("'#{nom}': adjacent surface", mth, 0, ERR)         if empty
+      return invalid("'#{nom}': adjacent surface", mth, 0, ERR) if empty
+
       facing = surface.adjacentSurface.get.nameString
     end
 
@@ -350,9 +317,10 @@ module TBD
     surf[:story      ] = story.get               unless story.empty?
     surf[:n          ] = n
     surf[:gross      ] = surface.grossArea
+    surf[:filmRSI    ] = surface.filmResistance
 
     surface.subSurfaces.sort_by { |s| s.nameString }.each do |s|
-      next unless validate(s)
+      next unless surface_valid?(s)
 
       id       = s.nameString
       valid    = s.vertices.size == 3 || s.vertices.size == 4

data/lib/tbd/ua.rb

@@ -39,13 +39,14 @@ module TBD
     cl1 = OpenStudio::Model::Model
     cl2 = OpenStudio::Model::LayeredConstruction
     cl3 = Numeric
+    cl4 = String
 
-    return mismatch("model", model, cl1, mth, DBG, res)  unless model.is_a?(cl1)
-    return mismatch("id", id, String, mth, DBG, res)     unless id.is_a?(String)
-    return mismatch("lc", lc, cl2, mth, DBG, res)        unless lc.is_a?(cl2)
-    return mismatch("hloss", hloss, cl3, mth, DBG, res)  unless hloss.is_a?(cl3)
-    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)
+    return mismatch("model", model, cl1, mth, DBG, res) unless model.is_a?(cl1)
+    return mismatch("id"   ,    id, cl4, mth, DBG, res) unless id.is_a?(cl4)
+    return mismatch("lc"   ,    lc, cl2, mth, DBG, res) unless lc.is_a?(cl2)
+    return mismatch("hloss", hloss, cl3, mth, DBG, res) unless hloss.is_a?(cl3)
+    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
@@ -54,12 +55,12 @@ module TBD
     lyr[:index] = nil unless lyr[:index] >= 0
     lyr[:index] = nil unless lyr[:index] < lc.layers.size
 
-    return invalid("'#{id}' layer index", mth, 0, ERR, res)   unless lyr[:index]
-    return zero("'#{id}': heatloss", mth, WRN, res)           unless hloss > TOL
-    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
-    return zero("'#{id}': net area (m2)", mth, ERR, res)      unless area > TOL
+    return invalid("'#{id}' layer index", mth, 0, ERR, res) unless lyr[:index]
+    return zero("'#{id}': heatloss"     , mth,    WRN, res) unless hloss > TOL
+    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
+    return zero("'#{id}': net area (m2)", mth,    ERR, res) unless area  > TOL
 
     # First, calculate initial layer RSi to initially meet Ut target.
     rt     = 1 / ut                      #                target construction Rt
@@ -76,7 +77,7 @@ module TBD
 
     if lyr[:type] == :massless
       m     = lc.getLayer(lyr[:index]).to_MasslessOpaqueMaterial
-      return  invalid("'#{id}' massless layer?", mth, 0)             if m.empty?
+      return  invalid("'#{id}' massless layer?", mth, 0, DBG, res)   if m.empty?
 
       m     = m.get.clone(model).to_MasslessOpaqueMaterial.get
               m.setName("#{id} uprated")
@@ -85,7 +86,7 @@ module TBD
               m.setThermalResistance(new_r)
     else # type == :standard
       m     = lc.getLayer(lyr[:index]).to_StandardOpaqueMaterial
-      return  invalid("'#{id}' standard layer?", mth, 0)             if m.empty?
+      return  invalid("'#{id}' standard layer?", mth, 0, DBG, res)   if m.empty?
 
       m     = m.get.clone(model).to_StandardOpaqueMaterial.get
               m.setName("#{id} uprated")
@@ -141,11 +142,12 @@ module TBD
     mth = "TBD::#{__callee__}"
     cl1 = OpenStudio::Model::Model
     cl2 = Hash
+    cl3 = OpenStudio::Model::LayeredConstruction
     a   = false
 
-    return mismatch("model", model, cl1, mth, DBG, a)    unless model.is_a?(cl1)
-    return mismatch("surfaces", s, cl2, mth, DBG, a)     unless s.is_a?(cl2)
-    return mismatch("argh", model, cl1, mth, DBG, a)     unless argh.is_a?(cl2)
+    return mismatch("model"   , model, cl1, mth, DBG, a) unless model.is_a?(cl1)
+    return mismatch("surfaces",     s, cl2, mth, DBG, a) unless s.is_a?(cl2)
+    return mismatch("argh"    , model, cl1, mth, DBG, a) unless argh.is_a?(cl2)
 
     argh[:uprate_walls ] = false unless argh.key?(:uprate_walls )
     argh[:uprate_roofs ] = false unless argh.key?(:uprate_roofs )
@@ -168,11 +170,13 @@ module TBD
     groups[:roof ][:op] = argh[:roof_option  ]
     groups[:floor][:op] = argh[:floor_option ]
 
-    groups.each do |label, g|
+    groups.each do |type, g|
       next unless g[:up]
       next unless g[:ut].is_a?(Numeric)
       next unless g[:ut] < 5.678
 
+      typ  = type
+      typ  = :ceiling if typ == :roof # fix in future revision. TO-DO.
       coll = {}
       area = 0
       film = 100000000000000
@@ -183,86 +187,81 @@ module TBD
              g[:op].downcase == "all floor constructions"
 
       if g[:op].empty?
-        log(ERR, "Construction to uprate? (#{mth})")
+        log(ERR, "Construction (#{type}) to uprate? (#{mth})")
       elsif all
-        model.getSurfaces.each do |sss|
-          next unless sss.surfaceType.downcase.include?(label.to_s)
-          next unless sss.outsideBoundaryCondition.downcase == "outdoors"
-          next     if sss.construction.empty?
-          next     if sss.construction.get.to_LayeredConstruction.empty?
-
-          c         = sss.construction.get.to_LayeredConstruction.get
-          i         = c.nameString
-
-          # Reliable unless referenced by other surface types e.g. floor vs wall.
-          if c.getNetArea > area
-            area = c.getNetArea
+        s.each do |nom, surface|
+          next unless surface.key?(:deratable   )
+          next unless surface.key?(:type        )
+          next unless surface.key?(:construction)
+          next unless surface.key?(:filmRSI     )
+          next unless surface.key?(:index       )
+          next unless surface.key?(:ltype       )
+          next unless surface.key?(:r           )
+          next unless surface[:deratable   ]
+          next unless surface[:type        ] == typ
+          next unless surface[:construction].is_a?(cl3)
+          next     if surface[:index       ].nil?
+
+          # Retain lowest surface film resistance (e.g. tilted surfaces).
+          c    = surface[:construction]
+          i    = c.nameString
+          aire = c.getNetArea
+          film = surface[:filmRSI] if surface[:filmRSI] < film
+
+          # Retain construction covering largest area. The following conditional
+          # is reliable UNLESS linked to other deratable surface types e.g. both
+          # floors AND walls (see "elsif lc" corrections below).
+          if aire > area
             lc   = c
+            area = aire
             id   = i
           end
 
-          film    = sss.filmResistance if sss.filmResistance < film
-          nom     = sss.nameString
-          coll[i] = { area: c.getNetArea, lc: c, s: {} } unless coll.key?(i)
-          coll[i][:s][nom] = { a: sss.netArea } unless coll[i][:s].key?(nom)
+          coll[i]          = { area: aire, lc: c, s: {} } unless coll.key?(i)
+          coll[i][:s][nom] = { a: surface[:net] }  unless coll[i][:s].key?(nom)
         end
       else
         id = g[:op]
-        c  = model.getConstructionByName(id)
-
-        if c.empty?
-          log(ERR, "Construction '#{id}'? (#{mth})")
-        else
-          c  = c.get.to_LayeredConstruction
-
-          if c.empty?
-            log(ERR, "'#{id}' layered construction? (#{mth})")
-          else
-            lc       = c.get
-            area     = lc.getNetArea
-            coll[id] = { area: area, lc: lc, s: {} }
-
-            model.getSurfaces.each do |sss|
-              next unless sss.surfaceType.downcase.include?(label.to_s)
-              next unless sss.outsideBoundaryCondition.downcase == "outdoors"
-              next     if sss.construction.empty?
-              next     if sss.construction.get.to_LayeredConstruction.empty?
-              lc   = sss.construction.get.to_LayeredConstruction.get
-              next unless id == lc.nameString
-              nom  = sss.nameString
-              film = sss.filmResistance if sss.filmResistance < film
-              ok   = coll[id][:s].key?(nom)
-              coll[id][:s][nom] = { a: sss.netArea } unless ok
-            end
-          end
+        lc = model.getConstructionByName(id)
+        log(ERR, "Construction '#{id}'? (#{mth})")         if lc.empty?
+        next                                               if lc.empty?
+
+        lc = lc.get.to_LayeredConstruction
+        log(ERR, "'#{id}' layered construction? (#{mth})") if lc.empty?
+        next                                               if lc.empty?
+
+        lc       = lc.get
+        area     = lc.getNetArea
+        coll[id] = { area: area, lc: lc, s: {} }
+
+        s.each do |nom, surface|
+          next unless surface.key?(:deratable   )
+          next unless surface.key?(:type        )
+          next unless surface.key?(:construction)
+          next unless surface.key?(:filmRSI     )
+          next unless surface.key?(:index       )
+          next unless surface.key?(:ltype       )
+          next unless surface.key?(:r           )
+          next unless surface[:deratable   ]
+          next unless surface[:type        ] == typ
+          next unless surface[:construction].is_a?(cl3)
+          next     if surface[:index       ].nil?
+
+          i = surface[:construction].nameString
+          next unless i == id
+
+          # Retain lowest surface film resistance (e.g. tilted surfaces).
+          film = surface[:filmRSI] if surface[:filmRSI] < film
+
+          coll[i][:s][nom] = { a: surface[:net] } unless coll[i][:s].key?(nom)
         end
       end
 
       if coll.empty?
-        log(ERR, "No #{label} construction to uprate - skipping (#{mth})")
+        log(ERR, "No #{type} construction to uprate - skipping (#{mth})")
         next
-      elsif lc                    # valid layered construction - good to uprate!
-        # Ensure lc is referenced by surface types == label.
-        model.getSurfaces.each do |sss|
-          next if sss.construction.empty?
-          next if sss.construction.get.to_LayeredConstruction.empty?
-          c = sss.construction.get.to_LayeredConstruction.get
-          i = c.nameString
-          next unless coll.key?(i)
-
-          unless sss.surfaceType.downcase.include?(label.to_s)
-            log(ERR, "Uprating #{label.to_s}, not '#{sss.nameString}' (#{mth})")
-            cloned = c.clone(model).to_LayeredConstruction.get
-            cloned.setName("'#{i}' cloned")
-            sss.setConstruction(cloned)
-            ok = s.key?(sss.nameString)
-            s[sss.nameString][:construction] = cloned                      if ok
-            coll[i][:s].delete(sss.nameString)
-            coll[i][:area] = c.getNetArea
-            next
-          end
-        end
-
+      elsif lc
+        # Valid layered construction - good to uprate!
         lyr         = insulatingLayer(lc)
         lyr[:index] = nil unless lyr[:index].is_a?(Numeric)
         lyr[:index] = nil unless lyr[:index] >= 0
@@ -270,64 +269,81 @@ module TBD
 
         log(ERR, "Insulation index for '#{id}'? (#{mth})")    unless lyr[:index]
         next                                                  unless lyr[:index]
-        hloss = 0                    # sum of applicable psi & khi effects [W/K]
 
-        coll.each do |i, col|
-          next unless col.key?(:s)
-          next unless col.is_a?(Hash)
+        # Ensure lc is exclusively linked to deratable surfaces of right type.
+        # If not, assign new lc clone to non-targeted surfaces.
+        s.each do |nom, surface|
+          next unless surface.key?(:type        )
+          next unless surface.key?(:deratable   )
+          next unless surface.key?(:construction)
+          next unless surface[:construction].is_a?(cl3)
+          next unless surface[:construction] == lc
+
+          ok = true
+          ok = false unless surface[:type     ] == typ
+          ok = false unless surface[:deratable]
+          ok = false unless coll.key?(id)
+          ok = false unless coll[id][:s].key?(nom)
+
+          unless ok
+            log(WRN, "Cloning '#{nom}' construction - not '#{id}' (#{mth})")
+            sss    = model.getSurfaceByName(nom)
+            next if sss.empty?
+
+            sss    = sss.get
+            cloned = lc.clone(model).to_LayeredConstruction.get
+            cloned.setName("#{nom} - cloned")
+            sss.setConstruction(cloned)
+            surface[:construction] = cloned
+            coll[id][:s].delete(nom)
+          end
+        end
+
+        hloss           = 0          # sum of applicable psi & khi effects [W/K]
 
+        # Tally applicable psi + khi losses. Possible construction reassignment.
+        coll.each do |i, col|
           col[:s].keys.each do |nom|
             next unless s.key?(nom)
-            next unless s[nom].key?(:deratable   )
             next unless s[nom].key?(:construction)
             next unless s[nom].key?(:index       )
             next unless s[nom].key?(:ltype       )
             next unless s[nom].key?(:r           )
-            next unless s[nom].key?(:type        )
-
-            next unless s[nom][:deratable]
-            type = s[nom][:type].to_s.downcase
-            type = "roof" if type == "ceiling"
-            next unless type.include?(label.to_s)
 
             # Tally applicable psi + khi.
-            hloss += s[nom][:heatloss] if s[nom].key?(:heatloss)
-
-            # Skip construction reassignment if already referencing right one.
-            unless s[nom][:construction] == lc
-              sss = model.getSurfaceByName(nom)
-              next if sss.empty?
-              sss = sss.get
-
-              if sss.isConstructionDefaulted
-                set = defaultConstructionSet(model, sss)
-                constructions = set.defaultExteriorSurfaceConstructions.get
-
-                case sss.surfaceType.downcase
-                when "roofceiling"
-                  constructions.setRoofCeilingConstruction(lc)
-                when "floor"
-                  constructions.setFloorConstruction(lc)
-                else
-                  constructions.setWallConstruction(lc)
-                end
-              else
-                sss.setConstruction(lc)
-              end
+            hloss += s[nom][:heatloss    ] if s[nom].key?(:heatloss)
+            next  if s[nom][:construction] == lc
+
+            # Reassign construction unless referencing lc.
+            sss = model.getSurfaceByName(nom)
+            next if sss.empty?
 
-              s[nom][:construction] = lc                 # reset TBD attributes
-              s[nom][:index       ] = lyr[:index]
-              s[nom][:ltype       ] = lyr[:type ]
-              s[nom][:r           ] = lyr[:r    ]        # temporary
+            sss = sss.get
+
+            if sss.isConstructionDefaulted
+              set = defaultConstructionSet(model, sss) # building? story?
+              constructions = set.defaultExteriorSurfaceConstructions
+
+              unless constructions.empty?
+                constructions = constructions.get
+                constructions.setWallConstruction(lc)        if typ == :wall
+                constructions.setFloorConstruction(lc)       if typ == :floor
+                constructions.setRoofCeilingConstruction(lc) if typ == :ceiling
+              end
+            else
+              sss.setConstruction(lc)
             end
+
+            s[nom][:construction] = lc                 # reset TBD attributes
+            s[nom][:index       ] = lyr[:index]
+            s[nom][:ltype       ] = lyr[:type ]
+            s[nom][:r           ] = lyr[:r    ]        # temporary
           end
         end
 
         # Merge to ensure a single entry for coll Hash.
         coll.each do |i, col|
           next if i == id
-          next unless coll.key?(id)
-          coll[id][:area] += col[:area]
 
           col[:s].each do |nom, sss|
             coll[id][:s][nom] = sss unless coll[id][:s].key?(nom)
@@ -338,6 +354,8 @@ module TBD
         log(DBG, "Collection == 1? for '#{id}' (#{mth})")  unless coll.size == 1
         next                                               unless coll.size == 1
 
+        area = lc.getNetArea
+        coll[id][:area] = area
         res = uo(model, lc, id, hloss, film, g[:ut])
         log(ERR, "Unable to uprate '#{id}' (#{mth})") unless res[:uo] && res[:m]
         next                                          unless res[:uo] && res[:m]
@@ -347,27 +365,18 @@ module TBD
         # Loop through coll :s, and reset :r - likely modified by uo().
         coll.values.first[:s].keys.each do |nom|
           next unless s.key?(nom)
-          next unless s[nom].key?(:deratable   )
-          next unless s[nom].key?(:construction)
-          next unless s[nom].key?(:index       )
-          next unless s[nom].key?(:ltype       )
-          next unless s[nom].key?(:type        )
-
-          next unless s[nom][:deratable   ]
-          next unless s[nom][:construction] == lc
-          next unless s[nom][:index       ] == lyr[:index]
-          next unless s[nom][:ltype       ] == lyr[:type]
-
-          type = s[nom][:type].to_s.downcase
-          type = "roof" if type == "ceiling"
-          next unless type.include?(label.to_s)
-          next unless s[nom].key?(:r)
-          s[nom][:r] = lyr[:r]                                           # final
+          next unless s[nom].key?(:index)
+          next unless s[nom].key?(:ltype)
+          next unless s[nom].key?(:r    )
+          next unless s[nom][:index] == lyr[:index]
+          next unless s[nom][:ltype] == lyr[:type ]
+
+          s[nom][:r] = lyr[:r]  # uprated insulating RSi factor, before derating
         end
 
-        argh[:wall_uo ] = res[:uo] if label == :wall
-        argh[:roof_uo ] = res[:uo] if label == :roof
-        argh[:floor_uo] = res[:uo] if label == :floor
+        argh[:wall_uo ] = res[:uo] if typ == :wall
+        argh[:roof_uo ] = res[:uo] if typ == :ceiling
+        argh[:floor_uo] = res[:uo] if typ == :floor
       else
         log(ERR, "Nilled construction to uprate - (#{mth})")
         return false
@@ -920,7 +929,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.2.1"
+      report << "* TBD : v3.2.3"
       report << "* date : #{ua[:date]}"
 
       if lang == :en

data/lib/tbd/version.rb

@@ -21,5 +21,5 @@
 # SOFTWARE.
 
 module TBD
-  VERSION = "3.2.1".freeze
+  VERSION = "3.2.3".freeze
 end

data/tbd.gemspec

@@ -29,7 +29,7 @@ Gem::Specification.new do |s|
   s.metadata                 = {}
 
   s.add_dependency             "topolys",     "~> 0"
-  s.add_dependency             "osut",        "~> 0"
+  s.add_dependency             "osut",        "~> 0.3.0"
   s.add_dependency             "json-schema", "~> 2.7.0"
 
   s.add_development_dependency "bundler",     "~> 2.1"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tbd
 version: !ruby/object:Gem::Version
-  version: 3.2.1
+  version: 3.2.3
 platform: ruby
 authors:
 - Denis Bourgeois & Dan Macumber
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-02-16 00:00:00.000000000 Z
+date: 2023-05-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: topolys
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.3.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.3.0
 - !ruby/object:Gem::Dependency
   name: json-schema
   requirement: !ruby/object:Gem::Requirement
@@ -161,7 +161,7 @@ licenses:
 - MIT
 metadata:
   homepage_uri: https://github.com/rd2/tbd
-  source_code_uri: https://github.com/rd2/tbd/tree/v3.2.1
+  source_code_uri: https://github.com/rd2/tbd/tree/v3.2.3
   bug_tracker_uri: https://github.com/rd2/tbd/issues
 post_install_message:
 rdoc_options: []