tbd 3.5.2 → 3.6.1

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

@@ -106,26 +106,28 @@ module OSut
   # default inside + outside air film resistances (m2.K/W)
   @@film = {
       shading: 0.000, # NA
-    partition: 0.150, # uninsulated wood- or steel-framed wall
-         wall: 0.150, # un/insulated wall
-         roof: 0.140, # un/insulated roof
-        floor: 0.190, # un/insulated (exposed) floor
-     basement: 0.120, # un/insulated basement wall
-         slab: 0.160, # un/insulated basement slab or slab-on-grade
+      ceiling: 0.266, # interzone floor/ceiling
+    partition: 0.239, # interzone wall partition
+         wall: 0.150, # exposed wall
+         roof: 0.135, # exposed roof
+        floor: 0.192, # exposed floor
+     basement: 0.120, # basement wall
+         slab: 0.162, # basement slab or slab-on-grade
          door: 0.150, # standard, 45mm insulated steel (opaque) door
        window: 0.150, # vertical fenestration, e.g. glazed doors, windows
-     skylight: 0.140  # e.g. domed 4' x 4' skylight
+     skylight: 0.135  # e.g. domed 4' x 4' skylight
   }.freeze
 
   # default (~1980s) envelope Uo (W/m2•K), based on surface type
   @@uo = {
       shading: nil,   # N/A
+      ceiling: nil,   # N/A
     partition: nil,   # N/A
          wall: 0.384, # rated R14.8 hr•ft2F/Btu
          roof: 0.327, # rated R17.6 hr•ft2F/Btu
         floor: 0.317, # rated R17.9 hr•ft2F/Btu (exposed floor)
-     basement: nil,
-         slab: nil,
+     basement: nil,   # N/A
+         slab: nil,   # N/A
          door: 1.800, # insulated, unglazed steel door (single layer)
        window: 2.800, # e.g. patio doors (simple glazing)
      skylight: 3.500  # all skylight technologies
@@ -197,6 +199,61 @@ module OSut
   @@mats[:door     ][:rho] =  600.000
   @@mats[:door     ][:cp ] = 1000.000
 
+  ##
+  # Returns surface air film resistance(s). Surface tilt-dependent values are
+  # returned if a valid surface tilt [0, PI] is provided. Otherwise, generic
+  # tilt-independent air film resistances are returned instead.
+  #
+  # @param type [:to_sym] surface type, e.g. :roof, :wall, :partition, :ceiling
+  # @param tilt [Numeric] surface tilt (in rad), optional
+  #
+  # @return [Float] surface air film resistance(s)
+  # @return [0.0] if invalid input (see logs)
+  def filmResistances(type = :wall, tilt = 2 * Math::PI)
+    mth = "OSut::#{__callee__}"
+
+    unless tilt.is_a?(Numeric)
+      return mismatch("tilt", tilt, Float, mth, DBG, 0.0)
+    end
+
+    unless type.respond_to?(:to_sym)
+      return mismatch("type", type, Symbol, mth, DBG, 0.0)
+    end
+
+    type = type.to_s.downcase.to_sym
+
+    unless @@film.key?(type)
+      return invalid("type", mth, 1, DBG, 0.0)
+    end
+
+    # Generic, tilt-independent values.
+    r = @@film[type]
+    return r if type == :shading
+
+    # Valid tilt?
+    if tilt.between?(0, Math::PI)
+      r = OpenStudio::Model::PlanarSurface.stillAirFilmResistance(tilt)
+      return r if type == :basement || type == :slab
+
+      if type == :ceiling || type == :partition
+        # Interzone. Fetch reciprocal tilt, e.g. if tilt == 0°, tiltx = 180°
+        tiltx = tilt + Math::PI
+
+        # Assuming tilt is contrained [0°, 180°] - constrain tiltx [0° 180°]:
+        #   e.g. tiltx == 210° if tilt ==  30°, so convert tiltx to 150°
+        #   e.g. tiltx == 330° if tilt == 150°, so convert tiltx to  30°
+        #   e.g. tiltx == 275° if tilt ==  95°, so convert tiltx to  85°
+        tiltx = Math::PI - tilt if tiltx > Math::PI
+
+        r += OpenStudio::Model::PlanarSurface.stillAirFilmResistance(tiltx)
+      else
+        r += 0.03 # "MOVINGAIR_15MPH"
+      end
+    end
+
+    r
+  end
+
   ##
   # Validates if every material in a layered construction is standard & opaque.
   #
@@ -470,7 +527,7 @@ module OSut
   ##
   # Resets a construction's Uo factor by adjusting its insulating layer
   # thermal conductivity, then if needed its thickness (or its RSi value if
-  # massless). Unless material uniquness is requested, a matching material is
+  # massless). Unless material uniqueness is requested, a matching material is
   # recovered instead of instantiating a new one. The latter is renamed
   # according to its adjusted conductivity/thickness (or RSi value).
   #
@@ -530,7 +587,7 @@ module OSut
       mt.setName(id)
 
       unless mt.setThermalResistance(r)
-        return invalid("Failed #{id}: RSi#{r.round(2)}", mth)
+        return invalid("Failed #{id}: RSi#{r.round(2)}", mth, 0, DBG, 0.0)
       end
 
       lc.setLayer(index, mt)
@@ -564,11 +621,11 @@ module OSut
       mt.setName(id)
 
       unless mt.setThermalConductivity(k)
-        return invalid("Failed #{id}: K#{k.round(3)}", mth)
+        return invalid("Failed #{id}: K#{k.round(3)}", mth, 0, DBG, 0.0)
       end
 
       unless mt.setThickness(d)
-        return invalid("Failed #{id}: #{(d*1000).to_i}mm", mth)
+        return invalid("Failed #{id}: #{(d*1000).to_i}mm", mth, 0, DBG, 0.0)
       end
 
       lc.setLayer(index, mt)
@@ -600,10 +657,6 @@ module OSut
     return mismatch("model", model, cl1, mth) unless model.is_a?(cl1)
     return mismatch("specs", specs, cl2, mth) unless specs.is_a?(cl2)
 
-    specs[:id] = "" unless specs.key?(:id)
-    id = trim(specs[:id])
-    id = "OSut:CON:#{specs[:type]}" if id.empty?
-
     if specs.key?(:type)
       unless @@uo.keys.include?(specs[:type])
         return invalid("surface type", mth, 2, ERR)
@@ -612,6 +665,10 @@ module OSut
       specs[:type] = :wall
     end
 
+    specs[:id] = "" unless specs.key?(:id)
+    id = trim(specs[:id])
+    id = "OSut:CON:#{specs[:type]}" if id.empty?
+
     specs[:uo] = @@uo[ specs[:type] ] unless specs.key?(:uo) # can be nil
     u = specs[:uo]
 
@@ -652,6 +709,35 @@ module OSut
       a[:compo][:mat] = @@mats[mt]
       a[:compo][:d  ] = d
       a[:compo][:id ] = "OSut:#{mt}:#{format('%03d', d*1000)[-3..-1]}"
+    when :ceiling
+      unless specs[:clad] == :none
+        mt = :concrete
+        mt = :material  if specs[:clad] == :light
+        d  = 0.015
+        d  = 0.100      if specs[:clad] == :medium
+        d  = 0.200      if specs[:clad] == :heavy
+        a[:clad][:mat] = @@mats[mt]
+        a[:clad][:d  ] = d
+        a[:clad][:id ] = "OSut:#{mt}:#{format('%03d', d*1000)[-3..-1]}"
+      end
+
+      mt = :mineral
+      mt = :polyiso   if specs[:frame] == :medium
+      mt = :cellulose if specs[:frame] == :heavy
+      mt = :material  unless u
+      d  = 0.100
+      d  = 0.015      unless u
+      a[:compo][:mat] = @@mats[mt]
+      a[:compo][:d  ] = d
+      a[:compo][:id ] = "OSut:#{mt}:#{format('%03d', d*1000)[-3..-1]}"
+
+      unless specs[:finish] == :none
+        mt = :material
+        d  = 0.015
+        a[:finish][:mat] = @@mats[mt]
+        a[:finish][:d  ] = d
+        a[:finish][:id ] = "OSut:#{mt}:#{format('%03d', d*1000)[-3..-1]}"
+      end
     when :partition
       unless specs[:clad] == :none
         d  = 0.015

data/lib/tbd/geo.rb

@@ -38,7 +38,6 @@ module TBD
     a   = false
     return mismatch("e1", e1, Hash, mth, DBG, a)       unless e1.is_a?(Hash)
     return mismatch("e2", e2, Hash, mth, DBG, a)       unless e2.is_a?(Hash)
-    return mismatch("e2", e2, Hash, mth, DBG, a)       unless e2.is_a?(Hash)
 
     return hashkey("e1", e1, :v0, mth, DBG, a)         unless e1.key?(:v0)
     return hashkey("e1", e1, :v1, mth, DBG, a)         unless e1.key?(:v1)
@@ -299,14 +298,16 @@ module TBD
     return   invalid("#{nom} normal", mth, 0, ERR) unless n
 
     type   = surface.surfaceType.downcase
-    facing = surface.outsideBoundaryCondition
+    facing = surface.outsideBoundaryCondition.downcase
+    interz = false
     setpts = setpoints(space)
 
-    if facing.downcase == "surface"
-      empty = surface.adjacentSurface.empty?
-      return invalid("#{nom}: adjacent surface", mth, 0, ERR) if empty
+    if facing == "surface"
+      adj = surface.adjacentSurface
+      return invalid("#{nom}: adjacent surface", mth, 0, ERR) if adj.empty?
 
-      facing = surface.adjacentSurface.get.nameString
+      facing = adj.get.nameString
+      interz = true
     end
 
     unless surface.construction.empty?
@@ -315,8 +316,9 @@ module TBD
       unless lc.empty?
         lc  = lc.get
         lyr = insulatingLayer(lc)
+        idx = lyr[:index]
 
-        if lyr[:index].is_a?(Integer) && lyr[:index].between?(0, lc.numLayers - 1)
+        if idx.is_a?(Integer) && idx.between?(0, lc.numLayers - 1)
           surf[:construction] = lc
           # index: ... of layer/material (to derate) within construction
           # ltype: either :massless (RSi) or :standard (k + d)
@@ -358,8 +360,14 @@ module TBD
     surf[:story      ] = story.get unless story.empty?
     surf[:n          ] = n
     surf[:gross      ] = surface.grossArea
-    surf[:filmRSI    ] = surface.filmResistance
     surf[:spandrel   ] = spandrel?(surface)
+    surf[:filmRSI    ] = surface.filmResistance
+
+    if interz
+      typ = :ceiling # interzone roof or ceiling
+      typ = :partition if surf[:type] == :wall
+      surf[:filmRSI] = TBD.filmResistances(typ, surface.tilt)
+    end
 
     surface.subSurfaces.sort_by { |s| s.nameString }.each do |s|
       next if poly(s).empty?
@@ -508,7 +516,7 @@ module TBD
       end
 
       unless u.is_a?(Numeric)
-        r = rsi(c, surface.filmResistance)
+        r = rsi(c, surf[:filmRSI])
 
         if r < TOL
           log(ERR, "Skipping '#{id}': U-factor unavailable (#{mth})")
@@ -635,8 +643,8 @@ module TBD
 
     valid1 = s1[:angle].is_a?(Numeric)
     valid2 = s2[:angle].is_a?(Numeric)
-    return mismatch("s1 angle", s1[:angle], Numeric, DBG, false) unless valid1
-    return mismatch("s1 angle", s1[:angle], Numeric, DBG, false) unless valid2
+    return mismatch("s1 angle", s1[:angle], Numeric, mth, DBG, false) unless valid1
+    return mismatch("s2 angle", s2[:angle], Numeric, mth, DBG, false) unless valid2
 
     angle = 0
     angle = s2[:angle] - s1[:angle] if s2[:angle] > s1[:angle]
@@ -678,8 +686,8 @@ module TBD
 
     valid1 = s1[:angle].is_a?(Numeric)
     valid2 = s2[:angle].is_a?(Numeric)
-    return mismatch("s1 angle", s1[:angle], Numeric, DBG, false) unless valid1
-    return mismatch("s1 angle", s1[:angle], Numeric, DBG, false) unless valid2
+    return mismatch("s1 angle", s1[:angle], Numeric, mth, DBG, false) unless valid1
+    return mismatch("s2 angle", s2[:angle], Numeric, mth, DBG, false) unless valid2
 
     angle = 0
     angle = s2[:angle] - s1[:angle] if s2[:angle] > s1[:angle]
@@ -752,8 +760,8 @@ module TBD
   # boundary conditions.
   #
   # @param model [OpenStudio::Model::Model] a model
-  # @param floors [Hash] TBD floors
   # @param walls [Hash] TBD walls
+  # @param floors [Hash] TBD floors
   # @param edges [Hash] TBD edges (many linking floors & walls
   #
   # @return [Bool] true if Kiva foundations are successfully generated
@@ -831,7 +839,7 @@ module TBD
       edge[:surfaces].keys.each do |id|
         next unless floors.key?(id)
 
-        next unless floors[id][:boundary].downcase == "foundation"
+        next unless floors[id][:boundary] == "foundation"
         next     if floors[id].key?(:kiva)
 
         # Initially set as slab-on-grade. Track 'exposed foundation perimeter'.
@@ -845,7 +853,7 @@ module TBD
         edge[:surfaces].keys.each do |i|
           next     if i == id
           next unless walls.key?(i)
-          next unless walls[i][:boundary].downcase == "foundation"
+          next unless walls[i][:boundary] == "foundation"
           next     if walls[i].key?(:kiva)
 
           floors[id][:kiva   ]  = :basement
@@ -857,7 +865,7 @@ module TBD
         edge[:surfaces].keys.each do |i|
           next     if i == id
           next unless walls.key?(i)
-          next unless walls[i][:boundary].downcase == "outdoors"
+          next unless walls[i][:boundary] == "outdoors"
 
           floors[id][:exposed] += edge[:length]
         end
@@ -872,7 +880,7 @@ module TBD
             e[:surfaces].keys.each do |ii|
               next     if i == ii
               next unless walls.key?(ii)
-              next unless walls[ii][:boundary].downcase == "foundation"
+              next unless walls[ii][:boundary] == "foundation"
               next     if walls[ii].key?(:kiva)
 
               floors[id][:kiva   ]  = :basement
@@ -883,7 +891,7 @@ module TBD
             e[:surfaces].keys.each do |ii|
               next    if i == ii
               next unless walls.key?(ii)
-              next unless walls[ii][:boundary].downcase == "outdoors"
+              next unless walls[ii][:boundary] == "outdoors"
 
               floors[id][:exposed] += e[:length]
             end

data/lib/tbd/psi.rb

@@ -542,7 +542,7 @@ module TBD
       h[:partyconcave          ] = @set[id].key?(:partyconcave)
       h[:partyconvex           ] = @set[id].key?(:partyconvex)
       h[:parapet               ] = @set[id].key?(:parapet)
-      h[:partyconcave          ] = @set[id].key?(:parapetconcave)
+      h[:parapetconcave        ] = @set[id].key?(:parapetconcave)
       h[:parapetconvex         ] = @set[id].key?(:parapetconvex)
       h[:roof                  ] = @set[id].key?(:roof)
       h[:roofconcave           ] = @set[id].key?(:roofconcave)
@@ -557,10 +557,10 @@ module TBD
       h[:balconyconcave        ] = @set[id].key?(:balconyconcave)
       h[:balconyconvex         ] = @set[id].key?(:balconyconvex)
       h[:balconysill           ] = @set[id].key?(:balconysill)
-      h[:balconysillconcave    ] = @set[id].key?(:balconysillconvex)
+      h[:balconysillconcave    ] = @set[id].key?(:balconysillconcave)
       h[:balconysillconvex     ] = @set[id].key?(:balconysillconvex)
       h[:balconydoorsill       ] = @set[id].key?(:balconydoorsill)
-      h[:balconydoorsillconcave] = @set[id].key?(:balconydoorsillconvex)
+      h[:balconydoorsillconcave] = @set[id].key?(:balconydoorsillconcave)
       h[:balconydoorsillconvex ] = @set[id].key?(:balconydoorsillconvex)
       h[:rimjoist              ] = @set[id].key?(:rimjoist)
       h[:rimjoistconcave       ] = @set[id].key?(:rimjoistconcave)
@@ -572,10 +572,10 @@ module TBD
       v[:head           ] = 0; v[:headconcave           ] = 0; v[:headconvex           ] = 0
       v[:sill           ] = 0; v[:sillconcave           ] = 0; v[:sillconvex           ] = 0
       v[:jamb           ] = 0; v[:jambconcave           ] = 0; v[:jambconvex           ] = 0
-      v[:doorhead       ] = 0; v[:doorheadconcave       ] = 0; v[:doorconvex           ] = 0
+      v[:doorhead       ] = 0; v[:doorheadconcave       ] = 0; v[:doorheadconvex       ] = 0
       v[:doorsill       ] = 0; v[:doorsillconcave       ] = 0; v[:doorsillconvex       ] = 0
       v[:doorjamb       ] = 0; v[:doorjambconcave       ] = 0; v[:doorjambconvex       ] = 0
-      v[:skylighthead   ] = 0; v[:skylightheadconcave   ] = 0; v[:skylightconvex       ] = 0
+      v[:skylighthead   ] = 0; v[:skylightheadconcave   ] = 0; v[:skylightheadconvex   ] = 0
       v[:skylightsill   ] = 0; v[:skylightsillconcave   ] = 0; v[:skylightsillconvex   ] = 0
       v[:skylightjamb   ] = 0; v[:skylightjambconcave   ] = 0; v[:skylightjambconvex   ] = 0
       v[:spandrel       ] = 0; v[:spandrelconcave       ] = 0; v[:spandrelconvex       ] = 0
@@ -712,7 +712,7 @@ module TBD
       v[:roofconcave           ] = @set[id][:parapet               ] if h[:parapet               ]
       v[:roofconvex            ] = @set[id][:parapet               ] if h[:parapet               ]
       v[:roofconcave           ] = @set[id][:parapetconcave        ] if h[:parapetconcave        ]
-      v[:roofconvex            ] = @set[id][:parapetxonvex         ] if h[:parapetconvex         ]
+      v[:roofconvex            ] = @set[id][:parapetconvex         ] if h[:parapetconvex         ]
       v[:roof                  ] = @set[id][:roof                  ] if h[:roof                  ]
       v[:roofconcave           ] = @set[id][:roof                  ] if h[:roof                  ]
       v[:roofconvex            ] = @set[id][:roof                  ] if h[:roof                  ]
@@ -758,12 +758,12 @@ module TBD
       v[:balconysillconcave    ] = @set[id][:balcony               ] if h[:balcony               ]
       v[:balconysillconvex     ] = @set[id][:balcony               ] if h[:balcony               ]
       v[:balconysillconcave    ] = @set[id][:balconyconcave        ] if h[:balconyconcave        ]
-      v[:balconysillconvex     ] = @set[id][:balconyconvex         ] if h[:balconycinvex         ]
+      v[:balconysillconvex     ] = @set[id][:balconyconvex         ] if h[:balconyconvex         ]
       v[:balconydoorsill       ] = @set[id][:balcony               ] if h[:balcony               ]
       v[:balconydoorsillconcave] = @set[id][:balcony               ] if h[:balcony               ]
       v[:balconydoorsillconvex ] = @set[id][:balcony               ] if h[:balcony               ]
       v[:balconydoorsillconcave] = @set[id][:balconyconcave        ] if h[:balconyconcave        ]
-      v[:balconydoorsillconvex ] = @set[id][:balconyconvex         ] if h[:balconycinvex         ]
+      v[:balconydoorsillconvex ] = @set[id][:balconyconvex         ] if h[:balconyconvex         ]
       v[:balconysill           ] = @set[id][:balconysill           ] if h[:balconysill           ]
       v[:balconysillconcave    ] = @set[id][:balconysill           ] if h[:balconysill           ]
       v[:balconysillconvex     ] = @set[id][:balconysill           ] if h[:balconysill           ]
@@ -786,10 +786,10 @@ module TBD
       v[:rimjoistconvex        ] = @set[id][:rimjoistconvex        ] if h[:rimjoistconvex        ]
 
       max = [v[:parapetconcave], v[:parapetconvex]].max
-      v[:parapet] = max unless @has[:parapet]
+      v[:parapet] = max unless h[:parapet]
 
       max = [v[:roofconcave], v[:roofconvex]].max
-      v[:roof] = max unless @has[:roof]
+      v[:roof] = max unless h[:roof]
 
       @val[id] = v
 
@@ -982,7 +982,7 @@ module TBD
       mth = "TBD::#{__callee__}"
       sh  = { has: {}, val: {} }
       id  = trim(id)
-      return mismatch("set ID", id, String, mth, ERR, a)      if id.empty?
+      return mismatch("set ID", id, String, mth, ERR, sh)     if id.empty?
       return hashkey(id, @set , id,         mth, ERR, sh) unless @set.key?(id)
       return hashkey(id, @has , id,         mth, ERR, sh) unless @has.key?(id)
       return hashkey(id, @val , id,         mth, ERR, sh) unless @val.key?(id)
@@ -1424,8 +1424,10 @@ module TBD
       m  = m.clone(model).to_MasslessOpaqueMaterial.get
       m.setName("#{id} #{up}m tbd")
 
-      de_r = RMIN                    unless de_r > RMIN
-      loss = (de_u - 1 / de_r) * net unless de_r > RMIN
+      if de_r < RMIN
+        de_r = RMIN
+        loss = (de_u - 1 / de_r) * net
+      end
 
       unless m.setThermalResistance(de_r)
         return invalid("Can't derate #{id}: RSi#{de_r.round(2)}", mth)
@@ -1555,7 +1557,7 @@ module TBD
       next unless surface[:conditioned]
       next     if surface[:ground     ]
 
-      unless surface[:boundary].downcase == "outdoors"
+      unless surface[:boundary] == "outdoors"
         next unless tbd[:surfaces].key?(surface[:boundary])
         next     if tbd[:surfaces][surface[:boundary]][:conditioned]
       end
@@ -1734,9 +1736,9 @@ module TBD
             next unless point_V_mag > TOL
             next unless point_V_mag > farthest_mag
 
-            farthest    = point
-            farthest_V  = origin_point_V
-            fathest_mag = point_V_mag
+            farthest     = point
+            farthest_V   = origin_point_V
+            farthest_mag = point_V_mag
           end
 
           angle  = reference_V.angle(farthest_V)
@@ -2202,7 +2204,7 @@ module TBD
           next      if holes.key?(i)
           next      if shades.key?(i)
 
-          facing = tbd[:surfaces][i][:boundary].downcase
+          facing = tbd[:surfaces][i][:boundary]
           next unless facing == "othersidecoefficients"
 
           s1      = edge[:surfaces][id]
@@ -2971,6 +2973,7 @@ module TBD
     # derate a construction/material pair having " tbd" in their OpenStudio name.
     tbd[:surfaces].each do |id, surface|
       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)
