tbd 3.4.4 → 3.5.0

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

@@ -1,6 +1,6 @@
 # BSD 3-Clause License
 #
-# Copyright (c) 2022-2024, Denis Bourgeois
+# Copyright (c) 2022-2025, Denis Bourgeois
 # All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
@@ -31,20 +31,26 @@
 require "openstudio"
 
 module OSut
-  # DEBUG for devs; WARN/ERROR for users (bad OS input), see OSlg
   extend OSlg
 
-  TOL  = 0.01             # default distance tolerance (m)
-  TOL2 = TOL * TOL        # default area tolerance (m2)
-  DBG  = OSlg::DEBUG.dup  # see github.com/rd2/oslg
-  INF  = OSlg::INFO.dup   # see github.com/rd2/oslg
-  WRN  = OSlg::WARN.dup   # see github.com/rd2/oslg
-  ERR  = OSlg::ERROR.dup  # see github.com/rd2/oslg
-  FTL  = OSlg::FATAL.dup  # see github.com/rd2/oslg
-  NS   = "nameString"     # OpenStudio object identifier method
-
-  HEAD = 2.032 # standard 80" door
-  SILL = 0.762 # standard 30" window sill
+  DBG  = OSlg::DEBUG.dup # see github.com/rd2/oslg
+  INF  = OSlg::INFO.dup  # see github.com/rd2/oslg
+  WRN  = OSlg::WARN.dup  # see github.com/rd2/oslg
+  ERR  = OSlg::ERROR.dup # see github.com/rd2/oslg
+  FTL  = OSlg::FATAL.dup # see github.com/rd2/oslg
+  NS   = "nameString"    # OpenStudio object identifier method
+  TOL  = 0.01            # default distance tolerance (m)
+  TOL2 = TOL * TOL       # default area tolerance (m2)
+  HEAD = 2.032           # standard 80" door
+  SILL = 0.762           # standard 30" window sill
+  DMIN = 0.010           # min. insulating material thickness
+  DMAX = 1.000           # max. insulating material thickness
+  KMIN = 0.010           # min. insulating material thermal conductivity
+  KMAX = 2.000           # max. insulating material thermal conductivity
+  UMAX = KMAX / DMIN     # material USi upper limit, 200.000
+  UMIN = KMIN / DMAX     # material USi lower limit,   0.010
+  RMIN = 1.0 / UMAX      # material RSi lower limit,   0.005 (or R-IP   0.03)
+  RMAX = 1.0 / UMIN      # material RSi upper limit, 100.000 (or R-IP 567.80)
 
   # General surface orientations (see facets method)
   SIDZ = [:bottom, # e.g. ground-facing, exposed floors
@@ -191,6 +197,388 @@ module OSut
   @@mats[:door     ][:rho] =  600.000
   @@mats[:door     ][:cp ] = 1000.000
 
+  ##
+  # Validates if every material in a layered construction is standard & opaque.
+  #
+  # @param lc [OpenStudio::LayeredConstruction] a layered construction
+  #
+  # @return [Bool] whether all layers are valid
+  # @return [false] if invalid input (see logs)
+  def standardOpaqueLayers?(lc = nil)
+    mth = "OSut::#{__callee__}"
+    cl  = OpenStudio::Model::LayeredConstruction
+    return invalid("lc", mth, 1, DBG, false) unless lc.respond_to?(NS)
+    return mismatch(lc.nameString, lc, cl, mth, DBG, false) unless lc.is_a?(cl)
+
+    lc.layers.each { |m| return false if m.to_StandardOpaqueMaterial.empty? }
+
+    true
+  end
+
+  ##
+  # Returns total (standard opaque) layered construction thickness (m).
+  #
+  # @param lc [OpenStudio::LayeredConstruction] a layered construction
+  #
+  # @return [Float] construction thickness
+  # @return [0.0] if invalid input (see logs)
+  def thickness(lc = nil)
+    mth = "OSut::#{__callee__}"
+    cl  = OpenStudio::Model::LayeredConstruction
+    return invalid("lc", mth, 1, DBG, 0.0) unless lc.respond_to?(NS)
+    return mismatch(lc.nameString, lc, cl, mth, DBG, 0.0) unless lc.is_a?(cl)
+
+    unless standardOpaqueLayers?(lc)
+      log(ERR, "#{lc.nameString} holds non-StandardOpaqueMaterial(s) (#{mth})")
+      return 0.0
+    end
+
+    thickness = 0.0
+
+    lc.layers.each { |m| thickness += m.thickness }
+
+    thickness
+  end
+
+  ##
+  # Returns total air film resistance of a fenestrated construction (m2•K/W)
+  #
+  # @param usi [Numeric] a fenestrated construction's U-factor (W/m2•K)
+  #
+  # @return [Float] total air film resistances
+  # @return [0.1216] if invalid input (see logs)
+  def glazingAirFilmRSi(usi = 5.85)
+    # The sum of thermal resistances of calculated exterior and interior film
+    # coefficients under standard winter conditions are taken from:
+    #
+    #   https://bigladdersoftware.com/epx/docs/9-6/engineering-reference/
+    #   window-calculation-module.html#simple-window-model
+    #
+    # These remain acceptable approximations for flat windows, yet likely
+    # unsuitable for subsurfaces with curved or projecting shapes like domed
+    # skylights. The solution here is considered an adequate fix for reporting.
+    #
+    # For U-factors above 8.0 W/m2•K (or invalid input), the function returns
+    # 0.1216 m2•K/W, which corresponds to a construction with a single glass
+    # layer thickness of 2mm & k = ~0.6 W/m.K.
+    #
+    # The EnergyPlus Engineering calculations were designed for vertical
+    # windows - not horizontal, slanted or domed surfaces - use with caution.
+    mth = "OSut::#{__callee__}"
+    cl  = Numeric
+    return mismatch("usi", usi, cl, mth,    DBG, 0.1216)  unless usi.is_a?(cl)
+    return invalid("usi",           mth, 1, WRN, 0.1216)      if usi > 8.0
+    return negative("usi",          mth,    WRN, 0.1216)      if usi < 0
+    return zero("usi",              mth,    WRN, 0.1216)      if usi.abs < TOL
+
+    rsi = 1 / (0.025342 * usi + 29.163853) # exterior film, next interior film
+    return rsi + 1 / (0.359073 * Math.log(usi) + 6.949915) if usi < 5.85
+    return rsi + 1 / (1.788041 * usi - 2.886625)
+  end
+
+  ##
+  # Returns a construction's 'standard calc' thermal resistance (m2•K/W), which
+  # includes air film resistances. It excludes insulating effects of shades,
+  # screens, etc. in the case of fenestrated constructions.
+  #
+  # @param lc [OpenStudio::Model::LayeredConstruction] a layered construction
+  # @param film [Numeric] thermal resistance of surface air films (m2•K/W)
+  # @param t [Numeric] gas temperature (°C) (optional)
+  #
+  # @return [Float] layered construction's thermal resistance
+  # @return [0.0] if invalid input (see logs)
+  def rsi(lc = nil, film = 0.0, t = 0.0)
+    # This is adapted from BTAP's Material Module "get_conductance" (P. Lopez)
+    #
+    #   https://github.com/NREL/OpenStudio-Prototype-Buildings/blob/
+    #   c3d5021d8b7aef43e560544699fb5c559e6b721d/lib/btap/measures/
+    #   btap_equest_converter/envelope.rb#L122
+    mth = "OSut::#{__callee__}"
+    cl1 = OpenStudio::Model::LayeredConstruction
+    cl2 = Numeric
+    return invalid("lc", mth, 1, DBG, 0.0) unless lc.respond_to?(NS)
+    return mismatch(lc.nameString, lc, cl1, mth, DBG, 0.0) unless lc.is_a?(cl1)
+    return mismatch("film", film, cl2, mth, DBG, 0.0) unless film.is_a?(cl2)
+    return mismatch("temp K",  t, cl2, mth, DBG, 0.0) unless t.is_a?(cl2)
+
+    t += 273.0 # °C to K
+    return negative("temp K", mth, ERR, 0.0) if t < 0
+    return negative("film",   mth, ERR, 0.0) if film < 0
+
+    rsi = film
+
+    lc.layers.each do |m|
+      # Fenestration materials first.
+      empty = m.to_SimpleGlazing.empty?
+      return 1 / m.to_SimpleGlazing.get.uFactor                     unless empty
+
+      empty = m.to_StandardGlazing.empty?
+      rsi += m.to_StandardGlazing.get.thermalResistance             unless empty
+      empty = m.to_RefractionExtinctionGlazing.empty?
+      rsi += m.to_RefractionExtinctionGlazing.get.thermalResistance unless empty
+      empty = m.to_Gas.empty?
+      rsi += m.to_Gas.get.getThermalResistance(t)                   unless empty
+      empty = m.to_GasMixture.empty?
+      rsi += m.to_GasMixture.get.getThermalResistance(t)            unless empty
+
+      # Opaque materials next.
+      empty = m.to_StandardOpaqueMaterial.empty?
+      rsi += m.to_StandardOpaqueMaterial.get.thermalResistance      unless empty
+      empty = m.to_MasslessOpaqueMaterial.empty?
+      rsi += m.to_MasslessOpaqueMaterial.get.thermalResistance      unless empty
+      empty = m.to_RoofVegetation.empty?
+      rsi += m.to_RoofVegetation.get.thermalResistance              unless empty
+      empty = m.to_AirGap.empty?
+      rsi += m.to_AirGap.get.thermalResistance                      unless empty
+    end
+
+    rsi
+  end
+
+  ##
+  # Identifies a layered construction's (opaque) insulating layer. The method
+  # returns a 3-keyed hash :index, the insulating layer index [0, n layers)
+  # within the layered construction; :type, either :standard or :massless; and
+  # :r, material thermal resistance in m2•K/W.
+  #
+  # @param lc [OpenStudio::Model::LayeredConstruction] a layered construction
+  #
+  # @return [Hash] index: (Integer), type: (Symbol), r: (Float)
+  # @return [Hash] index: nil, type: nil, r: 0.0 if invalid input (see logs)
+  def insulatingLayer(lc = nil)
+    mth = "OSut::#{__callee__}"
+    cl  = OpenStudio::Model::LayeredConstruction
+    res = { index: nil, type: nil, r: 0.0 }
+    i   = 0 # iterator
+    return invalid("lc", mth, 1, DBG, res) unless lc.respond_to?(NS)
+    return mismatch(lc.nameString, lc, cl, mth, DBG, res) unless lc.is_a?(cl)
+
+    lc.layers.each do |m|
+      unless m.to_MasslessOpaqueMaterial.empty?
+        m = m.to_MasslessOpaqueMaterial.get
+
+        if m.thermalResistance < RMIN || m.thermalResistance < res[:r]
+          i += 1
+          next
+        else
+          res[:r    ] = m.thermalResistance
+          res[:index] = i
+          res[:type ] = :massless
+        end
+      end
+
+      unless m.to_StandardOpaqueMaterial.empty?
+        m = m.to_StandardOpaqueMaterial.get
+        k = m.thermalConductivity
+        d = m.thickness
+
+        if d < DMIN || k > KMAX || d / k < res[:r]
+          i += 1
+          next
+        else
+          res[:r    ] = d / k
+          res[:index] = i
+          res[:type ] = :standard
+        end
+      end
+
+      i += 1
+    end
+
+    res
+  end
+
+  ##
+  # Validates whether a material is both uniquely reserved to a single layered
+  # construction in a model, and referenced only once in the construction.
+  # Limited to 'standard' or 'massless' materials.
+  #
+  # @param m [OpenStudio::Model::OpaqueMaterial] a material
+  #
+  # @return [Boolean] whether material is unique
+  # @return [false] if missing)
+  def uniqueMaterial?(m = nil)
+    mth = "OSut::#{__callee__}"
+    cl1 = OpenStudio::Model::OpaqueMaterial
+    return invalid("mat", mth, 1, DBG, false) unless m.respond_to?(NS)
+    return mismatch(m.nameString, m, cl1, mth, DBG, false) unless m.is_a?(cl1)
+
+    num = 0
+    lcs = m.model.getLayeredConstructions
+
+    unless m.to_MasslessOpaqueMaterial.empty?
+      m = m.to_MasslessOpaqueMaterial.get
+
+      lcs.each { |lc| num += lc.getLayerIndices(m).size }
+
+      return true if num == 1
+    end
+
+    unless m.to_StandardOpaqueMaterial.empty?
+      m = m.to_StandardOpaqueMaterial.get
+
+      lcs.each { |lc| num += lc.getLayerIndices(m).size }
+
+      return true if num == 1
+    end
+
+    false
+  end
+
+  ##
+  # Sets a layered construction material as unique. Solution similar to
+  # OpenStudio::Model::LayeredConstruction's 'ensureUniqueLayers', yet limited
+  # here to a single indexed OpenStudio material, typically the principal
+  # insulating material. Returns true if the indexed material is already unique.
+  # Limited to 'standard' or 'massless' materials.
+  #
+  # @param lc [OpenStudio::Model::LayeredConstruction] a construction
+  # @param index [Integer] the construction layer index of the material
+  #
+  # @return [Boolean] if assigned as unique
+  # @return [false] if invalid inputs
+  def assignUniqueMaterial(lc = nil, index = nil)
+    mth = "OSut::#{__callee__}"
+    cl1 = OpenStudio::Model::LayeredConstruction
+    cl2 = Integer
+    return invalid("lc", mth, 1, DBG, false) unless lc.respond_to?(NS)
+    return mismatch(lc.nameString, lc, cl1, mth, DBG, false) unless lc.is_a?(cl1)
+    return mismatch("index", index, cl2, mth, DBG, false) unless index.is_a?(cl2)
+    return invalid("index", mth, 0, DBG, false) unless index.between?(0, lc.numLayers - 1)
+
+    m = lc.getLayer(index)
+
+    unless m.to_MasslessOpaqueMaterial.empty?
+      m = m.to_MasslessOpaqueMaterial.get
+      return true if uniqueMaterial?(m)
+
+      mat = m.clone(m.model).to_MasslessOpaqueMaterial.get
+      return lc.setLayer(index, mat)
+    end
+
+    unless m.to_StandardOpaqueMaterial.empty?
+      m = m.to_StandardOpaqueMaterial.get
+      return true if uniqueMaterial?(m)
+
+      mat = m.clone(m.model).to_StandardOpaqueMaterial.get
+      return lc.setLayer(index, mat)
+    end
+
+    false
+  end
+
+  ##
+  # 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
+  # recovered instead of instantiating a new one. The latter is renamed
+  # according to its adjusted conductivity/thickness (or RSi value).
+  #
+  # @param lc [OpenStudio::Model::LayeredConstruction] a construction
+  # @param film [Float] construction air film resistance
+  # @param index [Integer] the insulating layer's array index
+  # @param uo [Float] desired Uo factor (with air film resistance)
+  # @param uniq [Boolean] whether to enforce material uniqueness
+  #
+  # @return [Float] new layer RSi [RMIN, RMAX]
+  # @return [0.0] if invalid input
+  def resetUo(lc = nil, film = nil, index = nil, uo = nil, uniq = false)
+    mth = "OSut::#{__callee__}"
+    r   = 0.0 # thermal resistance of new material
+    cl1 = OpenStudio::Model::LayeredConstruction
+    cl2 = Numeric
+    cl3 = Integer
+    return invalid("lc", mth, 1, DBG, r) unless lc.respond_to?(NS)
+    return mismatch(lc.nameString, lc, cl1, mth, DBG, r) unless lc.is_a?(cl1)
+    return mismatch("film", film, cl2, mth, DBG, r) unless film.is_a?(cl2)
+    return negative("film", mth, DBG, r) if film.negative?
+    return mismatch("index", index, cl3, mth, DBG, r) unless index.is_a?(cl3)
+    return invalid("index", mth, 3, DBG, r) unless index.between?(0, lc.numLayers - 1)
+    return mismatch("uo", uo, cl2, mth, DBG, r) unless uo.is_a?(cl2)
+
+    unless uo.between?(UMIN, UMAX)
+      uo = clamp(UMIN, UMAX)
+      log(WRN, "Resetting Uo (#{lc.nameString}) to #{uo.round(3)} (#{mth})")
+    end
+
+    uniq = false unless [true, false].include?(uniq)
+    r0 = rsi(lc, film) # current construction RSi value
+    ro = 1 / uo        # desired construction RSi value
+    dR = ro - r0       # desired increase in construction RSi
+    m  = lc.getLayer(index)
+
+    unless m.to_MasslessOpaqueMaterial.empty?
+      m = m.to_MasslessOpaqueMaterial.get
+      r = m.thermalResistance
+      return r if dR.abs.round(2) == 0.00
+
+      r  = (r + dR).clamp(RMIN, RMAX)
+      id = "OSut:RSi#{r.round(2)}"
+      mt = lc.model.getMasslessOpaqueMaterialByName(id)
+
+      # Existing material?
+      unless mt.empty?
+        mt = mt.get
+
+        if r.round(2) == mt.thermalResistance.round(2) && uniq == false
+          lc.setLayer(index, mt)
+          return r
+        end
+      end
+
+      mt = m.clone(m.model).to_MasslessOpaqueMaterial.get
+      mt.setName(id)
+
+      unless mt.setThermalResistance(r)
+        return invalid("Failed #{id}: RSi#{de_r.round(2)}", mth)
+      end
+
+      lc.setLayer(index, mt)
+
+      return r
+    end
+
+    unless m.to_StandardOpaqueMaterial.empty?
+      m = m.to_StandardOpaqueMaterial.get
+      r = m.thickness / m.conductivity
+      return r if dR.abs.round(2) == 0.00
+
+      k = (m.thickness / (r + dR)).clamp(KMIN, KMAX)
+      d = (k * (r + dR)).clamp(DMIN, DMAX)
+      r  = d / k
+      id = "OSUT:K#{format('%4.3f', k)}:#{format('%03d', d*1000)[-3..-1]}"
+      mt = lc.model.getStandardOpaqueMaterialByName(id)
+
+      # Existing material?
+      unless mt.empty?
+        mt = mt.get
+        rt = mt.thickness / mt.conductivity
+
+        if r.round(2) == rt.round(2) && uniq == false
+          lc.setLayer(index, mt)
+          return r
+        end
+      end
+
+      mt = m.clone(m.model).to_StandardOpaqueMaterial.get
+      mt.setName(id)
+
+      unless mt.setThermalConductivity(k)
+        return invalid("Failed #{id}: K#{k.round(3)}", mth)
+      end
+
+      unless mt.setThickness(d)
+        return invalid("Failed #{id}: #{(d*1000).to_i}mm", mth)
+      end
+
+      lc.setLayer(index, mt)
+
+      return r
+    end
+
+    0
+  end
+
   ##
   # Generates an OpenStudio multilayered construction, + materials if needed.
   #
@@ -214,19 +602,27 @@ module OSut
 
     specs[:id] = "" unless specs.key?(:id)
     id = trim(specs[:id])
-    id = "OSut|CON|#{specs[:type]}" if id.empty?
+    id = "OSut:CON:#{specs[:type]}" if id.empty?
 
-    specs[:type] = :wall unless specs.key?(:type)
-    chk = @@uo.keys.include?(specs[:type])
-    return invalid("surface type", mth, 2, ERR) unless chk
+    if specs.key?(:type)
+      unless @@uo.keys.include?(specs[:type])
+        return invalid("surface type", mth, 2, ERR)
+      end
+    else
+      specs[:type] = :wall
+    end
 
-    specs[:uo] = @@uo[ specs[:type] ] unless specs.key?(:uo)
+    specs[:uo] = @@uo[ specs[:type] ] unless specs.key?(:uo) # can be nil
     u = specs[:uo]
 
-    if u
-      return mismatch("#{id} Uo", u, Numeric, mth)  unless u.is_a?(Numeric)
-      return invalid("#{id} Uo (> 5.678)", mth, 2, ERR) if u > 5.678
-      return negative("#{id} Uo"         , mth,    ERR) if u < 0
+    unless u.nil?
+      return mismatch("#{id} Uo", u, Numeric, mth) unless u.is_a?(Numeric)
+
+      unless u.between?(UMIN, 5.678)
+        uO = u
+        u  = uO.clamp(UMIN, 5.678)
+        log(ERR, "Resetting Uo #{uO.round(3)} to #{u.round(3)} (#{mth})")
+      end
     end
 
     # Optional specs. Log/reset if invalid.
@@ -255,14 +651,14 @@ module OSut
       d  = 0.015
       a[:compo][:mat] = @@mats[mt]
       a[:compo][:d  ] = d
-      a[:compo][:id ] = "OSut|#{mt}|#{format('%03d', d*1000)[-3..-1]}"
+      a[:compo][:id ] = "OSut:#{mt}:#{format('%03d', d*1000)[-3..-1]}"
     when :partition
       unless specs[:clad] == :none
         d  = 0.015
         mt = :drywall
         a[:clad][:mat] = @@mats[mt]
         a[:clad][:d  ] = d
-        a[:clad][:id ] = "OSut|#{mt}|#{format('%03d', d*1000)[-3..-1]}"
+        a[:clad][:id ] = "OSut:#{mt}:#{format('%03d', d*1000)[-3..-1]}"
       end
 
       d  = 0.015
@@ -274,14 +670,14 @@ module OSut
       mt = :mineral   if u
       a[:compo][:mat] = @@mats[mt]
       a[:compo][:d  ] = d
-      a[:compo][:id ] = "OSut|#{mt}|#{format('%03d', d*1000)[-3..-1]}"
+      a[:compo][:id ] = "OSut:#{mt}:#{format('%03d', d*1000)[-3..-1]}"
 
       unless specs[:finish] == :none
         d  = 0.015
         mt = :drywall
         a[:finish][:mat] = @@mats[mt]
         a[:finish][:d  ] = d
-        a[:finish][:id ] = "OSut|#{mt}|#{format('%03d', d*1000)[-3..-1]}"
+        a[:finish][:id ] = "OSut:#{mt}:#{format('%03d', d*1000)[-3..-1]}"
       end
     when :wall
       unless specs[:clad] == :none
@@ -292,7 +688,7 @@ module OSut
         d  = 0.015     if specs[:clad] == :light
         a[:clad][:mat] = @@mats[mt]
         a[:clad][:d  ] = d
-        a[:clad][:id ] = "OSut|#{mt}|#{format('%03d', d*1000)[-3..-1]}"
+        a[:clad][:id ] = "OSut:#{mt}:#{format('%03d', d*1000)[-3..-1]}"
       end
 
       mt = :drywall
@@ -302,7 +698,7 @@ module OSut
       d  = 0.015       if specs[:frame] == :light
       a[:sheath][:mat] = @@mats[mt]
       a[:sheath][:d  ] = d
-      a[:sheath][:id ] = "OSut|#{mt}|#{format('%03d', d*1000)[-3..-1]}"
+      a[:sheath][:id ] = "OSut:#{mt}:#{format('%03d', d*1000)[-3..-1]}"
 
       mt = :mineral
       mt = :cellulose if specs[:frame] == :medium
@@ -314,7 +710,7 @@ module OSut
 
       a[:compo][:mat] = @@mats[mt]
       a[:compo][:d  ] = d
-      a[:compo][:id ] = "OSut|#{mt}|#{format('%03d', d*1000)[-3..-1]}"
+      a[:compo][:id ] = "OSut:#{mt}:#{format('%03d', d*1000)[-3..-1]}"
 
       unless specs[:finish] == :none
         mt = :concrete
@@ -324,7 +720,7 @@ module OSut
         d  = 0.200      if specs[:finish] == :heavy
         a[:finish][:mat] = @@mats[mt]
         a[:finish][:d  ] = d
-        a[:finish][:id ] = "OSut|#{mt}|#{format('%03d', d*1000)[-3..-1]}"
+        a[:finish][:id ] = "OSut:#{mt}:#{format('%03d', d*1000)[-3..-1]}"
       end
     when :roof
       unless specs[:clad] == :none
@@ -335,7 +731,7 @@ module OSut
         d  = 0.200     if specs[:clad] == :heavy  # e.g. parking garage
         a[:clad][:mat] = @@mats[mt]
         a[:clad][:d  ] = d
-        a[:clad][:id ] = "OSut|#{mt}|#{format('%03d', d*1000)[-3..-1]}"
+        a[:clad][:id ] = "OSut:#{mt}:#{format('%03d', d*1000)[-3..-1]}"
       end
 
       mt = :mineral
@@ -346,7 +742,7 @@ module OSut
       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]}"
