tbd 3.2.1 → 3.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7a5a9002ff406325bc226c157ed29ffc22ccb60ac46b9c6bf29358f04aa9d6a3
-  data.tar.gz: 60b0a52d46be3a91a2119cb5d3875826e7b278ca9ce78a230e9575263dbb4c89
+  metadata.gz: 15442c735a4591e22e609b8b2f73733a583a5f6b304c3c479866d98afcf63251
+  data.tar.gz: c4d53db567cc419b2e0eb5b4b48f85f19e6c12745bab19ee257566c0c1b38bea
 SHA512:
-  metadata.gz: df24c1565b802fd84c8f067d78662adf23d5fb2059145b6b22da98b8c06f70b49283ef7f28613e91c1258e3c7b865d17e81df93c2340aec431483597d8ddb847
-  data.tar.gz: 34ea2406564f08b36a54987ab08fd5d2cb24e49bfb02640169278f1138f65f36ac2c9279abb7e8be83e1c2aec4cca639b8735ab13f54f0470fe0a8470977be86
+  metadata.gz: e314e00796a8d0e6e44c6ccd23d0e9accaa45be119589da431d00f45354c622bbedd964b94053fd9823c33914713b07984e0f0df44f714d4311ac16f382c0407
+  data.tar.gz: 7344be85007deed2d9a22d83c0cb20d4860d4e048c1bf281e7f2c8024439696b75ba6d232c9f8985253003c1295d2e537fc29a9fb9322ea6d756bcd08ec0dcf9

data/lib/measures/tbd/measure.xml

@@ -3,8 +3,8 @@
   <schema_version>3.0</schema_version>
   <name>tbd_measure</name>
   <uid>8890787b-8c25-4dc8-8641-b6be1b6c2357</uid>
-  <version_id>2fc42e1d-2010-44ae-9837-6390512c41d4</version_id>
-  <version_modified>20230214T105829Z</version_modified>
+  <version_id>30d7ee3a-8327-4a32-92fd-5cc0b9ab24b0</version_id>
+  <version_modified>20230516T180637Z</version_modified>
   <xml_checksum>99772807</xml_checksum>
   <class_name>TBDMeasure</class_name>
   <display_name>Thermal Bridging and Derating - TBD</display_name>
@@ -406,12 +406,6 @@
       <usage_type>resource</usage_type>
       <checksum>A4E8433C</checksum>
     </file>
-    <file>
-      <filename>utils.rb</filename>
-      <filetype>rb</filetype>
-      <usage_type>resource</usage_type>
-      <checksum>283C976C</checksum>
-    </file>
     <file>
       <version>
         <software_program>OpenStudio</software_program>
@@ -429,24 +423,12 @@
       <usage_type>test</usage_type>
       <checksum>58ED6635</checksum>
     </file>
-    <file>
-      <filename>geo.rb</filename>
-      <filetype>rb</filetype>
-      <usage_type>resource</usage_type>
-      <checksum>F447D8CE</checksum>
-    </file>
     <file>
       <filename>README.md</filename>
       <filetype>md</filetype>
       <usage_type>readme</usage_type>
       <checksum>B836C43A</checksum>
     </file>
-    <file>
-      <filename>ua.rb</filename>
-      <filetype>rb</filetype>
-      <usage_type>resource</usage_type>
-      <checksum>19193778</checksum>
-    </file>
     <file>
       <filename>psi.rb</filename>
       <filetype>rb</filetype>
@@ -465,5 +447,23 @@
       <usage_type>resource</usage_type>
       <checksum>A3BB982A</checksum>
     </file>
+    <file>
+      <filename>ua.rb</filename>
+      <filetype>rb</filetype>
+      <usage_type>resource</usage_type>
+      <checksum>EEFCA7DA</checksum>
+    </file>
+    <file>
+      <filename>utils.rb</filename>
+      <filetype>rb</filetype>
+      <usage_type>resource</usage_type>
+      <checksum>C03764A5</checksum>
+    </file>
+    <file>
+      <filename>geo.rb</filename>
+      <filetype>rb</filetype>
+      <usage_type>resource</usage_type>
+      <checksum>5F84399F</checksum>
+    </file>
   </files>
 </measure>

data/lib/measures/tbd/resources/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/measures/tbd/resources/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