@@ -2981,8 +2984,7 @@ module TBD
       s = model.getSurfaceByName(id)
       next if s.empty?
 
-      s = s.get
-
+      s         = s.get
       index     = surface[:index       ]
       current_c = surface[:construction]
       c         = current_c.clone(model).to_LayeredConstruction.get
@@ -2995,7 +2997,7 @@ module TBD
       if m
         c.setLayer(index, m)
         c.setName("#{id} c tbd")
-        current_R = rsi(current_c, s.filmResistance)
+        current_R = rsi(current_c, surface[:filmRSI])
 
         # In principle, the derated "ratio" could be calculated simply by
         # accessing a surface's uFactor. Yet air layers within constructions
@@ -3035,7 +3037,7 @@ module TBD
 
         # Compute updated RSi value from layers.
         updated_c = s.construction.get.to_LayeredConstruction.get
-        updated_R = rsi(updated_c, s.filmResistance)
+        updated_R = rsi(updated_c, surface[:filmRSI])
         ratio     = -(current_R - updated_R) * 100 / current_R
 
         surface[:ratio] = ratio if ratio.abs > TOL
@@ -3047,14 +3049,10 @@ module TBD
     tbd[:surfaces].each do |id, surface|
       next unless surface[:deratable]
       next unless surface.key?(:construction)
+      next unless surface.key?(:filmRSI)
       next     if surface.key?(:u)
 
-      s   = model.getSurfaceByName(id)
-      msg = "Skipping missing surface '#{id}' (#{mth})"
-      log(ERR, msg) if s.empty?
-      next          if s.empty?
-
-      surface[:u] = 1.0 / rsi(surface[:construction], s.get.filmResistance)
+      surface[:u] = 1.0 / rsi(surface[:construction], surface[:filmRSI])
     end
 
     json[:io][:edges] = []
@@ -3204,8 +3202,8 @@ module TBD
 
       uo     = format("%.3f", g[:uo])
       ut     = format("%.3f", g[:ut])
-      output = "An initial #{label.to_s} Uo of #{uo} W/m2•K is required to " \
-               "achieve an overall Ut of #{ut} W/m2•K for #{g[:op]}"
+      output = "An area-weighted #{label.to_s} Uo of #{uo} W/m2•K is " \
+               "required to meet an overall Ut of #{ut} W/m2•K for #{g[:op]}"
       u_t << output
       runner.registerInfo(output)
     end