+      a[:compo][:id ] = "OSut:#{mt}:#{format('%03d', d*1000)[-3..-1]}"
 
       unless specs[:finish] == :none
         mt = :concrete
@@ -356,7 +752,7 @@ module OSut
         d  = 0.200      if specs[:finish] == :heavy
         a[:finish][:mat] = @@mats[mt]
         a[:finish][:d  ] = d
-        a[:finish][:id ] = "OSut|#{mt}|#{format('%03d', d*1000)[-3..-1]}"
+        a[:finish][:id ] = "OSut:#{mt}:#{format('%03d', d*1000)[-3..-1]}"
       end
     when :floor
       unless specs[:clad] == :none
@@ -364,7 +760,7 @@ module OSut
         d  = 0.015
         a[:clad][:mat] = @@mats[mt]
         a[:clad][:d  ] = d
-        a[:clad][:id ] = "OSut|#{mt}|#{format('%03d', d*1000)[-3..-1]}"
+        a[:clad][:id ] = "OSut:#{mt}:#{format('%03d', d*1000)[-3..-1]}"
       end
 
       mt = :mineral
@@ -375,7 +771,7 @@ module OSut
       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]}"
+      a[:compo][:id ] = "OSut:#{mt}:#{format('%03d', d*1000)[-3..-1]}"
 
       unless specs[:finish] == :none
         mt = :concrete
@@ -385,21 +781,21 @@ module OSut
         d  = 0.200      if specs[:finish] == :heavy
         a[:finish][:mat] = @@mats[mt]
         a[:finish][:d  ] = d
-        a[:finish][:id ] = "OSut|#{mt}|#{format('%03d', d*1000)[-3..-1]}"
+        a[:finish][:id ] = "OSut:#{mt}:#{format('%03d', d*1000)[-3..-1]}"
       end
     when :slab
       mt = :sand
       d  = 0.100
       a[:clad][:mat] = @@mats[mt]
       a[:clad][:d  ] = d
-      a[:clad][:id ] = "OSut|#{mt}|#{format('%03d', d*1000)[-3..-1]}"
+      a[:clad][:id ] = "OSut:#{mt}:#{format('%03d', d*1000)[-3..-1]}"
 
       unless specs[:frame] == :none
         mt = :polyiso
         d  = 0.025
         a[:sheath][:mat] = @@mats[mt]
         a[:sheath][:d  ] = d
-        a[:sheath][:id ] = "OSut|#{mt}|#{format('%03d', d*1000)[-3..-1]}"
+        a[:sheath][:id ] = "OSut:#{mt}:#{format('%03d', d*1000)[-3..-1]}"
       end
 
       mt = :concrete
@@ -407,14 +803,14 @@ module OSut
       d  = 0.200      if specs[:frame] == :heavy
       a[:compo][:mat] = @@mats[mt]
       a[:compo][:d  ] = d
-      a[:compo][:id ] = "OSut|#{mt}|#{format('%03d', d*1000)[-3..-1]}"
+      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]}"
+        a[:finish][:id ] = "OSut:#{mt}:#{format('%03d', d*1000)[-3..-1]}"
       end
     when :basement
       unless specs[:clad] == :none
@@ -424,38 +820,38 @@ module OSut
         d  = 0.015     if specs[:clad] == :light
         a[:clad][:mat] = @@mats[mt]
         a[:clad][:d  ] = d
-        a[:clad][:id ] = "OSut|#{mt}|#{format('%03d', d*1000)[-3..-1]}"
+        a[:clad][:id ] = "OSut:#{mt}:#{format('%03d', d*1000)[-3..-1]}"
 
         mt = :polyiso
         d  = 0.025
         a[:sheath][:mat] = @@mats[mt]
         a[:sheath][:d  ] = d
-        a[:sheath][:id ] = "OSut|#{mt}|#{format('%03d', d*1000)[-3..-1]}"
+        a[:sheath][:id ] = "OSut:#{mt}:#{format('%03d', d*1000)[-3..-1]}"
 
         mt = :concrete
         d  = 0.200
         a[:compo][:mat] = @@mats[mt]
         a[:compo][:d  ] = d
-        a[:compo][:id ] = "OSut|#{mt}|#{format('%03d', d*1000)[-3..-1]}"
+        a[:compo][:id ] = "OSut:#{mt}:#{format('%03d', d*1000)[-3..-1]}"
       else
         mt = :concrete
         d  = 0.200
         a[:sheath][:mat] = @@mats[mt]
         a[:sheath][:d  ] = d
-        a[:sheath][:id ] = "OSut|#{mt}|#{format('%03d', d*1000)[-3..-1]}"
+        a[:sheath][:id ] = "OSut:#{mt}:#{format('%03d', d*1000)[-3..-1]}"
 
         unless specs[:finish] == :none
           mt = :mineral
           d  = 0.075
           a[:compo][:mat] = @@mats[mt]
           a[:compo][:d  ] = d
-          a[:compo][:id ] = "OSut|#{mt}|#{format('%03d', d*1000)[-3..-1]}"
+          a[:compo][:id ] = "OSut:#{mt}:#{format('%03d', d*1000)[-3..-1]}"
 
           mt = :drywall
           d  = 0.015
           a[:finish][:mat] = @@mats[mt]
           a[:finish][:d  ] = d
-          a[:finish][:id ] = "OSut|#{mt}|#{format('%03d', d*1000)[-3..-1]}"
+          a[:finish][:id ] = "OSut:#{mt}:#{format('%03d', d*1000)[-3..-1]}"
         end
       end
     when :door
@@ -464,43 +860,27 @@ module OSut
 
       a[:compo  ][:mat ] = @@mats[mt]
       a[:compo  ][:d   ] = d
-      a[:compo  ][:id  ] = "OSut|#{mt}|#{format('%03d', d*1000)[-3..-1]}"
+      a[:compo  ][:id  ] = "OSut:#{mt}:#{format('%03d', d*1000)[-3..-1]}"
     when :window
-      a[:glazing][:u   ]  = specs[:uo  ]
+      a[:glazing][:u   ]  = u ? u : @@uo[:window]
       a[:glazing][:shgc]  = 0.450
       a[:glazing][:shgc]  = specs[:shgc] if specs.key?(:shgc)
-      a[:glazing][:id  ]  = "OSut|window"
-      a[:glazing][:id  ] += "|U#{format('%.1f', a[:glazing][:u])}"
-      a[:glazing][:id  ] += "|SHGC#{format('%d', a[:glazing][:shgc]*100)}"
+      a[:glazing][:id  ]  = "OSut:window"
+      a[:glazing][:id  ] += ":U#{format('%.1f', a[:glazing][:u])}"
+      a[:glazing][:id  ] += ":SHGC#{format('%d', a[:glazing][:shgc]*100)}"
     when :skylight
-      a[:glazing][:u   ] = specs[:uo  ]
+      a[:glazing][:u   ] = u ? u : @@uo[:skylight]
       a[:glazing][:shgc] = 0.450
       a[:glazing][:shgc] = specs[:shgc] if specs.key?(:shgc)
-      a[:glazing][:id  ]  = "OSut|skylight"
-      a[:glazing][:id  ] += "|U#{format('%.1f', a[:glazing][:u])}"
-      a[:glazing][:id  ] += "|SHGC#{format('%d', a[:glazing][:shgc]*100)}"
+      a[:glazing][:id  ]  = "OSut:skylight"
+      a[:glazing][:id  ] += ":U#{format('%.1f', a[:glazing][:u])}"
+      a[:glazing][:id  ] += ":SHGC#{format('%d', a[:glazing][:shgc]*100)}"
     end
 
     # Initiate layers.
-    glazed = true
-    glazed = false if a[:glazing].empty?
-    layers = OpenStudio::Model::OpaqueMaterialVector.new   unless glazed
-    layers = OpenStudio::Model::FenestrationMaterialVector.new if glazed
-
-    if glazed
-      u    = a[:glazing][:u   ]
-      shgc = a[:glazing][:shgc]
-      lyr  = model.getSimpleGlazingByName(a[:glazing][:id])
-
-      if lyr.empty?
-        lyr = OpenStudio::Model::SimpleGlazing.new(model, u, shgc)
-        lyr.setName(a[:glazing][:id])
-      else
-        lyr = lyr.get
-      end
+    if a[:glazing].empty?
+      layers = OpenStudio::Model::OpaqueMaterialVector.new
 
-      layers << lyr
-    else
       # Loop through each layer spec, and generate construction.
       a.each do |i, l|
         next if l.empty?
@@ -524,44 +904,68 @@ module OSut
 
         layers << lyr
       end
+    else
+      layers = OpenStudio::Model::FenestrationMaterialVector.new
+
+      u0   = a[:glazing][:u   ]
+      shgc = a[:glazing][:shgc]
+      lyr  = model.getSimpleGlazingByName(a[:glazing][:id])
+
+      if lyr.empty?
+        lyr = OpenStudio::Model::SimpleGlazing.new(model, u0, shgc)
+        lyr.setName(a[:glazing][:id])
+      else
+        lyr = lyr.get
+      end
+
+      layers << lyr
     end
 
-    c  = OpenStudio::Model::Construction.new(layers)
+    c = OpenStudio::Model::Construction.new(layers)
     c.setName(id)
 
-    # Adjust insulating layer thickness or conductivity to match requested Uo.
-    unless glazed
-      ro = 0
-      ro = 1 / specs[:uo] - @@film[ specs[:type] ] if specs[:uo]
+    # Adjust insulating layer conductivity (maybe thickness) to match Uo.
+    if u and a[:glazing].empty?
+      ro = 1 / u - film
+
+
+      if ro > RMIN
+        if specs[:type] == :door # 1x layer, adjust conductivity
+          layer = c.getLayer(0).to_StandardOpaqueMaterial
+          return invalid("#{id} standard material?", mth, 0) if layer.empty?
+
+          layer = layer.get
+          k     = layer.thickness / ro
+          layer.setConductivity(k)
+        else # multiple layers, adjust layer conductivity, then thickness
+          lyr = insulatingLayer(c)
+          return invalid("#{id} construction", mth, 0) if lyr[:index].nil?
+          return invalid("#{id} construction", mth, 0) if lyr[:type ].nil?
+          return invalid("#{id} construction", mth, 0) if lyr[:r    ].to_i.zero?
 
-      if specs[:type] == :door # 1x layer, adjust conductivity
-        layer = c.getLayer(0).to_StandardOpaqueMaterial
-        return invalid("#{id} standard material?", mth, 0) if layer.empty?
+          index = lyr[:index]
+          layer = c.getLayer(index).to_StandardOpaqueMaterial
+          return invalid("#{id} material @#{index}", mth, 0) if layer.empty?
 
-        layer = layer.get
-        k     = layer.thickness / ro
-        layer.setConductivity(k)
-      elsif ro > 0 # multiple layers, adjust insulating layer thickness
-        lyr = insulatingLayer(c)
-        return invalid("#{id} construction", mth, 0) if lyr[:index].nil?
-        return invalid("#{id} construction", mth, 0) if lyr[:type ].nil?
-        return invalid("#{id} construction", mth, 0) if lyr[:r    ].zero?
+          layer = layer.get
 
-        index = lyr[:index]
-        layer = c.getLayer(index).to_StandardOpaqueMaterial
-        return invalid("#{id} material @#{index}", mth, 0) if layer.empty?
+          k = (layer.thickness / (ro - rsi(c) + lyr[:r])).clamp(KMIN, KMAX)
+          d = (k * (ro - rsi(c) + lyr[:r])).clamp(DMIN, DMAX)
 
-        layer = layer.get
-        k     = layer.conductivity
-        d     = (ro - rsi(c) + lyr[:r]) * k
-        return invalid("#{id} adjusted m", mth, 0) if d < 0.03
+          nom  = "OSut:"
+          nom += layer.nameString.gsub(/[^a-z]/i, "").gsub("OSut", "")
+          nom += ":K#{format('%4.3f', k)}:#{format('%03d', d*1000)[-3..-1]}"
 
-        nom   = "OSut|"
-        nom  += layer.nameString.gsub(/[^a-z]/i, "").gsub("OSut", "")
-        nom  += "|"
-        nom  += format("%03d", d*1000)[-3..-1]
-        layer.setName(nom) if model.getStandardOpaqueMaterialByName(nom).empty?
-        layer.setThickness(d)
+          lyr = model.getStandardOpaqueMaterialByName(nom)
+
+          if lyr.empty?
+            layer.setName(nom)
+            layer.setConductivity(k)
+            layer.setThickness(d)
+          else
+            c.setLayer(index, lyr.get)
+          end
+        end
       end
     end
 
@@ -608,20 +1012,20 @@ module OSut
     end
 
     # Shading schedule.
-    id  = "OSut|SHADE|Ruleset"
+    id  = "OSut:SHADE:Ruleset"
     sch = mdl.getScheduleRulesetByName(id)
 
     if sch.empty?
       sch = OpenStudio::Model::ScheduleRuleset.new(mdl, 0)
       sch.setName(id)
       sch.setScheduleTypeLimits(onoff)
-      sch.defaultDaySchedule.setName("OSut|Shade|Ruleset|Default")
+      sch.defaultDaySchedule.setName("OSut:Shade:Ruleset:Default")
     else
       sch = sch.get
     end
 
     # Summer cooling rule.
-    id   = "OSut|SHADE|ScheduleRule"
+    id   = "OSut:SHADE:ScheduleRule"
     rule = mdl.getScheduleRuleByName(id)
 
     if rule.empty?
@@ -635,14 +1039,14 @@ module OSut
       rule.setStartDate(start)
       rule.setEndDate(finish)
       rule.setApplyAllDays(true)
-      rule.daySchedule.setName("OSut|Shade|Rule|Default")
+      rule.daySchedule.setName("OSut:Shade:Rule:Default")
       rule.daySchedule.addValue(OpenStudio::Time.new(0,24,0,0), 1)
     else
       rule = rule.get
     end
 
     # Shade object.
-    id  = "OSut|Shade"
+    id  = "OSut:Shade"
     shd = mdl.getShadeByName(id)
 
     if shd.empty?
@@ -653,7 +1057,7 @@ module OSut
     end
 
     # Shading control (unique to each call).
-    id  = "OSut|ShadingControl"
+    id  = "OSut:ShadingControl"
     ctl = OpenStudio::Model::ShadingControl.new(shd)
     ctl.setName(id)
     ctl.setSchedule(sch)
@@ -689,7 +1093,7 @@ module OSut
 
     # A single material.
     mdl = sps.first.model
-    id  = "OSut|MASS|Material"
+    id  = "OSut:MASS:Material"
     mat = mdl.getOpaqueMaterialByName(id)
 
     if mat.empty?
@@ -708,7 +1112,7 @@ module OSut
     end
 
     # A single, 1x layered construction.
-    id  = "OSut|MASS|Construction"
+    id  = "OSut:MASS:Construction"
     con = mdl.getConstructionByName(id)
 
     if con.empty?
@@ -721,7 +1125,7 @@ module OSut
       con = con.get
     end
 
-    id = "OSut|InternalMassDefinition|" + (format "%.2f", ratio)
+    id = "OSut:InternalMassDefinition:" + (format "%.2f", ratio)
     df = mdl.getInternalMassDefinitionByName(id)
 
     if df.empty?
@@ -735,7 +1139,7 @@ module OSut
 
     sps.each do |sp|
       mass = OpenStudio::Model::InternalMass.new(df)
-      mass.setName("OSut|InternalMass|#{sp.nameString}")
+      mass.setName("OSut:InternalMass:#{sp.nameString}")
       mass.setSpace(sp)
     end
 
@@ -743,13 +1147,13 @@ module OSut
   end
 
   ##
-  # Validates if a default construction set holds a base construction.
+  # Validates if a default construction set holds an opaque base construction.
   #
   # @param set [OpenStudio::Model::DefaultConstructionSet] a default set
-  # @param bse [OpensStudio::Model::ConstructionBase] a construction base
+  # @param bse [OpenStudio::Model::ConstructionBase] an opaque construction base
   # @param gr [Bool] if ground-facing surface
   # @param ex [Bool] if exterior-facing surface
-  # @param tp [#to_s] a surface type
+  # @param tp [#to_sym] surface type: "floor", "wall" or "roofceiling"
   #
   # @return [Bool] whether default set holds construction
   # @return [false] if invalid input (see logs)
@@ -766,323 +1170,156 @@ module OSut
     id2 = bse.nameString
     ck1 = set.is_a?(cl1)
     ck2 = bse.is_a?(cl2)
-    ck3 = [true, false].include?(gr)
-    ck4 = [true, false].include?(ex)
-    ck5 = tp.respond_to?(:to_s)
-    return mismatch(id1, set, cl1, mth,    DBG, false) unless ck1
-    return mismatch(id2, bse, cl2, mth,    DBG, false) unless ck2
-    return invalid("ground"      , mth, 3, DBG, false) unless ck3
-    return invalid("exterior"    , mth, 4, DBG, false) unless ck4
-    return invalid("surface type", mth, 5, DBG, false) unless ck5
-
-    type = trim(tp).downcase
-    ck1  = ["floor", "wall", "roofceiling"].include?(type)
-    return invalid("surface type", mth, 5, DBG, false) unless ck1
-
-    constructions = nil
-
-    if gr
-      unless set.defaultGroundContactSurfaceConstructions.empty?
-        constructions = set.defaultGroundContactSurfaceConstructions.get
-      end
-    elsif ex
-      unless set.defaultExteriorSurfaceConstructions.empty?
-        constructions = set.defaultExteriorSurfaceConstructions.get
-      end
-    else
-      unless set.defaultInteriorSurfaceConstructions.empty?
-        constructions = set.defaultInteriorSurfaceConstructions.get
-      end
-    end
-
-    return false unless constructions
-
-    case type
-    when "roofceiling"
-      unless constructions.roofCeilingConstruction.empty?
-        construction = constructions.roofCeilingConstruction.get
-        return true if construction == bse
-      end
-    when "floor"
-      unless constructions.floorConstruction.empty?
-        construction = constructions.floorConstruction.get
-        return true if construction == bse
-      end
-    else
-      unless constructions.wallConstruction.empty?
-        construction = constructions.wallConstruction.get
-        return true if construction == bse
-      end
-    end
-
-    false
-  end
-
-  ##
-  # Returns a surface's default construction set.
-  #
-  # @param s [OpenStudio::Model::Surface] a surface
-  #
-  # @return [OpenStudio::Model::DefaultConstructionSet] default set
-  # @return [nil] if invalid input (see logs)
-  def defaultConstructionSet(s = nil)
-    mth = "OSut::#{__callee__}"
-    cl  = OpenStudio::Model::Surface
-    return invalid("surface", mth, 1) unless s.respond_to?(NS)
-
-    id = s.nameString
-    ok = s.isConstructionDefaulted
-    m1 = "#{id} construction not defaulted (#{mth})"
-    m2 = "#{id} construction"
-    m3 = "#{id} space"
-    return mismatch(id, s, cl, mth) unless s.is_a?(cl)
-
-    log(ERR, m1)           unless ok
-    return nil             unless ok
-    return empty(m2, mth, ERR) if s.construction.empty?
-    return empty(m3, mth, ERR) if s.space.empty?
-
-    mdl      = s.model
-    base     = s.construction.get
-    space    = s.space.get
-    type     = s.surfaceType
-    ground   = false
-    exterior = false
-
-    if s.isGroundSurface
-      ground = true
-    elsif s.outsideBoundaryCondition.downcase == "outdoors"
-      exterior = true
-    end
-
-    unless space.defaultConstructionSet.empty?
-      set = space.defaultConstructionSet.get
-      return set if holdsConstruction?(set, base, ground, exterior, type)
-    end
-
-    unless space.spaceType.empty?
-      spacetype = space.spaceType.get
-
-      unless spacetype.defaultConstructionSet.empty?
-        set = spacetype.defaultConstructionSet.get
-        return set if holdsConstruction?(set, base, ground, exterior, type)
-      end
-    end
-
-    unless space.buildingStory.empty?
-      story = space.buildingStory.get
-
-      unless story.defaultConstructionSet.empty?
-        set = story.defaultConstructionSet.get
-        return set if holdsConstruction?(set, base, ground, exterior, type)
-      end
-    end
-
-    building = mdl.getBuilding
-
-    unless building.defaultConstructionSet.empty?
-      set = building.defaultConstructionSet.get
-      return set if holdsConstruction?(set, base, ground, exterior, type)
-    end
-
-    nil
-  end
-
-  ##
-  # Validates if every material in a layered construction is standard & opaque.
-  #
-  # @param lc [OpenStudio::LayeredConstruction] a layered construction
-  #
-  # @return [Bool] whether all layers are valid
-  # @return [false] if invalid input (see logs)
-  def standardOpaqueLayers?(lc = nil)
-    mth = "OSut::#{__callee__}"
-    cl  = OpenStudio::Model::LayeredConstruction
-    return invalid("lc", mth, 1, DBG, false) unless lc.respond_to?(NS)
-    return mismatch(lc.nameString, lc, cl, mth, DBG, false) unless lc.is_a?(cl)
-
-    lc.layers.each { |m| return false if m.to_StandardOpaqueMaterial.empty? }
-
-    true
-  end
-
-  ##
-  # Returns total (standard opaque) layered construction thickness (m).
-  #
-  # @param lc [OpenStudio::LayeredConstruction] a layered construction
-  #
-  # @return [Float] construction thickness
-  # @return [0.0] if invalid input (see logs)
-  def thickness(lc = nil)
-    mth = "OSut::#{__callee__}"
-    cl  = OpenStudio::Model::LayeredConstruction
-    return invalid("lc", mth, 1, DBG, 0.0) unless lc.respond_to?(NS)
-
-    id = lc.nameString
-    return mismatch(id, lc, cl, mth, DBG, 0.0) unless lc.is_a?(cl)
-
-    ok = standardOpaqueLayers?(lc)
-    log(ERR, "'#{id}' holds non-StandardOpaqueMaterial(s) (#{mth})")  unless ok
-    return 0.0                                                        unless ok
-
-    thickness = 0.0
-    lc.layers.each { |m| thickness += m.thickness }
-
-    thickness
-  end
-
-  ##
-  # Returns total air film resistance of a fenestrated construction (m2•K/W)
-  #
-  # @param usi [Numeric] a fenestrated construction's U-factor (W/m2•K)
-  #
-  # @return [Float] total air film resistances
-  # @return [0.1216] if invalid input (see logs)
-  def glazingAirFilmRSi(usi = 5.85)
-    # The sum of thermal resistances of calculated exterior and interior film
-    # coefficients under standard winter conditions are taken from:
-    #
-    #   https://bigladdersoftware.com/epx/docs/9-6/engineering-reference/
-    #   window-calculation-module.html#simple-window-model
-    #
-    # These remain acceptable approximations for flat windows, yet likely
-    # unsuitable for subsurfaces with curved or projecting shapes like domed
-    # skylights. The solution here is considered an adequate fix for reporting,
-    # awaiting eventual OpenStudio (and EnergyPlus) upgrades to report NFRC 100
-    # (or ISO) air film resistances under standard winter conditions.
-    #
-    # For U-factors above 8.0 W/m2•K (or invalid input), the function returns
-    # 0.1216 m2•K/W, which corresponds to a construction with a single glass
-    # layer thickness of 2mm & k = ~0.6 W/m.K.
-    #
-    # The EnergyPlus Engineering calculations were designed for vertical
-    # windows - not horizontal, slanted or domed surfaces - use with caution.
-    mth = "OSut::#{__callee__}"
-    cl  = Numeric
-    return mismatch("usi", usi, cl, mth,    DBG, 0.1216)  unless usi.is_a?(cl)
-    return invalid("usi",           mth, 1, WRN, 0.1216)      if usi > 8.0
-    return negative("usi",          mth,    WRN, 0.1216)      if usi < 0
-    return zero("usi",              mth,    WRN, 0.1216)      if usi.abs < TOL
-
-    rsi = 1 / (0.025342 * usi + 29.163853) # exterior film, next interior film
-    return rsi + 1 / (0.359073 * Math.log(usi) + 6.949915) if usi < 5.85
-    return rsi + 1 / (1.788041 * usi - 2.886625)
-  end
-
-  ##
-  # Returns a construction's 'standard calc' thermal resistance (m2•K/W), which
-  # includes air film resistances. It excludes insulating effects of shades,
-  # screens, etc. in the case of fenestrated constructions.
-  #
-  # @param lc [OpenStudio::Model::LayeredConstruction] a layered construction
-  # @param film [Numeric] thermal resistance of surface air films (m2•K/W)
-  # @param t [Numeric] gas temperature (°C) (optional)
-  #
-  # @return [Float] layered construction's thermal resistance
-  # @return [0.0] if invalid input (see logs)
-  def rsi(lc = nil, film = 0.0, t = 0.0)
-    # This is adapted from BTAP's Material Module "get_conductance" (P. Lopez)
-    #
-    #   https://github.com/NREL/OpenStudio-Prototype-Buildings/blob/
-    #   c3d5021d8b7aef43e560544699fb5c559e6b721d/lib/btap/measures/
-    #   btap_equest_converter/envelope.rb#L122
-    mth = "OSut::#{__callee__}"
-    cl1 = OpenStudio::Model::LayeredConstruction
-    cl2 = Numeric
-    return invalid("lc", mth, 1, DBG, 0.0) unless lc.respond_to?(NS)
-
-    id = lc.nameString
-    return mismatch(id,       lc, cl1, mth, DBG, 0.0) unless lc.is_a?(cl1)
-    return mismatch("film", film, cl2, mth, DBG, 0.0) unless film.is_a?(cl2)
-    return mismatch("temp K",  t, cl2, mth, DBG, 0.0) unless t.is_a?(cl2)
+    ck3 = [true, false].include?(gr)
+    ck4 = [true, false].include?(ex)
+    ck5 = tp.respond_to?(:to_sym)
+    return mismatch(id1, set, cl1, mth,    DBG, false) unless ck1
+    return mismatch(id2, bse, cl2, mth,    DBG, false) unless ck2
+    return invalid("ground"      , mth, 3, DBG, false) unless ck3
+    return invalid("exterior"    , mth, 4, DBG, false) unless ck4
+    return invalid("surface type", mth, 5, DBG, false) unless ck5
 
-    t += 273.0 # °C to K
-    return negative("temp K", mth, ERR, 0.0) if t < 0
-    return negative("film",   mth, ERR, 0.0) if film < 0
+    type = trim(tp).downcase
+    ck1  = ["floor", "wall", "roofceiling"].include?(type)
+    return invalid("surface type", mth, 5, DBG, false) unless ck1
 
-    rsi = film
+    constructions = nil
 
-    lc.layers.each do |m|
-      # Fenestration materials first.
-      empty = m.to_SimpleGlazing.empty?
-      return 1 / m.to_SimpleGlazing.get.uFactor                     unless empty
+    if gr
+      unless set.defaultGroundContactSurfaceConstructions.empty?
+        constructions = set.defaultGroundContactSurfaceConstructions.get
+      end
+    elsif ex
+      unless set.defaultExteriorSurfaceConstructions.empty?
+        constructions = set.defaultExteriorSurfaceConstructions.get
+      end
+    else
+      unless set.defaultInteriorSurfaceConstructions.empty?
+        constructions = set.defaultInteriorSurfaceConstructions.get
+      end
+    end
 
-      empty = m.to_StandardGlazing.empty?
-      rsi += m.to_StandardGlazing.get.thermalResistance             unless empty
-      empty = m.to_RefractionExtinctionGlazing.empty?
-      rsi += m.to_RefractionExtinctionGlazing.get.thermalResistance unless empty
-      empty = m.to_Gas.empty?
-      rsi += m.to_Gas.get.getThermalResistance(t)                   unless empty
-      empty = m.to_GasMixture.empty?
-      rsi += m.to_GasMixture.get.getThermalResistance(t)            unless empty
+    return false unless constructions
 
-      # Opaque materials next.
-      empty = m.to_StandardOpaqueMaterial.empty?
-      rsi += m.to_StandardOpaqueMaterial.get.thermalResistance      unless empty
-      empty = m.to_MasslessOpaqueMaterial.empty?
-      rsi += m.to_MasslessOpaqueMaterial.get.thermalResistance      unless empty
-      empty = m.to_RoofVegetation.empty?
-      rsi += m.to_RoofVegetation.get.thermalResistance              unless empty
-      empty = m.to_AirGap.empty?
-      rsi += m.to_AirGap.get.thermalResistance                      unless empty
+    case type
+    when "roofceiling"
+      unless constructions.roofCeilingConstruction.empty?
+        construction = constructions.roofCeilingConstruction.get
+        return true if construction == bse
+      end
+    when "floor"
+      unless constructions.floorConstruction.empty?
+        construction = constructions.floorConstruction.get
+        return true if construction == bse
+      end
+    else
+      unless constructions.wallConstruction.empty?
+        construction = constructions.wallConstruction.get
+        return true if construction == bse
+      end
     end
 
-    rsi
+    false
   end
 
   ##
-  # Identifies a layered construction's (opaque) insulating layer. The method
-  # returns a 3-keyed hash :index, the insulating layer index [0, n layers)
-  # within the layered construction; :type, either :standard or :massless; and
-  # :r, material thermal resistance in m2•K/W.
+  # Returns a surface's default construction set.
   #
-  # @param lc [OpenStudio::Model::LayeredConstruction] a layered construction
+  # @param s [OpenStudio::Model::Surface] a surface
   #
-  # @return [Hash] index: (Integer), type: (Symbol), r: (Float)
-  # @return [Hash] index: nil, type: nil, r: 0 if invalid input (see logs)
-  def insulatingLayer(lc = nil)
+  # @return [OpenStudio::Model::DefaultConstructionSet] default set
+  # @return [nil] if invalid input (see logs)
+  def defaultConstructionSet(s = nil)
     mth = "OSut::#{__callee__}"
-    cl  = OpenStudio::Model::LayeredConstruction
-    res = { index: nil, type: nil, r: 0.0 }
-    i   = 0  # iterator
-    return invalid("lc", mth, 1, DBG, res) unless lc.respond_to?(NS)
+    cl  = OpenStudio::Model::Surface
+    return invalid("surface", mth, 1) unless s.respond_to?(NS)
 
-    id   = lc.nameString
-    return mismatch(id, lc, cl1, mth, DBG, res) unless lc.is_a?(cl)
+    id = s.nameString
+    ok = s.isConstructionDefaulted
+    m1 = "#{id} construction not defaulted (#{mth})"
+    m2 = "#{id} construction"
+    m3 = "#{id} space"
+    return mismatch(id, s, cl, mth) unless s.is_a?(cl)
 
-    lc.layers.each do |m|
-      unless m.to_MasslessOpaqueMaterial.empty?
-        m             = m.to_MasslessOpaqueMaterial.get
+    log(ERR, m1)           unless ok
+    return nil             unless ok
+    return empty(m2, mth, ERR) if s.construction.empty?
+    return empty(m3, mth, ERR) if s.space.empty?
 
-        if m.thermalResistance < 0.001 || m.thermalResistance < res[:r]
-          i += 1
-          next
-        else
-          res[:r    ] = m.thermalResistance
-          res[:index] = i
-          res[:type ] = :massless
+    mdl      = s.model
+    base     = s.construction.get
+    space    = s.space.get
+    type     = s.surfaceType
+    ground   = false
+    exterior = false
+    adjacent = s.adjacentSurface.empty? ? nil : s.adjacentSurface.get
+    aspace   = adjacent.nil? || adjacent.space.empty? ? nil : adjacent.space.get
+    typ      = adjacent.nil? ? nil : adjacent.surfaceType
+
+    if s.isGroundSurface
+      ground = true
+    elsif s.outsideBoundaryCondition.downcase == "outdoors"
+      exterior = true
+    end
+
+    if space.defaultConstructionSet.empty?
+      unless aspace.nil?
+        unless aspace.defaultConstructionSet.empty?
+          set = aspace.defaultConstructionSet.get
+          return set if holdsConstruction?(set, base, ground, exterior, typ)
         end
       end
+    else
+      set = space.defaultConstructionSet.get
+      return set if holdsConstruction?(set, base, ground, exterior, type)
+    end
 
-      unless m.to_StandardOpaqueMaterial.empty?
-        m             = m.to_StandardOpaqueMaterial.get
-        k             = m.thermalConductivity
-        d             = m.thickness
+    unless space.spaceType.empty?
+      spacetype = space.spaceType.get
 
-        if d < 0.003 || k > 3.0 || d / k < res[:r]
-          i += 1
-          next
-        else
-          res[:r    ] = d / k
-          res[:index] = i
-          res[:type ] = :standard
+      unless spacetype.defaultConstructionSet.empty?
+        set = spacetype.defaultConstructionSet.get
+        return set if holdsConstruction?(set, base, ground, exterior, type)
+      end
+    end
+
+    unless aspace.nil? || aspace.spaceType.empty?
+      unless aspace.spaceType.empty?
+        spacetype = aspace.spaceType.get
+
+        unless spacetype.defaultConstructionSet.empty?
+          set = spacetype.defaultConstructionSet.get
+          return set if holdsConstruction?(set, base, ground, exterior, typ)
         end
       end
+    end
 
-      i += 1
+    unless space.buildingStory.empty?
+      story = space.buildingStory.get
+
+      unless story.defaultConstructionSet.empty?
+        set = story.defaultConstructionSet.get
+        return set if holdsConstruction?(set, base, ground, exterior, type)
+      end
     end
 
-    res
+    unless aspace.nil? || aspace.buildingStory.empty?
+      story = aspace.buildingStory.get
+
+      unless spacetype.defaultConstructionSet.empty?
+        set = spacetype.defaultConstructionSet.get
+        return set if holdsConstruction?(set, base, ground, exterior, typ)
+      end
+    end
+
+    building = mdl.getBuilding
+
+    unless building.defaultConstructionSet.empty?
+      set = building.defaultConstructionSet.get
+      return set if holdsConstruction?(set, base, ground, exterior, type)
+    end
+
+    nil
   end
 
   ##
@@ -1102,7 +1339,7 @@ module OSut
     id = s.nameString
     m1  = "#{id}:spandrel"
     m2  = "#{id}:spandrel:boolean"
-    return mismatch(id, s, cl, mth) unless s.is_a?(cl)
+    return mismatch(id, s, cl, mth, false) unless s.is_a?(cl)
 
     if s.additionalProperties.hasFeature("spandrel")
       val = s.additionalProperties.getFeatureAsBoolean("spandrel")
@@ -1129,7 +1366,7 @@ module OSut
     return invalid("subsurface", mth, 1, DBG, false) unless s.respond_to?(NS)
 
     id = s.nameString
-    return mismatch(id, s, cl, mth, false) unless s.is_a?(cl)
+    return mismatch(id, s, cl, mth, DBG, false) unless s.is_a?(cl)
 
     # OpenStudio::Model::SubSurface.validSubSurfaceTypeValues
     # "FixedWindow"              : fenestration
@@ -1422,7 +1659,15 @@ module OSut
     id = sched.nameString
     return mismatch(id, sched, cl, mth, DBG, res) unless sched.is_a?(cl)
 
-    vals = sched.timeSeries.values
+    values = sched.timeSeries.values
+
+    values.each do |value|
+      if value.respond_to?(:to_f)
+        vals << value.to_f
+      else
+        invalid("numerical at #{i}", mth, 1, ERR)
+      end
+    end
 
     res[:min] = vals.min.is_a?(Numeric) ? vals.min : nil
     res[:max] = vals.max.is_a?(Numeric) ? vals.min : nil
@@ -1529,6 +1774,16 @@ module OSut
           res[:spt] = max     if res[:spt] < max
         end
       end
+
+      unless sched.to_ScheduleInterval.empty?
+        sched = sched.to_ScheduleInterval.get
+        max = scheduleIntervalMinMax(sched)[:max]
+
+        if max
+          res[:spt] = max unless res[:spt]
+          res[:spt] = max     if res[:spt] < max
+        end
+      end
     end
 
     return res if zone.thermostat.empty?
@@ -1586,6 +1841,16 @@ module OSut
           end
         end
 
+        unless sched.to_ScheduleInterval.empty?
+          sched = sched.to_ScheduleInterval.get
+          max = scheduleIntervalMinMax(sched)[:max]
+
+          if max
+            res[:spt] = max unless res[:spt]
+            res[:spt] = max     if res[:spt] < max
+          end
+        end
+
         unless sched.to_ScheduleYear.empty?
           sched = sched.to_ScheduleYear.get
 
@@ -1707,6 +1972,16 @@ module OSut
           res[:spt] = min     if res[:spt] > min
         end
       end
+
+      unless sched.to_ScheduleInterval.empty?
+        sched = sched.to_ScheduleInterval.get
+        min = scheduleIntervalMinMax(sched)[:min]
+
+        if min
+          res[:spt] = min unless res[:spt]
+          res[:spt] = min     if res[:spt] > min
+        end
+      end
     end
 
     return res if zone.thermostat.empty?
@@ -1764,6 +2039,16 @@ module OSut
           end
         end
 
+        unless sched.to_ScheduleInterval.empty?
+          sched = sched.to_ScheduleInerval.get
+          min = scheduleIntervalMinMax(sched)[:min]
+
+          if min
+            res[:spt] = min unless res[:spt]
+            res[:spt] = min     if res[:spt] > min
+          end
+        end
+
         unless sched.to_ScheduleYear.empty?
           sched = sched.to_ScheduleYear.get
 
@@ -2157,7 +2442,7 @@ module OSut
     cl     = OpenStudio::Model::Model
     limits = nil
     return mismatch("model",     model, cl, mth) unless model.is_a?(cl)
-    return invalid("availability", avl,  2, mth) unless avl.respond_to?(:to_s)
+    return invalid("availability", avl,  2, mth) unless avl.respond_to?(:to_sym)
 
     # Either fetch availability ScheduleTypeLimits object, or create one.
     model.getScheduleTypeLimitss.each do |l|
@@ -2351,7 +2636,7 @@ module OSut
   # @return [OpenStudio::Vector3d] true normal vector
   # @return [nil] if invalid input (see logs)
   def trueNormal(s = nil, r = 0)
-    mth = "TBD::#{__callee__}"
+    mth = "OSut::#{__callee__}"
     cl  = OpenStudio::Model::PlanarSurface
     return mismatch("surface", s, cl, mth)   unless s.is_a?(cl)
     return invalid("rotation angle", mth, 2) unless r.respond_to?(:to_f)
@@ -2384,31 +2669,31 @@ module OSut
 
   ##
   # Returns OpenStudio 3D points as an OpenStudio point vector, validating
-  # points in the process (if Array).
+  # points in the process (e.g. if Array).
   #
   # @param pts [Set<OpenStudio::Point3d>] OpenStudio 3D points
   #
   # @return [OpenStudio::Point3dVector] 3D vector (see logs if empty)
   def to_p3Dv(pts = nil)
     mth = "OSut::#{__callee__}"
-    cl1 = OpenStudio::Point3d
-    cl2 = OpenStudio::Point3dVector
-    cl3 = OpenStudio::Model::PlanarSurface
-    cl4 = Array
     v   = OpenStudio::Point3dVector.new
 
-    if pts.is_a?(cl1)
+    if pts.is_a?(OpenStudio::Point3d)
       v << pts
       return v
+    elsif pts.is_a?(OpenStudio::Point3dVector)
+      return pts
+    elsif pts.is_a?(OpenStudio::Model::PlanarSurface)
+      pts.vertices.each { |pt| v << OpenStudio::Point3d.new(pt.x, pt.y, pt.z) }
+      return v
     end
 
-    return pts if pts.is_a?(cl2)
-    return pts.vertices if pts.is_a?(cl3)
-
-    return mismatch("points", pts, cl1, mth, DBG, v) unless pts.is_a?(cl4)
+    return mismatch("points", pts, Array, mth, DBG, v) unless pts.is_a?(Array)
 
     pts.each do |pt|
-      return mismatch("point", pt, cl4, mth, DBG, v) unless pt.is_a?(cl1)
+      unless pt.is_a?(OpenStudio::Point3d)
+        return mismatch("point", pt, OpenStudio::Point3d, mth, DBG, v)
+      end
     end
 
     pts.each { |pt| v << OpenStudio::Point3d.new(pt.x, pt.y, pt.z) }
@@ -2684,7 +2969,7 @@ module OSut
 
     pair = pts.each_cons(2).find { |p1, _| same?(p1, pt) }
 
-    pair.nil? ? pts.first : pair.last
+    pair.nil? ? pts[0] : pair[-1]
   end
 
   ##
@@ -2775,21 +3060,25 @@ module OSut
   # @param pts [Set<OpenStudio::Point3d] 3D points
   # @param n [#to_i] requested number of unique points (0 returns all)
   #
-  # @return [OpenStudio::Point3dVector] unique points (see logs if empty)
-  def getUniques(pts = nil, n = 0)
+  # @return [OpenStudio::Point3dVector] unique points (see logs)
+  def uniques(pts = nil, n = 0)
     mth = "OSut::#{__callee__}"
     pts = to_p3Dv(pts)
-    ok  = n.respond_to?(:to_i)
     v   = OpenStudio::Point3dVector.new
     return v if pts.empty?
-    return mismatch("n unique points", n, Integer, mth, DBG, v) unless ok
+
+    if n.is_a?(Numeric)
+      n = n.to_i
+    else
+      mismatch("n points", n, Integer, mth, DBG)
+      n = 0
+    end
 
     pts.each { |pt| v << pt unless holds?(v, pt) }
 
-    n = n.to_i
-    n = 0    unless n.abs < v.size
-    v = v[0..n]  if n > 0
-    v = v[n..-1] if n < 0
+    n = 0         if n.abs > v.size
+    v = v[0..n-1] if n > 0
+    v = v[n..-1]  if n < 0
 
     v
   end
@@ -2803,10 +3092,10 @@ module OSut
   # @param pts [Set<OpenStudio::Point3d>] 3D points
   #
   # @return [OpenStudio::Point3dVectorVector] line segments (see logs if empty)
-  def getSegments(pts = nil)
+  def segments(pts = nil)
     mth = "OSut::#{__callee__}"
     vv  = OpenStudio::Point3dVectorVector.new
-    pts = getUniques(pts)
+    pts = uniques(pts)
     return vv if pts.size < 2
 
     pts.each_with_index do |p1, i1|
@@ -2833,7 +3122,6 @@ module OSut
   # @return [false] if invalid input (see logs)
   def segment?(pts = nil)
     pts = to_p3Dv(pts)
-    return false     if pts.empty?
     return false unless pts.size == 2
     return false     if same?(pts[0], pts[1])
 
@@ -2850,10 +3138,10 @@ module OSut
   # @param pts [OpenStudio::Point3dVector] 3D points
   #
   # @return [OpenStudio::Point3dVectorVector] triads (see logs if empty)
-  def getTriads(pts = nil, co = false)
+  def triads(pts = nil, co = false)
     mth = "OSut::#{__callee__}"
     vv  = OpenStudio::Point3dVectorVector.new
-    pts = getUniques(pts)
+    pts = uniques(pts)
     return vv if pts.size < 2
 
     pts.each_with_index do |p1, i1|
@@ -2880,7 +3168,7 @@ module OSut
   # @param pts [Set<OpenStudio::Point3d>] 3D points
   #
   # @return [Bool] whether set is a valid triad (i.e. a trio of 3D points)
-  # @return [false] if invalid input (see logs)
+  # @return [false] if invalid input (see 'to_p3Dv' logs)
   def triad?(pts = nil)
     pts = to_p3Dv(pts)
     return false     if pts.empty?
@@ -2905,18 +3193,17 @@ module OSut
     mth = "OSut::#{__callee__}"
     cl1 = OpenStudio::Point3d
     cl2 = OpenStudio::Point3dVector
-    return mismatch(  "point", p0, cl1, mth, DBG, false) unless p0.is_a?(cl1)
-    return mismatch("segment", sg, cl2, mth, DBG, false) unless segment?(sg)
-
+    return mismatch("point", p0, cl1, mth, DBG, false) unless p0.is_a?(cl1)
+    return false unless segment?(sg)
     return true if holds?(sg, p0)
 
-    a   = sg.first
-    b   = sg.last
+    a   = sg[ 0]
+    b   = sg[-1]
     ab  = b - a
     abn = b - a
     abn.normalize
     ap  = p0 - a
-    sp = ap.dot(abn)
+    sp  = ap.dot(abn)
     return false if sp < 0
 
     apd = scalar(abn, sp)
@@ -2941,9 +3228,9 @@ module OSut
     mth = "OSut::#{__callee__}"
     cl1 = OpenStudio::Point3d
     cl2 = OpenStudio::Point3dVectorVector
-    sgs = sgs.is_a?(cl2) ? sgs : getSegments(sgs)
-    return empty("segments",         mth, DBG, false)     if sgs.empty?
-    return mismatch("point", p0, cl, mth, DBG, false) unless p0.is_a?(cl1)
+    sgs = sgs.is_a?(cl2) ? sgs : segments(sgs)
+    return empty("segments",          mth, DBG, false)     if sgs.empty?
+    return mismatch("point", p0, cl1, mth, DBG, false) unless p0.is_a?(cl1)
 
     sgs.each { |sg| return true if pointAlongSegment?(p0, sg) }
 
@@ -2958,9 +3245,9 @@ module OSut
   #
   # @return [OpenStudio::Point3d] point of intersection of both lines
   # @return [nil] if no intersection, equal, or invalid input (see logs)
-  def getLineIntersection(s1 = [], s2 = [])
-    s1  = getSegments(s1)
-    s2  = getSegments(s2)
+  def lineIntersection(s1 = [], s2 = [])
+    s1 = segments(s1)
+    s2 = segments(s2)
     return nil if s1.empty?
     return nil if s2.empty?
 
@@ -2971,10 +3258,10 @@ module OSut
     return nil if same?(s1, s2)
     return nil if same?(s1, s2.to_a.reverse)
 
-    a1 = s1[0]
-    a2 = s1[1]
-    b1 = s2[0]
-    b2 = s2[1]
+    a1 = s1.first
+    b1 = s2.first
+    a2 = s1.last
+    b2 = s2.last
 
     # Matching segment endpoints?
     return a1 if same?(a1, b1)
@@ -2983,18 +3270,18 @@ module OSut
     return a2 if same?(a2, b2)
 
     # Segment endpoint along opposite segment?
-    return a1 if pointAlongSegments?(a1, s2)
-    return a2 if pointAlongSegments?(a2, s2)
-    return b1 if pointAlongSegments?(b1, s1)
-    return b2 if pointAlongSegments?(b2, s1)
+    return a1 if pointAlongSegment?(a1, s2)
+    return a2 if pointAlongSegment?(a2, s2)
+    return b1 if pointAlongSegment?(b1, s1)
+    return b2 if pointAlongSegment?(b2, s1)
 
-    # Line segments as vectors. Skip if colinear.
+    # Line segments as vectors. Skip if collinear or parallel.
     a   = a2 - a1
     b   = b2 - b1
     xab = a.cross(b)
     return nil if xab.length.round(4) < TOL2
 
-    # Link 1st point to other segment endpoints as vectors. Must be coplanar.
+    # Link 1st point to other segment endpoints, as vectors. Must be coplanar.
     a1b1  = b1 - a1
     a1b2  = b2 - a1
     xa1b1 = a.cross(a1b1)
@@ -3035,7 +3322,7 @@ module OSut
     return nil if a.dot(p0 - a1) < 0
 
     # Ensure intersection is sandwiched between endpoints.
-    return nil unless pointAlongSegments?(p0, s2) && pointAlongSegments?(p0, s1)
+    return nil unless pointAlongSegment?(p0, s2) && pointAlongSegment?(p0, s1)
 
     p0
   end
@@ -3049,14 +3336,14 @@ module OSut
   # @return [Bool] whether 3D line intersects 3D segments
   # @return [false] if invalid input (see logs)
   def lineIntersects?(l = [], s = [])
-    l   = getSegments(l)
-    s   = getSegments(s)
+    l = segments(l)
+    s = segments(s)
     return nil if l.empty?
     return nil if s.empty?
 
     l = l.first
 
-    s.each { |segment| return true if getLineIntersection(l, segment) }
+    s.each { |segment| return true if lineIntersection(l, segment) }
 
     false
   end
@@ -3142,28 +3429,33 @@ module OSut
   end
 
   ##
-  # Returns sequential non-collinear points in an OpenStudio 3D point vector.
+  # Returns non-collinear points in an OpenStudio 3D point vector.
   #
   # @param pts [Set<OpenStudio::Point3d] 3D points
   # @param n [#to_i] requested number of non-collinears (0 returns all)
   #
-  # @return [OpenStudio::Point3dVector] non-collinears (see logs if empty)
-  def getNonCollinears(pts = nil, n = 0)
+  # @return [OpenStudio::Point3dVector] non-collinears (see logs)
+  def nonCollinears(pts = nil, n = 0)
     mth = "OSut::#{__callee__}"
-    pts = getUniques(pts)
-    ok  = n.respond_to?(:to_i)
-    v   = OpenStudio::Point3dVector.new
     a   = []
+    pts = uniques(pts)
     return pts if pts.size < 3
-    return mismatch("n non-collinears", n, Integer, mth, DBG, v) unless ok
+
+    if n.is_a?(Numeric)
+      n = n.to_i
+    else
+      mismatch("n points", n, Integer, mth, DBG)
+      n = 0
+    end
 
     # Evaluate cross product of vectors of 3x sequential points.
     pts.each_with_index do |p2, i2|
-      i1  = i2 - 1
-      i3  = i2 + 1
-      i3  = 0 if i3 == pts.size
-      p1  = pts[i1]
-      p3  = pts[i3]
+      i1 = i2 - 1
+      i3 = i2 + 1
+      i3 = 0 if i3 == pts.size
+      p1 = pts[i1]
+      p3 = pts[i3]
+
       v13 = p3 - p1
       v12 = p2 - p1
       next if v12.cross(v13).length < TOL2
@@ -3171,36 +3463,47 @@ module OSut
       a << p2
     end
 
-    if holds?(a, pts[0])
+    if a.include?(pts[0])
       a = a.rotate(-1) unless same?(a[0], pts[0])
     end
 
-    n = n.to_i
-    a = a[0..n-1]  if n > 0
-    a = a[n-1..-1] if n < 0
+    n = 0         if n.abs > a.size
+    a = a[0..n-1] if n > 0
+    a = a[n..-1]  if n < 0
 
     to_p3Dv(a)
   end
 
   ##
-  # Returns sequential collinear points in an OpenStudio 3D point vector.
+  # Returns collinear points in an OpenStudio 3D point vector.
   #
   # @param pts [Set<OpenStudio::Point3d] 3D points
   # @param n [#to_i] requested number of collinears (0 returns all)
   #
-  # @return [OpenStudio::Point3dVector] collinears (see logs if empty)
-  def getCollinears(pts = nil, n = 0)
+  # @return [OpenStudio::Point3dVector] collinears (see logs)
+  def collinears(pts = nil, n = 0)
     mth = "OSut::#{__callee__}"
-    pts = getUniques(pts)
-    ok  = n.respond_to?(:to_i)
-    v   = OpenStudio::Point3dVector.new
+    a   = OpenStudio::Point3dVector.new
+    pts = uniques(pts)
     return pts if pts.size < 3
-    return mismatch("n collinears", n, Integer, mth, DBG, v) unless ok
 
-    ncolls = getNonCollinears(pts)
-    return pts if ncolls.empty?
+    if n.is_a?(Numeric)
+      n = n.to_i
+    else
+      mismatch("n points", n, Integer, mth, DBG, pts)
+      n = 0
+    end
+
+    ncolls = nonCollinears(pts)
+    return a if ncolls.empty?
 
-    to_p3Dv( pts.delete_if { |pt| holds?(ncolls, pt) } )
+    a = pts.delete_if { |pt| holds?(ncolls, pt) }
+
+    n = 0         if n.abs > a.size
+    a = a[0..n-1] if n > 0
+    a = a[n..-1]  if n < 0
+
+    a
   end
 
   ##
@@ -3237,7 +3540,7 @@ module OSut
 
     # --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- #
     # Minimum 3 points?
-    p3 = getNonCollinears(pts, 3)
+    p3 = nonCollinears(pts, 3)
     return empty("polygon (non-collinears < 3)", mth, ERR, v) if p3.size < 3
 
     # Coplanar?
@@ -3268,8 +3571,8 @@ module OSut
     # --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- #
     # Ensure uniqueness and/or non-collinearity. Preserve original sequence.
     p0 = a.first
-    a  = getUniques(a).to_a       if uq
-    a  = getNonCollinears(a).to_a if co
+    a  = uniques(a).to_a       if uq
+    a  = nonCollinears(a).to_a if co
     i0 = a.index { |pt| same?(pt, p0) }
     a  = a.rotate(i0)             unless i0.nil?
 
@@ -3278,7 +3581,7 @@ module OSut
     if vx && a.size > 3
       zen = OpenStudio::Point3d.new(0, 0, 1000)
 
-      getTriads(a).each do |trio|
+      triads(a).each do |trio|
         p1  = trio[0]
         p2  = trio[1]
         p3  = trio[2]
@@ -3344,31 +3647,31 @@ module OSut
     return false unless pl.pointOnPlane(p0)
 
     entirely = false unless [true, false].include?(entirely)
-    segments = getSegments(s)
+    sgments  = segments(s)
 
     # Along polygon edges, or near vertices?
-    if pointAlongSegments?(p0, segments)
+    if pointAlongSegments?(p0, sgments)
       return false    if entirely
       return true unless entirely
     end
 
-    segments.each do |segment|
+    sgments.each do |sgment|
       #   - draw vector from segment midpoint to point
       #   - scale 1000x (assuming no building surface would be 1km wide)
       #   - convert vector to an independent line segment
       #   - loop through polygon segments, tally the number of intersections
       #   - avoid double-counting polygon vertices as intersections
       #   - return false if number of intersections is even
-      mid = midpoint(segment.first, segment.last)
+      mid = midpoint(sgment.first, sgment.last)
       mpV = scalar(mid - p0, 1000)
       p1  = p0 + mpV
       ctr = 0
 
       # Skip if ~collinear.
-      next if mpV.cross(segment.last - segment.first).length.round(4) < TOL2
+      next if mpV.cross(sgment.last - sgment.first).length.round(4) < TOL2
 
-      segments.each do |sg|
-        intersect = getLineIntersection([p0, p1], sg)
+      sgments.each do |sg|
+        intersect = lineIntersection([p0, p1], sg)
         next unless intersect
 
         # Skip test altogether if one of the polygon vertices.
@@ -3518,7 +3821,7 @@ module OSut
     return false if pts.empty?
     return false unless rectangular?(pts)
 
-    getSegments(pts).each do |pt|
+    segments(pts).each do |pt|
       l = (pt[1] - pt[0]).length
       d = l unless d
       return false unless l.round(2) == d.round(2)
@@ -3552,7 +3855,7 @@ module OSut
     p2.each { |p0| return false if pointWithinPolygon?(p0, p1, true) }
 
     # p1 segment mid-points must not lie OUTSIDE of p2.
-    getSegments(p1).each do |sg|
+    segments(p1).each do |sg|
       mp = midpoint(sg.first, sg.last)
       return false unless pointWithinPolygon?(mp, p2)
     end
@@ -3595,22 +3898,17 @@ module OSut
       cw1 = clockwise?(p01)
       a1  = cw1 ? p01.to_a.reverse : p01.to_a
       a2  = p02.to_a
-      a2  = flatten(a2).to_a if flat
-      return invalid("points 2", mth, 2, DBG, face) unless xyz?(a2, :z)
-
-      cw2 = clockwise?(a2)
-      a2  = a2.reverse if cw2
     else
       t   = OpenStudio::Transformation.alignFace(p01)
       a1  = t.inverse * p01
       a2  = t.inverse * p02
-      a2  = flatten(a2).to_a if flat
-      return invalid("points 2", mth, 2, DBG, face) unless xyz?(a2, :z)
-
-      cw2 = clockwise?(a2)
-      a2  = a2.reverse if cw2
     end
 
+    a2  = flatten(a2).to_a if flat
+    cw2 = clockwise?(a2)
+    a2  = a2.reverse if cw2
+    return invalid("points 2", mth, 2, DBG, face) unless xyz?(a2, :z)
+
     # Return either (transformed) polygon if one fits into the other.
     p1t = p01
 
@@ -3690,7 +3988,7 @@ module OSut
     p2   = poly(p2)
     return face if p1.empty?
     return face if p2.empty?
-    return mismatch("ray", ray, cl, mth) unless ray.is_a?(cl)
+    return mismatch("ray", ray, cl, mth, face) unless ray.is_a?(cl)
 
     # From OpenStudio SDK v3.7.0 onwards, one could/should rely on:
     #
@@ -4023,12 +4321,12 @@ module OSut
   #
   # @param [Set<OpenStudio::Point3d>] a triad (3D points)
   #
-  # @return [Set<OpenStudio::Point3D>] a rectangular ULC box (see logs if empty)
+  # @return [Set<OpenStudio::Point3D>] a rectangular BLC box (see logs if empty)
   def triadBox(pts = nil)
     mth = "OSut::#{__callee__}"
     bkp = OpenStudio::Point3dVector.new
     box = []
-    pts = getNonCollinears(pts)
+    pts = nonCollinears(pts)
     return bkp if pts.empty?
 
     t   = xyz?(pts, :z) ? nil : OpenStudio::Transformation.alignFace(pts)
@@ -4065,7 +4363,7 @@ module OSut
     box << OpenStudio::Point3d.new(p1.x, p1.y, p1.z)
     box << OpenStudio::Point3d.new(p2.x, p2.y, p2.z)
     box << OpenStudio::Point3d.new(p3.x, p3.y, p3.z)
-    box = getNonCollinears(box, 4)
+    box = nonCollinears(box, 4)
     return bkp unless box.size == 4
 
     box = blc(box)
@@ -4098,7 +4396,7 @@ module OSut
 
     # Generate vertical plane along longest segment.
     mpoints = []
-    sgs     = getSegments(pts)
+    sgs     = segments(pts)
     longest = sgs.max_by { |s| OpenStudio.getDistanceSquared(s.first, s.last) }
     plane   = verticalPlane(longest.first, longest.last)
 
@@ -4112,7 +4410,7 @@ module OSut
     box << mpoints.first
     box << mpoints.last
     box << plane.project(mpoints.last)
-    box = getNonCollinears(box).to_a
+    box = nonCollinears(box).to_a
     return bkp unless box.size == 4
 
     box = clockwise?(box) ? blc(box.reverse) : blc(box)
@@ -4165,16 +4463,16 @@ module OSut
     aire = 0
 
     # PATH C : Right-angle, midpoint triad approach.
-    getSegments(pts).each do |sg|
+    segments(pts).each do |sg|
       m0 = midpoint(sg.first, sg.last)
 
-      getSegments(pts).each do |seg|
+      segments(pts).each do |seg|
         p1 = seg.first
         p2 = seg.last
         next if same?(p1, sg.first)
         next if same?(p1, sg.last)
         next if same?(p2, sg.first)
-        next if same?(p2, sg.first)
+        next if same?(p2, sg.last)
 
         out = triadBox(OpenStudio::Point3dVector.new([m0, p1, p2]))
         next if out.empty?
@@ -4194,7 +4492,7 @@ module OSut
     end
 
     # PATH D : Right-angle triad approach, may override PATH C boxes.
-    getSegments(pts).each do |sg|
+    segments(pts).each do |sg|
       p0 = sg.first
       p1 = sg.last
 
@@ -4227,7 +4525,7 @@ module OSut
     # PATH E : Medial box, segment approach.
     aire = 0
 
-    getSegments(pts).each do |sg|
+    segments(pts).each do |sg|
       p0 = sg.first
       p1 = sg.last
 
@@ -4260,7 +4558,7 @@ module OSut
     # PATH F : Medial box, triad approach.
     aire = 0
 
-    getTriads(pts).each do |sg|
+    triads(pts).each do |sg|
       p0 = sg[0]
       p1 = sg[1]
       p2 = sg[2]
@@ -4292,7 +4590,7 @@ module OSut
     holes = OpenStudio::Point3dVectorVector.new
 
     OpenStudio.computeTriangulation(outer, holes).each do |triangle|
-      getSegments(triangle).each do |sg|
+      segments(triangle).each do |sg|
         p0 = sg.first
         p1 = sg.last
 
@@ -4349,7 +4647,7 @@ module OSut
   #
   # @return [Hash] :set, :box, :bbox, :t, :r & :o
   # @return [Hash] :set, :box, :bbox, :t, :r & :o (nil) if invalid (see logs)
-  def getRealignedFace(pts = nil, force = false)
+  def realignedFace(pts = nil, force = false)
     mth = "OSut::#{__callee__}"
     out = { set: nil, box: nil, bbox: nil, t: nil, r: nil, o: nil }
     pts = poly(pts, false, true)
@@ -4372,11 +4670,11 @@ module OSut
     box = boundedBox(pts)
     return invalid("bounded box", mth, 0, DBG, out) if box.empty?
 
-    segments = getSegments(box)
-    return invalid("bounded box segments", mth, 0, DBG, out) if segments.empty?
+    sgments = segments(box)
+    return invalid("bounded box segments", mth, 0, DBG, out) if sgments.empty?
 
     # Deterministic ID of box rotation/translation 'origin'.
-    segments.each_with_index do |sg, idx|
+    sgments.each_with_index do |sg, idx|
       sgs[sg]       = {}
       sgs[sg][:idx] = idx
       sgs[sg][:mid] = midpoint(sg[0], sg[1])
@@ -4396,10 +4694,10 @@ module OSut
       i = sg0[:idx]
     end
 
-    k = i + 2 < segments.size ? i + 2 : i - 2
+    k = i + 2 < sgments.size ? i + 2 : i - 2
 
-    origin   = midpoint(segments[i][0], segments[i][1])
-    terminal = midpoint(segments[k][0], segments[k][1])
+    origin   = midpoint(sgments[i][0], sgments[i][1])
+    terminal = midpoint(sgments[k][0], sgments[k][1])
     seg      = terminal - origin
     right    = OpenStudio::Point3d.new(origin.x + d, origin.y    , 0) - origin
     north    = OpenStudio::Point3d.new(origin.x,     origin.y + d, 0) - origin
@@ -4441,7 +4739,7 @@ module OSut
   # @param pts [Set<OpenStudio::Point3d>] 3D points, once re/aligned
   # @param force [Bool] whether to force rotation of (narrow) bounded box
   #
-  # @return [Float] width al©ong X-axis, once re/aligned
+  # @return [Float] width along X-axis, once re/aligned
   # @return [0.0] if invalid inputs
   def alignedWidth(pts = nil, force = false)
     mth = "OSut::#{__callee__}"
@@ -4453,7 +4751,7 @@ module OSut
       force = false
     end
 
-    pts = getRealignedFace(pts, force)[:set]
+    pts = realignedFace(pts, force)[:set]
     return 0 if pts.size < 2
 
     pts.max_by(&:x).x - pts.min_by(&:x).x
@@ -4477,12 +4775,84 @@ module OSut
       force = false
     end
 
-    pts = getRealignedFace(pts, force)[:set]
+    pts = realignedFace(pts, force)[:set]
     return 0 if pts.size < 2
 
     pts.max_by(&:y).y - pts.min_by(&:y).y
   end
 
+  ##
+  # Fetch a space's full height (in space coordinates). The solution considers
+  # all surface types ("Floor" vs "Wall" vs "RoofCeiling").
+  #
+  # @param space [OpenStudio::Model::Space] a space
+  #
+  # @return [Float] full height of space (0 if invalid input)
+  def spaceHeight(space = nil)
+    return 0 unless space.is_a?(OpenStudio::Model::Space)
+
+    minZ =  10000
+    maxZ = -10000
+
+    space.surfaces.each do |surface|
+      minZ = [surface.vertices.min_by(&:z).z, minZ].min
+      maxZ = [surface.vertices.max_by(&:z).z, maxZ].max
+    end
+
+    maxZ < minZ ? 0 : maxZ - minZ
+  end
+
+  ##
+  # Fetch a space's width, based on the geometry of space floors.
+  #
+  # @param space [OpenStudio::Model::Space] a space
+  #
+  # @return [Float] width of a space (0 if invalid input)
+  def spaceWidth(space = nil)
+    return 0 unless space.is_a?(OpenStudio::Model::Space)
+
+    floors = facets(space, "all", "Floor")
+    return 0 if floors.empty?
+
+    # Automatically determining a space's "width" is not straightforward:
+    #   - a space may hold multiple floor surfaces at various Z-axis levels
+    #   - a space may hold multiple floor surfaces, with unique "widths"
+    #   - a floor surface may expand/contract (in "width") along its length.
+    #
+    # First, attempt to merge all floor surfaces together as 1x polygon:
+    #   - select largest floor surface (in area)
+    #   - determine its 3D plane
+    #   - retain only other floor surfaces sharing same 3D plane
+    #   - recover potential union between floor surfaces
+    #   - fall back to largest floor surface if invalid union
+    #   - return width of largest bounded box
+    floors = floors.sort_by(&:grossArea).reverse
+    floor  = floors.first
+    plane  = floor.plane
+    t      = OpenStudio::Transformation.alignFace(floor.vertices)
+    polyg  = poly(floor, false, true, true, t, :ulc).to_a.reverse
+    return 0 if polyg.empty?
+
+    if floors.size > 1
+      floors = floors.select { |flr| plane.equal(flr.plane, 0.001) }
+
+      if floors.size > 1
+        polygs = floors.map    { |flr| poly(flr, false, true, true, t, :ulc) }
+        polygs = polygs.reject { |plg| plg.empty? }
+        polygs = polygs.map    { |plg| plg.to_a.reverse }
+        union  = OpenStudio.joinAll(polygs, 0.01).first
+        polyg  = poly(union, false, true, true)
+        return 0 if polyg.empty?
+      end
+    end
+
+    res = realignedFace(polyg.to_a.reverse)
+    return 0 if res[:box].nil?
+
+    # A bounded box's 'height', at its narrowest, is its 'width'.
+    height(res[:box])
+  end
+
   ##
   # Identifies 'leader line anchors', i.e. specific 3D points of a (larger) set
   # (e.g. delineating a larger, parent polygon), each anchor linking the BLC
@@ -4504,7 +4874,7 @@ module OSut
   #
   # @param s [Set<OpenStudio::Point3d>] a (larger) parent set of points
   # @param [Array<Hash>] set a collection of (smaller) sequenced points
-  # @option [Symbol] tag sequence of subset vertices to target
+  # @option [#to_sym] tag sequence of subset vertices to target
   #
   # @return [Integer] number of successfully anchored subsets (see logs)
   def genAnchors(s = nil, set = [], tag = :box)
@@ -4512,18 +4882,20 @@ module OSut
     n   = 0
     id  = s.respond_to?(:nameString) ? "#{s.nameString}: " : ""
     pts = poly(s)
-    return invalid("#{id} polygon", mth, 1, DBG, n) if pts.empty?
-    return mismatch("set", set, Array, mth, DBG, n) unless set.respond_to?(:to_a)
+    return invalid("#{id} polygon", mth, 1, DBG, n)  if pts.empty?
+    return mismatch("set", set,  Array, mth, DBG, n) unless set.respond_to?(:to_a)
+    return mismatch("tag", tag, Symbol, mth, DBG, n) unless tag.respond_to?(:to_sym)
 
     origin = OpenStudio::Point3d.new(0,0,0)
     zenith = OpenStudio::Point3d.new(0,0,1)
     ray    = zenith - origin
     set    = set.to_a
+    tag    = tag.to_sym
 
     # Validate individual subsets. Purge surface-specific leader line anchors.
     set.each_with_index do |st, i|
       str1 = id + "subset ##{i+1}"
-      str2 = str1 + " #{tag.to_s}"
+      str2 = str1 + " #{trim(tag)}"
       return mismatch(str1, st, Hash,  mth, DBG, n) unless st.respond_to?(:key?)
       return hashkey( str1, st,  tag,  mth, DBG, n) unless st.key?(tag)
       return empty("#{str2} vertices", mth, DBG, n) if st[tag].empty?
@@ -4576,7 +4948,7 @@ module OSut
       else
         st[:t] = OpenStudio::Transformation.alignFace(pts) unless st.key?(:t)
         tpts   = st[:t].inverse * st[tag]
-        o      = getRealignedFace(tpts, true)
+        o      = realignedFace(tpts, true)
         tpts   = st[:t] * (o[:r] * (o[:t] * o[:set]))
 
         st[:out] = o
@@ -4594,7 +4966,7 @@ module OSut
         nb = 0
 
         # Check for intersections between leader line and larger polygon edges.
-        getSegments(pts).each do |sg|
+        segments(pts).each do |sg|
           break unless nb.zero?
           next if holds?(sg, pt)
 
@@ -4608,7 +4980,7 @@ module OSut
 
           ost = other[tag]
 
-          getSegments(ost).each { |sg| nb += 1 if lineIntersects?(ld, sg) }
+          segments(ost).each { |sg| nb += 1 if lineIntersects?(ld, sg) }
         end
 
         # ... and previous leader lines (first come, first serve basis).
@@ -4626,7 +4998,7 @@ module OSut
         end
 
         # Finally, check for self-intersections.
-        getSegments(tpts).each do |sg|
+        segments(tpts).each do |sg|
           break unless nb.zero?
           next if holds?(sg, tpts.first)
 
@@ -4666,7 +5038,7 @@ module OSut
   # @param s [Set<OpenStudio::Point3d>] a larger (parent) set of points
   # @param [Array<Hash>] set a collection of (smaller) sequenced vertices
   # @option set [Hash] :ld a polygon-specific leader line anchors
-  # @option [Symbol] tag sequence of set vertices to target
+  # @option [#to_sym] tag sequence of set vertices to target
   #
   # @return [OpenStudio::Point3dVector] extended vertices (see logs if empty)
   def genExtendedVertices(s = nil, set = [], tag = :vtx)
@@ -4678,16 +5050,19 @@ module OSut
     a   = OpenStudio::Point3dVector.new
     v   = []
     return a if pts.empty?
-    return mismatch("set", set, Array, mth, DBG, a) unless set.respond_to?(:to_a)
+    return mismatch("set", set,  Array, mth, DBG, a) unless set.respond_to?(:to_a)
+    return mismatch("tag", tag, Symbol, mth, DBG, n) unless tag.respond_to?(:to_sym)
 
     set = set.to_a
+    tag = tag.to_sym
 
     # Validate individual sets.
     set.each_with_index do |st, i|
       str1 = id + "subset ##{i+1}"
-      str2 = str1 + " #{tag.to_s}"
-      next if st.key?(:void) && st[:void]
+      str2 = str1 + " #{trim(tag)}"
       return mismatch(str1, st,  Hash, mth, DBG, a) unless st.respond_to?(:key?)
+      next if st.key?(:void) && st[:void]
+
       return hashkey( str1, st,   tag, mth, DBG, a) unless st.key?(tag)
       return empty("#{str2} vertices", mth, DBG, a) if st[tag].empty?
       return hashkey( str1, st,   :ld, mth, DBG, a) unless st.key?(:ld)
@@ -4696,9 +5071,9 @@ module OSut
       return invalid("#{str2} polygon", mth, 0, DBG, a) if stt.empty?
 
       ld = st[:ld]
-      return mismatch(str, ld,  Hash, mth, DBG, a) unless ld.is_a?(Hash)
-      return hashkey( str, ld,     s, mth, DBG, a) unless ld.key?(s)
-      return mismatch(str, ld[s], cl, mth, DBG, a) unless ld[s].is_a?(cl)
+      return mismatch(str2, ld,  Hash, mth, DBG, a) unless ld.is_a?(Hash)
+      return hashkey( str2, ld,     s, mth, DBG, a) unless ld.key?(s)
+      return mismatch(str2, ld[s], cl, mth, DBG, a) unless ld[s].is_a?(cl)
     end
 
     # Re-sequence polygon vertices.
@@ -4976,8 +5351,8 @@ module OSut
   # surface type filters if 'type' argument == "all".
   #
   # @param spaces [Set<OpenStudio::Model::Space>] target spaces
-  # @param boundary [#to_s] OpenStudio outside boundary condition
-  # @param type [#to_s] OpenStudio surface (or subsurface) type
+  # @param boundary [#to_sym] OpenStudio outside boundary condition
+  # @param type [#to_sym] OpenStudio surface (or subsurface) type
   # @param sides [Set<Symbols>] direction keys, e.g. :north (see OSut::SIDZ)
   #
   # @return [Array<OpenStudio::Model::Surface>] surfaces (may be empty, no logs)
@@ -4986,7 +5361,7 @@ module OSut
     spaces = spaces.respond_to?(:to_a) ? spaces.to_a : []
     return [] if spaces.empty?
 
-    sides = sides.respond_to?(:to_sym) ? [sides] : sides
+    sides = sides.respond_to?(:to_sym) ? [trim(sides).to_sym] : sides
     sides = sides.respond_to?(:to_a) ? sides.to_a : []
 
     faces    = []
@@ -5091,7 +5466,7 @@ module OSut
     pltz.each_with_index do |plt, i|
       id = "plate # #{i+1} (index #{i})"
 
-      return mismatch(id, plt, cl1, mth, DBG, slb) unless plt.is_a?(cl2)
+      return mismatch(id, plt, cl2, mth, DBG, slb) unless plt.is_a?(cl2)
       return hashkey( id, plt,  :x, mth, DBG, slb) unless plt.key?(:x )
       return hashkey( id, plt,  :y, mth, DBG, slb) unless plt.key?(:y )
       return hashkey( id, plt, :dx, mth, DBG, slb) unless plt.key?(:dx)
@@ -5142,7 +5517,7 @@ module OSut
     end
 
     # Once joined, re-adjust Z-axis coordinates.
-    unless z.zero?
+    unless z.round(2) == 0.00
       vtx = OpenStudio::Point3dVector.new
       slb.each { |pt| vtx << OpenStudio::Point3d.new(pt.x, pt.y, z) }
       slb = vtx
@@ -5162,18 +5537,18 @@ module OSut
   # @param spaces [Set<OpenStudio::Model::Space>] target spaces
   #
   # @return [Array<OpenStudio::Model::Surface>] roofs (may be empty)
-  def getRoofs(spaces = [])
+  def roofs(spaces = [])
     mth    = "OSut::#{__callee__}"
     up     = OpenStudio::Point3d.new(0,0,1) - OpenStudio::Point3d.new(0,0,0)
-    roofs  = []
+    rfs    = []
     spaces = spaces.is_a?(OpenStudio::Model::Space) ? [spaces] : spaces
     spaces = spaces.respond_to?(:to_a) ? spaces.to_a : []
 
     spaces = spaces.select { |space| space.is_a?(OpenStudio::Model::Space) }
 
     # Space-specific outdoor-facing roof surfaces.
-    roofs = facets(spaces, "Outdoors", "RoofCeiling")
-    roofs = roofs.select { |roof| roof?(roof) }
+    rfs = facets(spaces, "Outdoors", "RoofCeiling")
+    rfs = rfs.select { |rf| roof?(rf) }
 
     spaces.each do |space|
       # When unoccupied spaces are involved (e.g. plenums, attics), the target
@@ -5209,12 +5584,12 @@ module OSut
           cst = cast(cv0, rvi, up)
           next unless overlaps?(cst, rvi, false)
 
-          roofs << ruf unless roofs.include?(ruf)
+          rfs << ruf unless rfs.include?(ruf)
         end
       end
     end
 
-    roofs
+    rfs
   end
 
   ##
@@ -5240,10 +5615,10 @@ module OSut
     return invalid("baselit"          , mth, 4, DBG, false) unless ck4
 
     walls  = sidelit ? facets(space, "Outdoors", "Wall")        : []
-    roofs  =  toplit ? facets(space, "Outdoors", "RoofCeiling") : []
+    rufs   =  toplit ? facets(space, "Outdoors", "RoofCeiling") : []
     floors = baselit ? facets(space, "Outdoors", "Floor")       : []
 
-    (walls + roofs + floors).each do |surface|
+    (walls + rufs + floors).each do |surface|
       surface.subSurfaces.each do |sub|
         # All fenestrated subsurface types are considered, as user can set these
         # explicitly (e.g. skylight in a wall) in OpenStudio.
@@ -5260,7 +5635,7 @@ module OSut
   # @param s [OpenStudio::Model::Surface] a model surface
   # @param [Array<Hash>] subs requested attributes
   # @option subs [#to_s] :id identifier e.g. "Window 007"
-  # @option subs [#to_s] :type ("FixedWindow") OpenStudio subsurface type
+  # @option subs [#to_sym] :type ("FixedWindow") OpenStudio subsurface type
   # @option subs [#to_i] :count (1) number of individual subs per array
   # @option subs [#to_i] :multiplier (1) OpenStudio subsurface multiplier
   # @option subs [#frameWidth] :frame (nil) OpenStudio frame & divider object
@@ -5370,11 +5745,11 @@ module OSut
       box = boundedBox(s0)
 
       if realign
-        s00 = getRealignedFace(box, true)
+        s00 = realignedFace(box, true)
         return invalid("bound realignment", mth, 0, DBG, false) unless s00[:set]
       end
     elsif realign
-      s00 = getRealignedFace(s0, false)
+      s00 = realignedFace(s0, false)
       return invalid("unbound realignment", mth, 0, DBG, false) unless s00[:set]
     end
 
@@ -5389,12 +5764,13 @@ module OSut
       return mismatch("sub", sub, cl4, mth, DBG, no) unless sub.is_a?(cl3)
 
       # Required key:value pairs (either set by the user or defaulted).
-      sub[:frame     ] = nil  unless sub.key?(:frame     )
-      sub[:assembly  ] = nil  unless sub.key?(:assembly  )
-      sub[:count     ] = 1    unless sub.key?(:count     )
+      sub[:frame     ] = nil  unless sub.key?(:frame)
+      sub[:assembly  ] = nil  unless sub.key?(:assembly)
+      sub[:count     ] = 1    unless sub.key?(:count)
       sub[:multiplier] = 1    unless sub.key?(:multiplier)
-      sub[:id        ] = ""   unless sub.key?(:id        )
-      sub[:type      ] = type unless sub.key?(:type      )
+      sub[:id        ] = ""   unless sub.key?(:id)
+      sub[:type      ] = type unless sub.key?(:type)
+      sub[:type      ] = type unless sub[:type].respond_to?(:to_sym)
       sub[:type      ] = trim(sub[:type])
       sub[:id        ] = trim(sub[:id])
       sub[:type      ] = type                   if sub[:type].empty?
@@ -5983,7 +6359,6 @@ module OSut
           # previously-added leader lines.
           #
           # @todo: revise approach for attics ONCE skylight wells have been added.
-          olap = nil
           olap = overlap(cst, rvi, false)
           next if olap.empty?
 
@@ -6013,24 +6388,24 @@ module OSut
   # (Array of 2x linked surfaces). Each surface may be linked to more than one
   # horizontal ridge.
   #
-  # @param roofs [Array<OpenStudio::Model::Surface>] target surfaces
+  # @param rfs [Array<OpenStudio::Model::Surface>] target surfaces
   #
   # @return [Array] horizontal ridges (see logs if empty)
-  def getHorizontalRidges(roofs = [])
+  def horizontalRidges(rfs = [])
     mth    = "OSut::#{__callee__}"
     ridges = []
-    return ridges unless roofs.is_a?(Array)
+    return ridges unless rfs.is_a?(Array)
 
-    roofs = roofs.select { |s| s.is_a?(OpenStudio::Model::Surface) }
-    roofs = roofs.select { |s| sloped?(s) }
+    rfs = rfs.select { |s| s.is_a?(OpenStudio::Model::Surface) }
+    rfs = rfs.select { |s| sloped?(s) }
 
-    roofs.each do |roof|
-      maxZ = roof.vertices.max_by(&:z).z
-      next if roof.space.empty?
+    rfs.each do |rf|
+      maxZ = rf.vertices.max_by(&:z).z
+      next if rf.space.empty?
 
-      space = roof.space.get
+      space = rf.space.get
 
-      getSegments(roof).each do |edge|
+      segments(rf).each do |edge|
         next unless xyz?(edge, :z, maxZ)
 
         # Skip if already tracked.
@@ -6045,18 +6420,18 @@ module OSut
 
         next if match
 
-        ridge = { edge: edge, length: (edge[1] - edge[0]).length, roofs: [roof] }
+        ridge = { edge: edge, length: (edge[1] - edge[0]).length, roofs: [rf] }
 
         # Links another roof (same space)?
         match = false
 
-        roofs.each do |ruf|
+        rfs.each do |ruf|
           break if match
-          next  if ruf == roof
+          next  if ruf == rf
           next  if ruf.space.empty?
           next  unless ruf.space.get == space
 
-          getSegments(ruf).each do |edg|
+          segments(ruf).each do |edg|
             break    if match
             next unless same?(edge, edg) || same?(edge, edg.reverse)
 
@@ -6100,7 +6475,7 @@ module OSut
       if opts[:size].respond_to?(:to_f)
         w  = opts[:size].to_f
         w2 = w * w
-        return invalid(size, mth, 0, ERR, []) if w.round(2) < gap4
+        return invalid("size", mth, 0, ERR, []) if w.round(2) < gap4
       else
         return mismatch("size", opts[:size], Numeric, mth, DBG, [])
       end
@@ -6123,12 +6498,12 @@ module OSut
       spaces = spaces.select { |sp| sp.partofTotalFloorArea }
       spaces = spaces.reject { |sp| unconditioned?(sp) }
       spaces = spaces.reject { |sp| vestibule?(sp) }
-      spaces = spaces.reject { |sp| getRoofs(sp).empty? }
+      spaces = spaces.reject { |sp| roofs(sp).empty? }
       spaces = spaces.reject { |sp| sp.floorArea < 4 * w2 }
       spaces = spaces.sort_by(&:floorArea).reverse
-      return empty("spaces", mth, WRN, 0) if spaces.empty?
+      return empty("spaces", mth, WRN, []) if spaces.empty?
     else
-      return mismatch("spaces", spaces, Array, mth, DBG, 0)
+      return mismatch("spaces", spaces, Array, mth, DBG, [])
     end
 
     # Unfenestrated spaces have no windows, glazed doors or skylights. By
@@ -6169,7 +6544,7 @@ module OSut
 
     # Gather roof surfaces - possibly those of attics or plenums above.
     spaces.each do |sp|
-      getRoofs(sp).each do |rf|
+      roofs(sp).each do |rf|
         espaces[sp] = {roofs: []} unless espaces.key?(sp)
         espaces[sp][:roofs] << rf unless espaces[sp][:roofs].include?(rf)
       end
@@ -6224,7 +6599,7 @@ module OSut
   # @option opts [Bool] :sloped (true) whether to consider sloped roof surfaces
   # @option opts [Bool] :plenum (true) whether to consider plenum wells
   # @option opts [Bool] :attic (true) whether to consider attic wells
-  # @option opts [Array<#to_s>] :patterns requested skylight allocation (3x)
+  # @option opts [Array<#to_sym>] :patterns requested skylight allocation (3x)
   # @example (a) consider 2D array of individual skylights, e.g. n(1.22m x 1.22m)
   #   opts[:patterns] = ["array"]
   # @example (b) consider 'a', then array of 1x(size) x n(size) skylight strips
@@ -6244,6 +6619,7 @@ module OSut
     bfr   = 0.005 # minimum array perimeter buffer (no wells)
     w     = 1.22  # default 48" x 48" skylight base
     w2    = w * w # m2
+    v     = OpenStudio.openStudioVersion.split(".").join.to_i
 
     # --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- #
     # Excerpts of ASHRAE 90.1 2022 definitions:
@@ -6360,10 +6736,10 @@ module OSut
 
       if frame.respond_to?(:frameWidth)
         frame = nil if v < 321
-        frame = nil if f.frameWidth.round(2) < 0
-        frame = nil if f.frameWidth.round(2) > gap
+        frame = nil if frame.frameWidth.round(2) < 0
+        frame = nil if frame.frameWidth.round(2) > gap
 
-        f = f.frameWidth                            if frame
+        f = frame.frameWidth if frame
         log(WRN, "Skip Frame&Divider (#{mth})") unless frame
       else
         frame = nil
@@ -6420,7 +6796,7 @@ module OSut
     end
 
     # Purge if requested.
-    getRoofs(spaces).each { |s| s.subSurfaces.map(&:remove) } if clear
+    roofs(spaces).each { |s| s.subSurfaces.map(&:remove) } if clear
 
     # Safely exit, e.g. if strictly called to purge existing roof subsurfaces.
     return 0 if area && area.round(2) == 0
@@ -6540,7 +6916,7 @@ module OSut
     if opts.key?(:patterns)
       if opts[:patterns].is_a?(Array)
         opts[:patterns].each_with_index do |pattern, i|
-          pattern = trim(pattern).downcase
+          pattern = pattern.respond_to?(:to_sym) ? trim(pattern).downcase : ""
 
           if pattern.empty?
             invalid("pattern #{i+1}", mth, 0, ERR)
@@ -6588,14 +6964,14 @@ module OSut
       next unless opts[opt] == false
 
       case opt
-      when :sidelit then filters.map! { |f| f.include?("b") ? f.delete("b") : f }
-      when :sloped  then filters.map! { |f| f.include?("c") ? f.delete("c") : f }
-      when :plenum  then filters.map! { |f| f.include?("d") ? f.delete("d") : f }
-      when :attic   then filters.map! { |f| f.include?("e") ? f.delete("e") : f }
+      when :sidelit then filters.map! { |fl| fl.include?("b") ? fl.delete("b") : fl }
+      when :sloped  then filters.map! { |fl| fl.include?("c") ? fl.delete("c") : fl }
+      when :plenum  then filters.map! { |fl| fl.include?("d") ? fl.delete("d") : fl }
+      when :attic   then filters.map! { |fl| fl.include?("e") ? fl.delete("e") : fl }
       end
     end
 
-    filters.reject! { |f| f.empty? }
+    filters.reject! { |fl| fl.empty? }
     filters.uniq!
 
     # Remaining filters may be further pruned automatically after space/roof
@@ -6698,7 +7074,7 @@ module OSut
     # Process outdoor-facing roof surfaces of plenums and attics above.
     rooms.each do |space, room|
       t0   = room[:t0]
-      rufs = getRoofs(space) - room[:roofs]
+      rufs = roofs(space) - room[:roofs]
 
       rufs.each do |ruf|
         next unless roof?(ruf)
@@ -6860,12 +7236,12 @@ module OSut
     # Ensure uniqueness of plenum roofs.
     attics.values.each do |attic|
       attic[:roofs ].uniq!
-      attic[:ridges] = getHorizontalRidges(attic[:roofs]) # @todo
+      attic[:ridges] = horizontalRidges(attic[:roofs]) # @todo
     end
 
     plenums.values.each do |plenum|
       plenum[:roofs ].uniq!
-      plenum[:ridges] = getHorizontalRidges(plenum[:roofs]) # @todo
+      plenum[:ridges] = horizontalRidges(plenum[:roofs]) # @todo
     end
 
     # Regardless of the selected skylight arrangement pattern, the solution only
@@ -7388,7 +7764,7 @@ module OSut
             pattern = "array"
           elsif fpm2.keys.include?("strips")
             pattern = "strips"
-          else fpm2.keys.include?("strip")
+          else # fpm2.keys.include?("strip")
             pattern = "strip"
           end
         else
@@ -7399,7 +7775,7 @@ module OSut
             pattern = "strip"
           elsif fpm2.keys.include?("strips")
             pattern = "strips"
-          else fpm2.keys.include?("array")
+          else # fpm2.keys.include?("array")
             pattern = "array"
           end
         end
@@ -7502,7 +7878,7 @@ module OSut
     # Size contraction: round 2: prioritize larger sets.
     adm2 = 0
 
-    sets.each_with_index do |set, i|
+    sets.each_with_index do |set|
       next if set[:w].round(2) <= w0
       next if set[:d].round(2) <= w0
 
@@ -7674,12 +8050,12 @@ module OSut
 
           # Generate well walls.
           vX = cast(roof, tile, ray)
-          s0 = getSegments(t0 * roof.vertices)
-          sX = getSegments(t0 * vX)
+          s0 = segments(t0 * roof.vertices)
+          sX = segments(t0 * vX)
 
           s0.each_with_index do |sg, j|
-            sg0 = sg.to_a
-            sgX = sX[j].to_a
+            sg0 = sg
+            sgX = sX[j]
             vec = OpenStudio::Point3dVector.new
             vec << sg0.first
             vec << sg0.last