RubyGems - osut - Versions diffs - 0.5.0 → 0.7.0 - Mend

osut 0.5.0 → 0.7.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (9) hide show

checksums.yaml +4 -4
data/.github/workflows/pull_request.yml +21 -21
data/.gitignore +2 -0
data/LICENSE +1 -1
data/lib/osut/utils.rb +1676 -1072
data/lib/osut/version.rb +2 -2
data/lib/osut.rb +1 -1
data/osut.gemspec +1 -1
metadata +6 -9

data/lib/osut/utils.rb CHANGED Viewed

@@ -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
@@ -34,20 +34,20 @@ 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  # see github.com/rd2/oslg
-  INF  = OSlg::INFO   # see github.com/rd2/oslg
-  WRN  = OSlg::WARN   # see github.com/rd2/oslg
-  ERR  = OSlg::ERROR  # see github.com/rd2/oslg
-  FTL  = OSlg::FATAL  # 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)
+  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
   # General surface orientations (see facets method)
-  SIDZ = [:bottom, # e.g. ground-facing, exposed floros
+  SIDZ = [:bottom, # e.g. ground-facing, exposed floors
              :top, # e.g. roof/ceiling
            :north, # NORTH
             :east, # EAST
@@ -220,13 +220,14 @@ module OSut
     chk = @@uo.keys.include?(specs[:type])
     return invalid("surface type", mth, 2, ERR) unless chk
-    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
+      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 zero("#{id} Uo",                 mth,    ERR) if u.round(2) == 0.00
+      return negative("#{id} Uo",             mth,    ERR) if u < 0
     end
     # Optional specs. Log/reset if invalid.
@@ -466,14 +467,14 @@ module OSut
       a[:compo  ][:d   ] = d
       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)}"
     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"
@@ -482,25 +483,11 @@ module OSut
     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
+    unglazed = a[:glazing].empty? ? true : false
-    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 unglazed
+      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 +511,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.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]
-      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)
-      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?
-        index = lyr[:index]
-        layer = c.getLayer(index).to_StandardOpaqueMaterial
-        return invalid("#{id} material @#{index}", mth, 0) if layer.empty?
-        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  += "|"
-        nom  += format("%03d", d*1000)[-3..-1]
-        layer.setName(nom) if model.getStandardOpaqueMaterialByName(nom).empty?
-        layer.setThickness(d)
+    if u and unglazed
+      ro = 1 / u - film
+      if ro > 0
+        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 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?
+          index = lyr[:index]
+          layer = c.getLayer(index).to_StandardOpaqueMaterial
+          return invalid("#{id} material @#{index}", mth, 0) if layer.empty?
+          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  += "|"
+          nom  += format("%03d", d*1000)[-3..-1]
+          lyr = model.getStandardOpaqueMaterialByName(nom)
+          if lyr.empty?
+            layer.setName(nom)
+            layer.setThickness(d)
+          else
+            omat = lyr.get
+            c.setLayer(index, omat)
+          end
+        end
       end
     end
@@ -746,7 +757,7 @@ module OSut
   # Validates if a default construction set holds a base construction.
   #
   # @param set [OpenStudio::Model::DefaultConstructionSet] a default set
-  # @param bse [OpensStudio::Model::ConstructionBase] a construction base
+  # @param bse [OpenStudio::Model::ConstructionBase] a construction base
   # @param gr [Bool] if ground-facing surface
   # @param ex [Bool] if exterior-facing surface
   # @param tp [#to_s] a surface type
@@ -1048,7 +1059,7 @@ module OSut
     return invalid("lc", mth, 1, DBG, res) unless lc.respond_to?(NS)
     id   = lc.nameString
-    return mismatch(id, lc, cl1, mth, DBG, res) unless lc.is_a?(cl)
+    return mismatch(id, lc, cl, mth, DBG, res) unless lc.is_a?(cl)
     lc.layers.each do |m|
       unless m.to_MasslessOpaqueMaterial.empty?
@@ -1102,7 +1113,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 +1140,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 +1433,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 +1548,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 +1615,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 +1746,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 +1813,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
@@ -1924,7 +1983,7 @@ module OSut
     # isolation) to determine whether an UNOCCUPIED space should have its
     # envelope insulated ("plenum") or not ("attic").
     #
-    # In contrast to OpenStudio-Standards' "space_plenum?", this method
+    # In contrast to OpenStudio-Standards' "space_plenum?", the method below
     # strictly returns FALSE if a space is indeed "partofTotalFloorArea". It
     # also returns FALSE if the space is a vestibule. Otherwise, it needs more
     # information to determine if such an UNOCCUPIED space is indeed a
@@ -1933,7 +1992,7 @@ module OSut
     # CASE A: it includes the substring "plenum" (case insensitive) in its
     #         spaceType's name, or in the latter's standardsSpaceType string;
     #
-    # CASE B: "isPlenum" == TRUE in an OpenStudio model WITH HVAC airloops: OR
+    # CASE B: "isPlenum" == TRUE in an OpenStudio model WITH HVAC airloops; OR
     #
     # CASE C: its zone holds an 'inactive' thermostat (i.e. can't extract valid
     #         setpoints) in an OpenStudio model with setpoint temperatures.
@@ -2054,7 +2113,7 @@ module OSut
         res[:heating] = nil
         res[:cooling] = nil
       elsif cnd.downcase == "semiheated"
-        res[:heating] = 15.0 if res[:heating].nil?
+        res[:heating] = 14.0 if res[:heating].nil?
         res[:cooling] = nil
       elsif cnd.downcase.include?("conditioned")
         # "nonresconditioned", "resconditioned" or "indirectlyconditioned"
@@ -2090,6 +2149,60 @@ module OSut
     ok
   end
+  ##
+  # Validates whether a space can be considered as REFRIGERATED.
+  #
+  # @param space [OpenStudio::Model::Space] a space
+  #
+  # @return [Bool] whether space is considered REFRIGERATED
+  # @return [false] if invalid input (see logs)
+  def refrigerated?(space = nil)
+    mth = "OSut::#{__callee__}"
+    cl  = OpenStudio::Model::Space
+    tg0 = "refrigerated"
+    return mismatch("space", space, cl, mth, DBG, false) unless space.is_a?(cl)
+    # 1. First check OSut's REFRIGERATED status.
+    status = space.additionalProperties.getFeatureAsString(tg0)
+    unless status.empty?
+      status = status.get
+      return status if [true, false].include?(status)
+      log(ERR, "Unknown #{space.nameString} REFRIGERATED #{status} (#{mth})")
+    end
+    # 2. Else, compare design heating/cooling setpoints.
+    stps = setpoints(space)
+    return false unless stps[:heating].nil?
+    return false     if stps[:cooling].nil?
+    return true      if stps[:cooling] < 15
+    false
+  end
+  ##
+  # Validates whether a space can be considered as SEMIHEATED as per NECB 2020
+  # 1.2.1.2. 2): design heating setpoint < 15°C (and non-REFRIGERATED).
+  #
+  # @param space [OpenStudio::Model::Space] a space
+  #
+  # @return [Bool] whether space is considered SEMIHEATED
+  # @return [false] if invalid input (see logs)
+  def semiheated?(space = nil)
+    mth = "OSut::#{__callee__}"
+    cl  = OpenStudio::Model::Space
+    return mismatch("space", space, cl, mth, DBG, false) unless space.is_a?(cl)
+    return false if refrigerated?(space)
+    stps = setpoints(space)
+    return false unless stps[:cooling].nil?
+    return false     if stps[:heating].nil?
+    return true      if stps[:heating] < 15
+    false
+  end
   ##
   # Generates an HVAC availability schedule.
   #
@@ -2256,9 +2369,9 @@ module OSut
   # ---- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---- #
   # This final set of utilities targets OpenStudio geometry. Many of the
   # following geometry methods rely on Boost as an OpenStudio dependency.
-  # As per Boost requirements, points (e.g. polygons) must first be 'aligned':
+  # As per Boost requirements, points (e.g. vertical polygon) must be 'aligned':
   #   - first rotated/tilted as to lay flat along XY plane (Z-axis ~= 0)
-  #   - initial Z-axis values are represented as Y-axis values
+  #   - initial Z-axis values now become Y-axis values
   #   - points with the lowest X-axis values are 'aligned' along X-axis (0)
   #   - points with the lowest Z-axis values are 'aligned' along Y-axis (0)
   #   - for several Boost methods, points must be clockwise in sequence
@@ -2297,7 +2410,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)
@@ -2330,31 +2443,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) }
@@ -2630,7 +2743,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
   ##
@@ -2721,21 +2834,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
@@ -2749,10 +2866,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|
@@ -2779,7 +2896,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])
@@ -2796,10 +2912,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|
@@ -2826,7 +2942,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?
@@ -2851,18 +2967,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)
@@ -2887,9 +3002,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) }
@@ -2904,9 +3019,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?
@@ -2917,10 +3032,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)
@@ -2929,25 +3044,32 @@ 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)
     xa1b2 = a.cross(a1b2)
+    xa1b1.normalize
+    xa1b2.normalize
+    xab.normalize
     return nil unless xab.cross(xa1b1).length.round(4) < TOL2
     return nil unless xab.cross(xa1b2).length.round(4) < TOL2
+    # Reset.
+    xa1b1 = a.cross(a1b1)
+    xa1b2 = a.cross(a1b2)
     # Both segment endpoints can't be 'behind' point.
     return nil if a.dot(a1b1) < 0 && a.dot(a1b2) < 0
@@ -2974,7 +3096,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
@@ -2988,33 +3110,36 @@ 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
   ##
-  # Determines if pre-'aligned' OpenStudio 3D points are listed clockwise.
+  # Validates whether OpenStudio 3D points are listed clockwise, assuming points
+  # have been pre-'aligned' - not just flattened along XY (i.e. Z = 0).
   #
-  # @param pts [OpenStudio::Point3dVector] 3D points
+  # @param pts [OpenStudio::Point3dVector] pre-aligned 3D points
   #
   # @return [Bool] whether sequence is clockwise
   # @return [false] if invalid input (see logs)
   def clockwise?(pts = nil)
     mth = "OSut::#{__callee__}"
     pts = to_p3Dv(pts)
-    n   = false
-    return invalid("3+ points"  , mth, 1, DBG, n)     if pts.size < 3
-    return invalid("flat points", mth, 1, DBG, n) unless xyz?(pts, :z)
+    return invalid("3+ points"  , mth, 1, DBG, false)     if pts.size < 3
+    return invalid("flat points", mth, 1, DBG, false) unless xyz?(pts, :z)
+    n = OpenStudio.getOutwardNormal(pts)
+    return invalid("polygon", mth, 1, DBG, false) if n.empty?
-    OpenStudio.pointInPolygon(pts.first, pts, TOL)
+    n.get.z > 0 ? false : true
   end
   ##
@@ -3078,28 +3203,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
@@ -3107,36 +3237,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?
+    a = pts.delete_if { |pt| holds?(ncolls, pt) }
-    to_p3Dv( 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
   ##
@@ -3144,8 +3285,8 @@ module OSut
   # polygon. In addition to basic OpenStudio polygon tests (e.g. all points
   # sharing the same 3D plane, non-self-intersecting), the method can
   # optionally check for convexity, or ensure uniqueness and/or non-collinearity.
-  # Returned vector can also be 'aligned', as well as in UpperLeftCorner (ULC)
-  # counterclockwise sequence, or in clockwise sequence.
+  # Returned vector can also be 'aligned', as well as in UpperLeftCorner (ULC),
+  # BottomLeftCorner (BLC), in clockwise (or counterclockwise) sequence.
   #
   # @param pts [Set<OpenStudio::Point3d>] 3D points
   # @param vx [Bool] whether to check for convexity
@@ -3162,7 +3303,7 @@ module OSut
     v   = OpenStudio::Point3dVector.new
     vx  = false unless [true, false].include?(vx)
     uq  = false unless [true, false].include?(uq)
-    co  = true  unless [true, false].include?(co)
+    co  = false unless [true, false].include?(co)
     # --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- #
     # Exit if mismatched/invalid arguments.
@@ -3173,8 +3314,8 @@ module OSut
     # --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- #
     # Minimum 3 points?
-    p3 = getNonCollinears(pts, 3)
-    return empty("polygon", mth, ERR, v) if p3.size < 3
+    p3 = nonCollinears(pts, 3)
+    return empty("polygon (non-collinears < 3)", mth, ERR, v) if p3.size < 3
     # Coplanar?
     pln = OpenStudio::Plane.new(p3)
@@ -3204,8 +3345,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?
@@ -3214,7 +3355,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]
@@ -3273,49 +3414,47 @@ module OSut
     return mismatch("point", p0, cl, mth, DBG, false) unless p0.is_a?(cl)
     n = OpenStudio.getOutwardNormal(s)
-    return false if n.empty?
+    return invalid("plane/normal", mth, 2, DBG, false) if n.empty?
     n  = n.get
     pl = OpenStudio::Plane.new(s.first, n)
     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
-      pts = []
       # 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
-        # One of the polygon vertices?
+        # Skip test altogether if one of the polygon vertices.
         if holds?(s, intersect)
-          next if holds?(pts, intersect)
-          pts << intersect
+          ctr = 0
+          break
+        else
+          ctr += 1
         end
-        ctr += 1
       end
       next         if ctr.zero?
@@ -3334,56 +3473,88 @@ module OSut
   # @return [Bool] whether 2 polygons are parallel
   # @return [false] if invalid input (see logs)
   def parallel?(p1 = nil, p2 = nil)
-    p1  = poly(p1, false, true, false)
-    p2  = poly(p2, false, true, false)
+    p1 = poly(p1, false, true)
+    p2 = poly(p2, false, true)
     return false if p1.empty?
     return false if p2.empty?
-    p1 = getNonCollinears(p1, 3)
-    p2 = getNonCollinears(p2, 3)
-    return false if p1.empty?
-    return false if p2.empty?
+    n1 = OpenStudio.getOutwardNormal(p1)
+    n2 = OpenStudio.getOutwardNormal(p2)
+    return false if n1.empty?
+    return false if n2.empty?
+    n1.get.dot(n2.get).abs > 0.99
+  end
+  ##
+  # Validates whether a polygon can be considered a valid 'roof' surface, as per
+  # ASHRAE 90.1 & Canadian NECBs, i.e. outward normal within 60° from vertical
+  #
+  # @param pts [Set<OpenStudio::Point3d>] OpenStudio 3D points
+  #
+  # @return [Bool] if considered a roof surface
+  # @return [false] if invalid input (see logs)
+  def roof?(pts = nil)
+    ray = OpenStudio::Point3d.new(0,0,1) - OpenStudio::Point3d.new(0,0,0)
+    dut = Math.cos(60 * Math::PI / 180)
+    pts = poly(pts, false, true, true)
+    return false if pts.empty?
-    pl1 = OpenStudio::Plane.new(p1)
-    pl2 = OpenStudio::Plane.new(p2)
+    dot = ray.dot(OpenStudio.getOutwardNormal(pts).get)
+    return false if dot.round(2) <= 0
+    return true  if dot.round(2) == 1
-    pl1.outwardNormal.dot(pl2.outwardNormal).abs > 0.99
+    dot.round(4) >= dut.round(4)
   end
   ##
-  # Validates whether a polygon faces upwards.
+  # Validates whether a polygon faces upwards, harmonized with OpenStudio
+  # Utilities' "alignZPrime" function.
   #
   # @param pts [Set<OpenStudio::Point3d>] OpenStudio 3D points
   #
   # @return [Bool] if facing upwards
   # @return [false] if invalid input (see logs)
   def facingUp?(pts = nil)
-    up  = OpenStudio::Point3d.new(0,0,1) - OpenStudio::Point3d.new(0,0,0)
-    pts = poly(pts, false, true, false)
-    return false if pts.empty?
-    pts = getNonCollinears(pts, 3)
+    ray = OpenStudio::Point3d.new(0,0,1) - OpenStudio::Point3d.new(0,0,0)
+    pts = poly(pts, false, true, true)
     return false if pts.empty?
-    OpenStudio::Plane.new(pts).outwardNormal.dot(up) > 0.99
+    OpenStudio.getOutwardNormal(pts).get.dot(ray) > 0.99
   end
   ##
-  # Validates whether a polygon faces downwards.
+  # Validates whether a polygon faces downwards, harmonized with OpenStudio
+  # Utilities' "alignZPrime" function.
   #
   # @param pts [Set<OpenStudio::Point3d>] OpenStudio 3D points
   #
   # @return [Bool] if facing downwards
   # @return [false] if invalid input (see logs)
   def facingDown?(pts = nil)
-    lo  = OpenStudio::Point3d.new(0,0,-1) - OpenStudio::Point3d.new(0,0,0)
-    pts = poly(pts, false, true, false)
+    ray = OpenStudio::Point3d.new(0,0,-1) - OpenStudio::Point3d.new(0,0,0)
+    pts = poly(pts, false, true, true)
     return false if pts.empty?
-    pts = getNonCollinears(pts, 3)
+    OpenStudio.getOutwardNormal(pts).get.dot(ray) > 0.99
+  end
+  ##
+  # Validates whether surface can be considered 'sloped' (i.e. not ~flat, as per
+  # OpenStudio Utilities' "alignZPrime"). A vertical polygon returns true.
+  #
+  # @param pts [Set<OpenStudio::Point3d>] OpenStudio 3D points
+  #
+  # @return [Bool] whether surface is sloped
+  # @return [false] if invalid input (see logs)
+  def sloped?(pts = nil)
+    mth = "OSut::#{__callee__}"
+    pts = poly(pts, false, true, true)
     return false if pts.empty?
+    return false if facingUp?(pts)
+    return false if facingDown?(pts)
-    OpenStudio::Plane.new(pts).outwardNormal.dot(lo) > 0.99
+    true
   end
   ##
@@ -3424,7 +3595,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)
@@ -3454,6 +3625,15 @@ module OSut
     p1.each { |p0| return false unless pointWithinPolygon?(p0, p2) }
+    # Although p2 points may lie ALONG p1, none may lie entirely WITHIN p1.
+    p2.each { |p0| return false if pointWithinPolygon?(p0, p1, true) }
+    # p1 segment mid-points must not lie OUTSIDE of p2.
+    segments(p1).each do |sg|
+      mp = midpoint(sg.first, sg.last)
+      return false unless pointWithinPolygon?(mp, p2)
+    end
     entirely = false unless [true, false].include?(entirely)
     return true unless entirely
@@ -3492,22 +3672,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
@@ -3587,7 +3762,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:
     #
@@ -3600,7 +3775,7 @@ module OSut
     # The following +/- replicates the same solution, based on:
     #   https://stackoverflow.com/a/65832417
     p0 = p2.first
-    pl = OpenStudio::Plane.new(getNonCollinears(p2, 3))
+    pl = OpenStudio::Plane.new(p2)
     n  = pl.outwardNormal
     return face if n.dot(ray).abs < TOL
@@ -3920,12 +4095,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)
@@ -3962,6 +4137,8 @@ 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 = nonCollinears(box, 4)
+    return bkp unless box.size == 4
     box = blc(box)
     return bkp unless rectangular?(box)
@@ -3993,7 +4170,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)
@@ -4007,6 +4184,9 @@ module OSut
     box << mpoints.first
     box << mpoints.last
     box << plane.project(mpoints.last)
+    box = nonCollinears(box).to_a
+    return bkp unless box.size == 4
     box = clockwise?(box) ? blc(box.reverse) : blc(box)
     return bkp unless rectangular?(box)
     return bkp unless fits?(box, pts)
@@ -4057,20 +4237,21 @@ 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?
         next unless fits?(out, pts)
+        next if fits?(pts, out)
         area = OpenStudio.getArea(out)
         next if area.empty?
@@ -4085,7 +4266,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
@@ -4096,6 +4277,7 @@ module OSut
         out = triadBox(OpenStudio::Point3dVector.new([p0, p1, p2]))
         next if out.empty?
         next unless fits?(out, pts)
+        next if fits?(pts, out)
         area = OpenStudio.getArea(out)
         next if area.empty?
@@ -4117,7 +4299,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
@@ -4128,6 +4310,7 @@ module OSut
         out = medialBox(OpenStudio::Point3dVector.new([p0, p1, p2]))
         next if out.empty?
         next unless fits?(out, pts)
+        next if fits?(pts, out)
         area = OpenStudio.getArea(box)
         next if area.empty?
@@ -4149,7 +4332,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]
@@ -4157,6 +4340,7 @@ module OSut
       out = medialBox(OpenStudio::Point3dVector.new([p0, p1, p2]))
       next if out.empty?
       next unless fits?(out, pts)
+      next if fits?(pts, out)
       area = OpenStudio.getArea(box)
       next if area.empty?
@@ -4180,7 +4364,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
@@ -4191,6 +4375,7 @@ module OSut
           out = medialBox(OpenStudio::Point3dVector.new([p0, p1, p2]))
           next if out.empty?
           next unless fits?(out, pts)
+          next if fits?(pts, out)
           area = OpenStudio.getArea(out)
           next if area.empty?
@@ -4214,25 +4399,29 @@ module OSut
   ##
   # Generates re-'aligned' polygon vertices wrt main axis of symmetry of its
-  # largest bounded box. A Hash is returned with 6x key:value pairs ...
+  # largest bounded box. Input polygon vertex Z-axis values must equal 0, and be
+  # counterclockwise. A Hash is returned with 6x key:value pairs ...
   # set: realigned (cloned) polygon vertices, box: its bounded box (wrt to :set),
   # bbox: its bounding box, t: its translation transformation, r: its rotation
   # transformation, and o: the origin coordinates of its axis of rotation. First,
   # cloned polygon vertices are rotated so the longest axis of symmetry of its
   # bounded box lies parallel to the X-axis; :o being the midpoint of the narrow
-  # side (of the bounded box) nearest to grid origin (0,0,0). Once rotated,
+  # side (of the bounded box) nearest to grid origin (0,0,0). If the axis of
+  # symmetry of the bounded box is already parallel to the X-axis, then the
+  # rotation step is skipped (unless force == true). Whether rotated or not,
   # polygon vertices are then translated as to ensure one or more vertices are
   # aligned along the X-axis and one or more vertices are aligned along the
-  # Y-axis (no vertices with negative X or Y coordinate values). To unalign the
-  # returned set of vertices (or its bounded box, or its bounding box), first
-  # inverse the translation transformation, then inverse the rotation
+  # Y-axis (no vertices with negative X or Y coordinate values). To unalign
+  # the returned set of vertices (or its bounded box, or its bounding box),
+  # first inverse the translation transformation, then inverse the rotation
   # transformation.
   #
   # @param pts [Set<OpenStudio::Point3d>] OpenStudio 3D points
+  # @param force [Bool] whether to force rotation for aligned yet narrow boxes
   #
   # @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)
+  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)
@@ -4240,6 +4429,13 @@ module OSut
     return invalid("aligned plane", mth, 1, DBG, out) unless xyz?(pts, :z)
     return invalid("clockwise pts", mth, 1, DBG, out)     if clockwise?(pts)
+    # Optionally force rotation so bounded box ends up wider than taller.
+    # Strongly suggested for flat surfaces like roofs (see 'sloped?').
+    unless [true, false].include?(force)
+      log(DBG, "Ignoring force input (#{mth})")
+      force = false
+    end
     o   = OpenStudio::Point3d.new(0, 0, 0)
     w   = width(pts)
     h   = height(pts)
@@ -4248,11 +4444,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])
@@ -4263,7 +4459,6 @@ module OSut
     sgs = sgs.sort_by { |sg, s| s[:mo] }.first(2).to_h     if square?(box)
     sgs = sgs.sort_by { |sg, s| s[:l ] }.first(2).to_h unless square?(box)
     sgs = sgs.sort_by { |sg, s| s[:mo] }.first(2).to_h unless square?(box)
     sg0 = sgs.values[0]
     sg1 = sgs.values[1]
@@ -4273,16 +4468,23 @@ 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
     axis     = OpenStudio::Point3d.new(origin.x,     origin.y    , d) - origin
     angle    = OpenStudio::getAngle(right, seg)
     angle    = -angle if north.dot(seg) < 0
+    # Skip rotation if bounded box is already aligned along XY grid (albeit
+    # 'narrow'), i.e. if the angle is 90°.
+    if angle.round(3) == (Math::PI/2).round(3)
+      angle = 0 unless force
+    end
     r        = OpenStudio.createRotation(origin, axis, angle)
     pts      = to_p3Dv(r.inverse * pts)
     box      = to_p3Dv(r.inverse * box)
@@ -4291,13 +4493,13 @@ module OSut
     xy       = OpenStudio::Point3d.new(origin.x + dX, origin.y + dY, 0)
     origin2  = xy - origin
     t        = OpenStudio.createTranslation(origin2)
-    set      = t.inverse * pts
-    box      = t.inverse * box
+    set      = to_p3Dv(t.inverse * pts)
+    box      = to_p3Dv(t.inverse * box)
     bbox     = outline([set])
-    out[:set ] = set
-    out[:box ] = box
-    out[:bbox] = bbox
+    out[:set ] = blc(set)
+    out[:box ] = blc(box)
+    out[:bbox] = blc(bbox)
     out[:t   ] = t
     out[:r   ] = r
     out[:o   ] = origin
@@ -4309,14 +4511,21 @@ module OSut
   # Returns 'width' of a set of OpenStudio 3D points, once re/aligned.
   #
   # @param pts [Set<OpenStudio::Point3d>] 3D points, once re/aligned
+  # @param force [Bool] whether to force rotation of (narrow) bounded box
   #
   # @return [Float] width along X-axis, once re/aligned
   # @return [0.0] if invalid inputs
-  def alignedWidth(pts = nil)
+  def alignedWidth(pts = nil, force = false)
+    mth = "OSut::#{__callee__}"
     pts = poly(pts, false, true, true, true)
     return 0 if pts.size < 2
-    pts = getRealignedFace(pts)[:set]
+    unless [true, false].include?(force)
+      log(DBG, "Ignoring force input (#{mth})")
+      force = false
+    end
+    pts = realignedFace(pts, force)[:set]
     return 0 if pts.size < 2
     pts.max_by(&:x).x - pts.min_by(&:x).x
@@ -4326,57 +4535,149 @@ module OSut
   # Returns 'height' of a set of OpenStudio 3D points, once re/aligned.
   #
   # @param pts [Set<OpenStudio::Point3d>] 3D points, once re/aligned
+  # @param force [Bool] whether to force rotation of (narrow) bounded box
   #
   # @return [Float] height along Y-axis, once re/aligned
   # @return [0.0] if invalid inputs
-  def alignedHeight(pts = nil)
-    pts   = pts = poly(pts, false, true, true, true)
+  def alignedHeight(pts = nil, force = false)
+    mth = "OSut::#{__callee__}"
+    pts = poly(pts, false, true, true, true)
     return 0 if pts.size < 2
-    pts = getRealignedFace(pts)[:set]
+    unless [true, false].include?(force)
+      log(DBG, "Ignoring force input (#{mth})")
+      force = false
+    end
+    pts = realignedFace(pts, force)[:set]
     return 0 if pts.size < 2
     pts.max_by(&:y).y - pts.min_by(&:y).y
   end
   ##
-  # Generates leader line anchors, linking polygon vertices to one or more sets
-  # (Hashes) of sequenced vertices. By default, the method seeks to link set
-  # :vtx (key) vertices (users can select another collection of vertices, e.g.
-  # tag == :box). The method minimally validates individual sets of vertices
-  # (e.g. coplanarity, non-self-intersecting, no inter-set conflicts). Potential
-  # leader lines cannot intersect each other, other 'tagged' set vertices or
-  # original polygon edges. For highly-articulated cases (e.g. a narrow polygon
-  # with multiple concavities, holding multiple sets), such leader line
-  # conflicts will surely occur. The method relies on a 'first-come-first-served'
-  # approach: sets without leader lines are ignored (check for set :void keys,
-  # see error logs). It is recommended to sort sets prior to calling the method.
+  # Fetch a space's full height (in space coordinates). The solution considers
+  # all surface types ("Floor" vs "Wall" vs "RoofCeiling").
   #
-  # @param s [Set<OpenStudio::Point3d>] a larger (parent) set of points
-  # @param [Array<Hash>] set a collection of sequenced vertices
-  # @option [Symbol] tag sequence of set vertices to target
+  # @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 [Integer] number of successfully-generated anchors (check logs)
-  def genAnchors(s = nil, set = [], tag = :vtx)
+  # @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
+  # corner of one or more (smaller) subsets (free-floating within the parent)
+  # - see follow-up 'genInserts'. Subsets may hold several 'tagged' vertices
+  # (e.g. :box, :cbox). By default, the solution seeks to anchor subset :box
+  # vertices. Users can select other tags, e.g. tag == :cbox. The solution
+  # minimally validates individual subsets (e.g. no self-intersecting polygons,
+  # coplanarity, no inter-subset conflicts, must fit within larger set).
+  # Potential leader lines cannot intersect each other, similarly tagged subsets
+  # or (parent) polygon edges. For highly-articulated cases (e.g. a narrow
+  # parent polygon with multiple concavities, holding multiple subsets), such
+  # leader line conflicts are likely unavoidable. It is recommended to first
+  # sort subsets (e.g. areas), given the solution's 'first-come-first-served'
+  # policy. Subsets without valid leader lines are ultimately ignored (check
+  # for new set :void keys, see error logs). The larger set of points is
+  # expected to be in space coordinates - not building or site coordinates,
+  # while subset points are expected to 'fit?' in the larger set.
+  #
+  # @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
+  #
+  # @return [Integer] number of successfully anchored subsets (see logs)
+  def genAnchors(s = nil, set = [], tag = :box)
     mth = "OSut::#{__callee__}"
-    dZ  = nil
-    t   = nil
+    n   = 0
     id  = s.respond_to?(:nameString) ? "#{s.nameString}: " : ""
     pts = poly(s)
-    n   = 0
-    return n if pts.empty?
+    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)
-    set = set.to_a
+    origin = OpenStudio::Point3d.new(0,0,0)
+    zenith = OpenStudio::Point3d.new(0,0,1)
+    ray    = zenith - origin
+    set    = set.to_a
-    # Validate individual sets. Purge surface-specific leader line anchors.
+    # Validate individual subsets. Purge surface-specific leader line anchors.
     set.each_with_index do |st, i|
-      str1 = id + "set ##{i+1}"
+      str1 = id + "subset ##{i+1}"
       str2 = str1 + " #{tag.to_s}"
       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?
+      if st.key?(:out)
+        return hashkey( str1, st,   :t,  mth, DBG, n) unless st.key?(:t)
+        return hashkey( str1, st,  :ti,  mth, DBG, n) unless st.key?(:ti)
+        return hashkey( str1, st,  :t0,  mth, DBG, n) unless st.key?(:t0)
+      end
       stt = poly(st[tag])
       return invalid("#{str2} polygon", mth, 0, DBG, n) if stt.empty?
       return invalid("#{str2} gap", mth, 0, DBG, n) unless fits?(stt, pts, true)
@@ -4391,76 +4692,87 @@ module OSut
       end
     end
-    if facingUp?(pts)
-      if xyz?(pts, :z)
-        dZ = 0
+    set.each_with_index do |st, i|
+      # When a subset already holds a leader line anchor (from an initial call
+      # to 'genAnchors'), it inherits key :out - a Hash holding (among others) a
+      # 'realigned' set of points (by default a 'realigned' :box). The latter is
+      # typically generated from an outdoor-facing roof (e.g. when called from
+      # 'lights'). Subsequent calls to 'genAnchors' may send (as first
+      # argument) a corresponding ceiling tile below (also from 'addSkylights').
+      # Roof vs ceiling may neither share alignment transformation nor space
+      # site transformation identities. All subsequent calls to 'genAnchors'
+      # shall recover the :out points, apply a succession of de/alignments and
+      # transformations in sync , and overwrite tagged points.
+      #
+      # Although 'genAnchors' and 'genInserts' have both been developed to
+      # support anchor insertions in other cases (e.g. bay window in a wall),
+      # variables and terminology here continue pertain to roofs, ceilings,
+      # skylights and wells - less abstract, simpler to follow.
+      if st.key?(:out)
+        ti   = st[:ti ] # unoccupied attic/plenum space site transformation
+        t0   = st[:t0 ] # occupied space site transformation
+        t    = st[:t  ] # initial alignment transformation of roof surface
+        o    = st[:out]
+        tpts = t0.inverse * (ti * (t * (o[:r] * (o[:t] * o[:set]))))
+        tpts = cast(tpts, pts, ray)
+        st[tag] = tpts
       else
-        dZ = pts.first.z
-        pts = flatten(pts).to_a
+        st[:t] = OpenStudio::Transformation.alignFace(pts) unless st.key?(:t)
+        tpts   = st[:t].inverse * st[tag]
+        o      = realignedFace(tpts, true)
+        tpts   = st[:t] * (o[:r] * (o[:t] * o[:set]))
+        st[:out] = o
+        st[tag ] = tpts
       end
-    else
-      t  = OpenStudio::Transformation.alignFace(pts)
-      pts = t.inverse * pts
     end
-    # Set leader lines anchors. Gather candidate leader line anchors; select
-    # anchor with shortest distance to first vertex of 'tagged' set.
+    # Identify candidate leader line anchors for each subset.
     set.each_with_index do |st, i|
       candidates = []
-      break if st[:ld].key?(s)
+      tpts = st[tag]
-      stt = dZ ? flatten(st[tag]).to_a : t.inverse * st[tag]
-      p1  = stt.first
+      pts.each do |pt|
+        ld = [pt, tpts.first]
+        nb = 0
-      pts.each_with_index do |pt, k|
-        ld  = [pt, p1]
-        nb  = 0
-        # Check for intersections between leader line and polygon edges.
-        getSegments(pts).each do |sg|
+        # Check for intersections between leader line and larger polygon edges.
+        segments(pts).each do |sg|
           break unless nb.zero?
           next if holds?(sg, pt)
           nb += 1 if lineIntersects?(sg, ld)
         end
-        next unless nb.zero?
-        # Check for intersections between candidate leader line and other sets.
-        set.each_with_index do |other, j|
+        # Check for intersections between candidate leader line vs other subsets.
+        set.each do |other|
           break unless nb.zero?
-          next if i == j
+          next if st == other
-          ost = dZ ? flatten(other[tag]).to_a : t.inverse * other[tag]
-          sgj = getSegments(ost)
+          ost = other[tag]
-          sgj.each { |sg| nb += 1 if lineIntersects?(ld, sg) }
+          segments(ost).each { |sg| nb += 1 if lineIntersects?(ld, sg) }
         end
-        next unless nb.zero?
         # ... and previous leader lines (first come, first serve basis).
-        set.each_with_index do |other, j|
+        set.each do |other|
           break unless nb.zero?
-          next if i == j
+          next if st == other
+          next unless other.key?(:ld)
           next unless other[:ld].key?(s)
           ost = other[tag]
-          pj  = ost.first
-          old = other[:ld][s]
-          ldj = dZ ? flatten([ old, pj ]) : t.inverse * [ old, pj ]
+          pld = other[:ld][s]
+          next if same?(pld, pt)
-          unless same?(old, pt)
-            nb += 1 if lineIntersects?(ld, ldj)
-          end
+          nb += 1 if lineIntersects?(ld, [pld, ost.first])
         end
-        next unless nb.zero?
         # Finally, check for self-intersections.
-        getSegments(stt).each do |sg|
+        segments(tpts).each do |sg|
           break unless nb.zero?
-          next if holds?(sg, p1)
+          next if holds?(sg, tpts.first)
           nb += 1 if lineIntersects?(sg, ld)
           nb += 1 if (sg.first - sg.last).cross(ld.first - ld.last).length < TOL
@@ -4471,18 +4783,13 @@ module OSut
       if candidates.empty?
         str = id + "set ##{i+1}"
-        log(ERR, "#{str}: unable to anchor #{tag} leader line (#{mth})")
+        log(WRN, "#{str}: unable to anchor #{tag} leader line (#{mth})")
         st[:void] = true
       else
-        p0 = candidates.sort_by! { |pt| (pt - p1).length }.first
-        if dZ
-          st[:ld][s] = OpenStudio::Point3d.new(p0.x, p0.y, p0.z + dZ)
-        else
-          st[:ld][s] = t * p0
-        end
+        p0 = candidates.sort_by { |pt| (pt - tpts.first).length }.first
         n += 1
+        st[:ld][s] = p0
       end
     end
@@ -4490,17 +4797,19 @@ module OSut
   end
   ##
-  # Generates extended polygon vertices to circumscribe one or more sets
-  # (Hashes) of sequenced vertices. The method minimally validates individual
-  # sets of vertices (e.g. coplanarity, non-self-intersecting, no inter-set
-  # conflicts). Valid leader line anchors (set key :ld) need to be generated
-  # prior to calling the method (see genAnchors). By default, the method seeks
-  # to link leader line anchors to set :vtx (key) vertices (users can select
-  # another collection of vertices, e.g. tag == :box).
+  # Extends (larger) polygon vertices to circumscribe one or more (smaller)
+  # subsets of vertices, based on previously-generated 'leader line' anchors.
+  # The solution minimally validates individual subsets (e.g. no
+  # self-intersecting polygons, coplanarity, no inter-subset conflicts, must fit
+  # within larger set). Valid leader line anchors (set key :ld) need to be
+  # generated prior to calling the method - see 'genAnchors'. Subsets may hold
+  # several 'tag'ged vertices (e.g. :box, :vtx). By default, the solution
+  # seeks to anchor subset :vtx vertices. Users can select other tags, e.g.
+  # tag == :box).
   #
   # @param s [Set<OpenStudio::Point3d>] a larger (parent) set of points
-  # @param [Array<Hash>] set a collection of sequenced vertices
-  # @option set [Hash] :ld a collection of polygon-specific leader line anchors
+  # @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
   #
   # @return [OpenStudio::Point3dVector] extended vertices (see logs if empty)
@@ -4519,9 +4828,11 @@ module OSut
     # Validate individual sets.
     set.each_with_index do |st, i|
-      str1 = id + "set ##{i+1}"
+      str1 = id + "subset ##{i+1}"
       str2 = str1 + " #{tag.to_s}"
       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)
@@ -4530,9 +4841,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.
@@ -4540,7 +4851,8 @@ module OSut
       v << pt
       # Loop through each valid set; concatenate circumscribing vertices.
-      set.each_with_index do |st, i|
+      set.each do |st|
+        next if st.key?(:void) && st[:void]
         next unless same?(st[:ld][s], pt)
         next unless st.key?(tag)
@@ -4553,21 +4865,22 @@ module OSut
   end
   ##
-  # Generates arrays of rectangular polygon inserts within a larger polygon. If
-  # successful, each set inherits additional key:value pairs: namely :vtx
-  # (subset of polygon circumscribing vertices), and :vts (collection of
-  # indivudual polygon insert vertices). Valid leader line anchors (set key :ld)
-  # need to be generated prior to calling the method (see genAnchors, and
-  # genExtendedvertices).
-  #
-  # @param s [Set<OpenStudio::Point3d>] a larger polygon
-  # @param [Array<Hash>] set a collection of polygon insert instructions
-  # @option set [Set<OpenStudio::Point3d>] :box bounding box of each collection
-  # @option set [Hash] :ld a collection of polygon-specific leader line anchors
+  # Generates (1D or 2D) arrays of (smaller) rectangular collection of points,
+  # (e.g. arrays of polygon inserts) from subset parameters, within a (larger)
+  # set (e.g. parent polygon). If successful, each subset inherits additional
+  # key:value pairs: namely :vtx (collection of circumscribing vertices), and
+  # :vts (collection of individual insert vertices). Valid leader line anchors
+  # (set key :ld) need to be generated prior to calling the solution
+  # - see 'genAnchors'.
+  #
+  # @param s [Set<OpenStudio::Point3d>] a larger (parent) set of points
+  # @param [Array<Hash>] set a collection of (smaller) sequenced vertices
+  # @option set [Set<OpenStudio::Point3d>] :box bounding box of each subset
+  # @option set [Hash] :ld a collection of leader line anchors
   # @option set [Integer] :rows (1) number of rows of inserts
   # @option set [Integer] :cols (1) number of columns of inserts
-  # @option set [Numeric] :w0 (1.4) width of individual inserts (wrt cols) min 0.4
-  # @option set [Numeric] :d0 (1.4) depth of individual inserts (wrt rows) min 0.4
+  # @option set [Numeric] :w0 width of individual inserts (wrt cols) min 0.4
+  # @option set [Numeric] :d0 depth of individual inserts (wrt rows) min 0.4
   # @option set [Numeric] :dX (0) optional left/right X-axis buffer
   # @option set [Numeric] :dY (0) optional top/bottom Y-axis buffer
   #
@@ -4587,10 +4900,12 @@ module OSut
     # Validate/reset individual set collections.
     set.each_with_index do |st, i|
-      str1 = id + "set ##{i+1}"
+      str1 = id + "subset ##{i+1}"
+      next if st.key?(:void) && st[:void]
       return mismatch(str1, st, Hash, mth, DBG, a) unless st.respond_to?(:key?)
       return hashkey( str1, st, :box, mth, DBG, a) unless st.key?(:box)
       return hashkey( str1, st,  :ld, mth, DBG, a) unless st.key?(:ld)
+      return hashkey( str1, st, :out, mth, DBG, a) unless st.key?(:out)
       str2 = str1 + " anchor"
       ld = st[:ld]
@@ -4599,7 +4914,7 @@ module OSut
       return mismatch(str2, ld[s], cl, mth, DBG, a) unless ld[s].is_a?(cl)
       # Ensure each set bounding box is safely within larger polygon boundaries.
-      # TO DO: In line with related addSkylights "TO DO", expand method to
+      # @todo: In line with related addSkylights' @todo, expand solution to
       #        safely handle 'side' cutouts (i.e. no need for leader lines). In
       #        so doing, boxes could eventually align along surface edges.
       str3 = str1 + " box"
@@ -4659,9 +4974,10 @@ module OSut
       end
     end
-    # Flag conflicts between set bounding boxes. TO DO: ease up for ridges.
+    # Flag conflicts between set bounding boxes. @todo: ease up for ridges.
     set.each_with_index do |st, i|
       bx = st[:box]
+      next if st.key?(:void) && st[:void]
       set.each_with_index do |other, j|
         next if i == j
@@ -4673,37 +4989,18 @@ module OSut
       end
     end
-    # Loop through each 'valid' set (i.e. linking a valid leader line anchor),
-    # generate set vertex array based on user-provided specs. Reset BLC vertex
-    # coordinates once completed.
-    set.each_with_index do |st, i|
-      str = id + "set ##{i+1}"
-      dZ  = nil
-      t   = nil
-      bx  = st[:box]
-      if facingUp?(bx)
-        if xyz?(bx, :z)
-          dZ = 0
-        else
-          dZ = bx.first.z
-          bx = flatten(bx).to_a
-        end
-      else
-        t  = OpenStudio::Transformation.alignFace(bx)
-        bx = t.inverse * bx
-      end
-      o = getRealignedFace(bx)
-      next unless o[:set]
-      st[:out] = o
-      st[:bx ] = blc(o[:r] * (o[:t] * o[:set]))
+    t    = OpenStudio::Transformation.alignFace(pts)
+    rpts = t.inverse * pts
+    # Loop through each 'valid' subset (i.e. linking a valid leader line anchor),
+    # generate subset vertex array based on user-provided specs.
+    set.each_with_index do |st, i|
+      str = id + "subset ##{i+1}"
+      next if st.key?(:void) && st[:void]
+      o    = st[:out]
       vts  = {} # collection of individual (named) polygon insert vertices
       vtx  = [] # sequence of circumscribing polygon vertices
       bx   = o[:set]
       w    = width(bx)  # overall sandbox width
       d    = height(bx) # overall sandbox depth
@@ -4712,7 +5009,7 @@ module OSut
       cols = st[:cols]  # number of array columns
       rows = st[:rows]  # number of array rows
       x    = st[:w0  ]  # width of individual insert
-      y    = st[:d0  ]  # depth of indivual insert
+      y    = st[:d0  ]  # depth of individual insert
       gX   = 0          # gap between insert columns
       gY   = 0          # gap between insert rows
@@ -4790,15 +5087,7 @@ module OSut
           vec << OpenStudio::Point3d.new(xC + x, yC    , 0)
           # Store.
-          vtz = ulc(o[:r] * (o[:t] * vec))
-          if dZ
-            vz = OpenStudio::Point3dVector.new
-            vtz.each { |v| vz << OpenStudio::Point3d.new(v.x, v.y, v.z + dZ) }
-            vts[nom] = vz
-          else
-            vts[nom] = to_p3Dv(t * vtz)
-          end
+          vts[nom] = to_p3Dv(t * ulc(o[:r] * (o[:t] * vec)))
           # Add reverse vertices, circumscribing each insert.
           vec.reverse!
@@ -4814,18 +5103,8 @@ module OSut
         end
       end
-      vtx = o[:r] * (o[:t] * vtx)
-      if dZ
-        vz = OpenStudio::Point3dVector.new
-        vtx.each { |v| vz << OpenStudio::Point3d.new(v.x, v.y, v.z + dZ) }
-        vtx = vz
-      else
-        vtx = to_p3Dv(t * vtx)
-      end
       st[:vts] = vts
-      st[:vtx] = vtx
+      st[:vtx] = to_p3Dv(t * (o[:r] * (o[:t] * vtx)))
     end
     # Extended vertex sequence of the larger polygon.
@@ -4835,9 +5114,11 @@ module OSut
   ##
   # Returns an array of OpenStudio space surfaces or subsurfaces that match
   # criteria, e.g. exterior, north-east facing walls in hotel "lobby". Note that
-  # 'sides' rely on space coordinates (not absolute model coordinates). Also,
+  # 'sides' rely on space coordinates (not building or site coordinates). Also,
   # 'sides' are exclusive (not inclusive), e.g. walls strictly north-facing or
   # strictly east-facing would not be returned if 'sides' holds [:north, :east].
+  # No outside boundary condition filters if 'boundary' argument == "all". No
+  # surface type filters if 'type' argument == "all".
   #
   # @param spaces [Set<OpenStudio::Model::Space>] target spaces
   # @param boundary [#to_s] OpenStudio outside boundary condition
@@ -4845,7 +5126,7 @@ module OSut
   # @param sides [Set<Symbols>] direction keys, e.g. :north (see OSut::SIDZ)
   #
   # @return [Array<OpenStudio::Model::Surface>] surfaces (may be empty, no logs)
-  def facets(spaces = [], boundary = "Outdoors", type = "Wall", sides = [])
+  def facets(spaces = [], boundary = "all", type = "all", sides = [])
     spaces = spaces.is_a?(OpenStudio::Model::Space) ? [spaces] : spaces
     spaces = spaces.respond_to?(:to_a) ? spaces.to_a : []
     return [] if spaces.empty?
@@ -4859,8 +5140,8 @@ module OSut
     return [] if boundary.empty?
     return [] if type.empty?
-    # Filter sides. If sides is initially empty, return all surfaces of matching
-    # type and outside boundary condition.
+    # Filter sides. If 'sides' is initially empty, return all surfaces of
+    # matching type and outside boundary condition.
     unless sides.empty?
       sides = sides.select { |side| SIDZ.include?(side) }
       return [] if sides.empty?
@@ -4870,8 +5151,13 @@ module OSut
       return [] unless space.respond_to?(:setSpaceType)
       space.surfaces.each do |s|
-        next unless s.outsideBoundaryCondition.downcase == boundary
-        next unless s.surfaceType.downcase == type
+        unless boundary == "all"
+          next unless s.outsideBoundaryCondition.downcase == boundary
+        end
+        unless type == "all"
+          next unless s.surfaceType.downcase == type
+        end
         if sides.empty?
           faces << s
@@ -4891,13 +5177,15 @@ module OSut
     # SubSurfaces?
     spaces.each do |space|
-      break unless faces.empty?
       space.surfaces.each do |s|
-        next unless s.outsideBoundaryCondition.downcase == boundary
+        unless boundary == "all"
+          next unless s.outsideBoundaryCondition.downcase == boundary
+        end
         s.subSurfaces.each do |sub|
-          next unless sub.subSurfaceType.downcase == type
+          unless type == "all"
+            next unless sub.subSurfaceType.downcase == type
+          end
           if sides.empty?
             faces << sub
@@ -4948,7 +5236,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)
@@ -4999,7 +5287,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
@@ -5012,28 +5300,30 @@ module OSut
   # Returns outdoor-facing, space-related roof surfaces. These include
   # outdoor-facing roofs of each space per se, as well as any outdoor-facing
   # roof surface of unoccupied spaces immediately above (e.g. plenums, attics)
-  # overlapping any of the ceiling surfaces of each space.
+  # overlapping any of the ceiling surfaces of each space. It does not include
+  # surfaces labelled as 'RoofCeiling', which do not comply with ASHRAE 90.1 or
+  # NECB tilt criteria - see 'roof?'.
   #
   # @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")
+    rfs = facets(spaces, "Outdoors", "RoofCeiling")
+    rfs = rfs.select { |rf| roof?(rf) }
-    # Outdoor-facing roof surfaces of unoccupied plenums or attics above?
     spaces.each do |space|
-      # When multiple spaces are involved (e.g. plenums, attics), the target
+      # When unoccupied spaces are involved (e.g. plenums, attics), the target
       # space may not share the same local transformation as the space(s) above.
-      # Fetching local transformation.
+      # Fetching site transformation.
       t0 = transforms(space)
       next unless t0[:t]
@@ -5056,18 +5346,20 @@ module OSut
         ti = ti[:t]
-        # TO DO: recursive call for stacked spaces as atria (via AirBoundaries).
+        # @todo: recursive call for stacked spaces as atria (via AirBoundaries).
         facets(other, "Outdoors", "RoofCeiling").each do |ruf|
+          next unless roof?(ruf)
           rvi = ti * ruf.vertices
           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
   ##
@@ -5093,10 +5385,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.
@@ -5128,11 +5420,13 @@ module OSut
   # @option subs [#to_f] :r_buffer gap between sub/array and right corner
   # @option subs [#to_f] :l_buffer gap between sub/array and left corner
   # @param clear [Bool] whether to remove current sub surfaces
+  # @param bound [Bool] whether to add subs wrt surface's bounded box
+  # @param realign [Bool] whether to first realign bounded box
   # @param bfr [#to_f] safety buffer, to maintain near other edges
   #
   # @return [Bool] whether addition is successful
   # @return [false] if invalid input (see logs)
-  def addSubs(s = nil, subs = [], clear = false, bfr = 0.005)
+  def addSubs(s = nil, subs = [], clear = false, bound = false, realign = false, bfr = 0.005)
     mth = "OSut::#{__callee__}"
     v   = OpenStudio.openStudioVersion.split(".").join.to_i
     cl1 = OpenStudio::Model::Surface
@@ -5144,15 +5438,18 @@ module OSut
     # --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- #
     # Exit if mismatched or invalid argument classes.
-    return mismatch("surface",  s, cl2, mth, DBG, no) unless s.is_a?(cl1)
-    return mismatch("subs",  subs, cl3, mth, DBG, no) unless subs.is_a?(cl2)
+    sbs = subs.is_a?(cl3) ? [subs] : subs
+    sbs = sbs.respond_to?(:to_a) ? sbs.to_a : []
+    return mismatch("surface",  s, cl1, mth, DBG, no) unless s.is_a?(cl1)
+    return mismatch("subs",  subs, cl2, mth, DBG, no)     if sbs.empty?
     return empty("surface points",      mth, DBG, no)     if poly(s).empty?
-    # --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- #
-    # Clear existing sub surfaces if requested.
-    nom = s.nameString
-    mdl = s.model
+    subs = sbs
+    nom  = s.nameString
+    mdl  = s.model
+    # --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- #
+    # Purge existing sub surfaces?
     unless [true, false].include?(clear)
       log(WRN, "#{nom}: Keeping existing sub surfaces (#{mth})")
       clear = false
@@ -5161,9 +5458,30 @@ module OSut
     s.subSurfaces.map(&:remove) if clear
     # --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- #
-    # Ensure minimum safety buffer.
-    if bfr.respond_to?(:to_f)
-      bfr = bfr.to_f
+    # Add sub surfaces with respect to base surface's bounded box? This is
+    # often useful (in some cases necessary) with irregular or concave surfaces.
+    # If true, sub surface parameters (e.g. height, offset, centreline) no
+    # longer apply to the original surface 'bounding' box, but instead to its
+    # largest 'bounded' box. This can be combined with the 'realign' parameter.
+    unless [true, false].include?(bound)
+      log(WRN, "#{nom}: Ignoring bounded box (#{mth})")
+      bound = false
+    end
+    # --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- #
+    # Force re-alignment of base surface (or its 'bounded' box)? False by
+    # default (ideal for vertical/tilted walls & sloped roofs). If set to true
+    # for a narrow wall for instance, an array of sub surfaces will be added
+    # from bottom to top (rather from left to right).
+    unless [true, false].include?(realign)
+      log(WRN, "#{nom}: Ignoring realignment (#{mth})")
+      realign = false
+    end
+    # --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- #
+    # Ensure minimum safety buffer.
+    if bfr.respond_to?(:to_f)
+      bfr = bfr.to_f
       return negative("safety buffer", mth, ERR, no) if bfr.round(2) < 0
       msg = "Safety buffer < 5mm may generate invalid geometry (#{mth})"
@@ -5192,15 +5510,21 @@ module OSut
     s0  = poly(s, false, false, false, t, :ulc)
     s00 = nil
-    if facingUp?(s) || facingDown?(s) # TODO: redundant check?
-      s00 = getRealignedFace(s0)
-      return false unless s00[:set]
+    # Adapt sandbox if user selects to 'bound' and/or 'realign'.
+    if bound
+      box = boundedBox(s0)
-      s0 = s00[:set]
+      if realign
+        s00 = realignedFace(box, true)
+        return invalid("bound realignment", mth, 0, DBG, false) unless s00[:set]
+      end
+    elsif realign
+      s00 = realignedFace(s0, false)
+      return invalid("unbound realignment", mth, 0, DBG, false) unless s00[:set]
     end
-    max_x = width(s0)
-    max_y = height(s0)
+    max_x = s00 ? width( s00[:set]) :  width(s0)
+    max_y = s00 ? height(s00[:set]) : height(s0)
     mid_x = max_x / 2
     mid_y = max_y / 2
@@ -5219,7 +5543,7 @@ module OSut
       sub[:type      ] = trim(sub[:type])
       sub[:id        ] = trim(sub[:id])
       sub[:type      ] = type                   if sub[:type].empty?
-      sub[:id        ] = "OSut|#{nom}|#{index}" if sub[:id  ].empty?
+      sub[:id        ] = "OSut:#{nom}:#{index}" if sub[:id  ].empty?
       sub[:count     ] = 1 unless sub[:count     ].respond_to?(:to_i)
       sub[:multiplier] = 1 unless sub[:multiplier].respond_to?(:to_i)
       sub[:count     ] = sub[:count     ].to_i
@@ -5271,8 +5595,10 @@ module OSut
         next if key == :frame
         next if key == :assembly
-        ok = value.respond_to?(:to_f)
-        return mismatch(key, value, Float, mth, DBG, no) unless ok
+        unless value.respond_to?(:to_f)
+          return mismatch(key, value, Float, mth, DBG, no)
+        end
         next if key == :centreline
         negative(key, mth, WRN) if value < 0
@@ -5329,27 +5655,27 @@ module OSut
       # Log/reset "height" if beyond min/max.
       if sub.key?(:height)
         unless sub[:height].between?(glass - TOL2, max_height + TOL2)
-          sub[:height] = glass      if sub[:height] < glass
-          sub[:height] = max_height if sub[:height] > max_height
-          log(WRN, "Reset '#{id}' height to #{sub[:height]} m (#{mth})")
+          log(WRN, "Reset '#{id}' height #{sub[:height].round(3)}m (#{mth})")
+          sub[:height] = sub[:height].clamp(glass, max_height)
+          log(WRN, "Height '#{id}' reset to #{sub[:height].round(3)}m (#{mth})")
         end
       end
       # Log/reset "head" height if beyond min/max.
       if sub.key?(:head)
         unless sub[:head].between?(min_head - TOL2, max_head + TOL2)
-          sub[:head] = max_head if sub[:head] > max_head
-          sub[:head] = min_head if sub[:head] < min_head
-          log(WRN, "Reset '#{id}' head height to #{sub[:head]} m (#{mth})")
+          log(WRN, "Reset '#{id}' head #{sub[:head].round(3)}m (#{mth})")
+          sub[:head] = sub[:head].clamp(min_head, max_head)
+          log(WRN, "Head '#{id}' reset to #{sub[:head].round(3)}m (#{mth})")
         end
       end
       # Log/reset "sill" height if beyond min/max.
       if sub.key?(:sill)
         unless sub[:sill].between?(min_sill - TOL2, max_sill + TOL2)
-          sub[:sill] = max_sill if sub[:sill] > max_sill
-          sub[:sill] = min_sill if sub[:sill] < min_sill
-          log(WRN, "Reset '#{id}' sill height to #{sub[:sill]} m (#{mth})")
+          log(WRN, "Reset '#{id}' sill #{sub[:sill].round(3)}m (#{mth})")
+          sub[:sill] = sub[:sill].clamp(min_sill, max_sill)
+          log(WRN, "Sill '#{id}' reset to #{sub[:sill].round(3)}m (#{mth})")
         end
       end
@@ -5368,8 +5694,9 @@ module OSut
           log(ERR, "Skip: invalid '#{id}' head/sill combo (#{mth})")
           next
         else
+          log(WRN, "(Re)set '#{id}' sill #{sub[:sill].round(3)}m (#{mth})")
           sub[:sill] = sill
-          log(WRN, "(Re)set '#{id}' sill height to #{sub[:sill]} m (#{mth})")
+          log(WRN, "Sill '#{id}' (re)set to #{sub[:sill].round(3)}m (#{mth})")
         end
       end
@@ -5379,7 +5706,8 @@ module OSut
         height = sub[:head] - sub[:sill]
         if sub.key?(:height) && (sub[:height] - height).abs > TOL2
-          log(WRN, "(Re)set '#{id}' height to #{height} m (#{mth})")
+          log(WRN, "(Re)set '#{id}' height #{sub[:height].round(3)}m (#{mth})")
+          log(WRN, "Height '#{id}' (re)set to #{height.round(3)}m (#{mth})")
         end
         sub[:height] = height
@@ -5400,9 +5728,10 @@ module OSut
               log(ERR, "Skip: invalid '#{id}' head/height combo (#{mth})")
               next
             else
+              log(WRN, "(Re)set '#{id}' height #{sub[:height].round(3)}m (#{mth})")
               sub[:sill  ] = sill
               sub[:height] = height
-              log(WRN, "(Re)set '#{id}' height to #{sub[:height]} m (#{mth})")
+              log(WRN, "Height '#{id}' re(set) #{sub[:height].round(3)}m (#{mth})")
             end
           else
             sub[:sill] = sill
@@ -5428,9 +5757,10 @@ module OSut
               log(ERR, "Skip: invalid '#{id}' sill/height combo (#{mth})")
               next
             else
+              log(WRN, "(Re)set '#{id}' height #{sub[:height].round(3)}m (#{mth})")
               sub[:head  ] = head
               sub[:height] = height
-              log(WRN, "(Re)set '#{id}' height to #{sub[:height]} m (#{mth})")
+              log(WRN, "Height '#{id}' reset to #{sub[:height].round(3)}m (#{mth})")
             end
           else
             sub[:head] = head
@@ -5459,9 +5789,9 @@ module OSut
       # Log/reset "width" if beyond min/max.
       if sub.key?(:width)
         unless sub[:width].between?(glass - TOL2, max_width + TOL2)
-          sub[:width] = glass     if sub[:width] < glass
-          sub[:width] = max_width if sub[:width] > max_width
-          log(WRN, "Reset '#{id}' width to #{sub[:width]} m (#{mth})")
+          log(WRN, "Reset '#{id}' width #{sub[:width].round(3)}m (#{mth})")
+          sub[:width] = sub[:width].clamp(glass, max_width)
+          log(WRN, "Width '#{id}' reset to #{sub[:width].round(3)}m (#{mth})")
         end
       end
@@ -5471,7 +5801,7 @@ module OSut
         if sub[:count] < 1
           sub[:count] = 1
-          log(WRN, "Reset '#{id}' count to #{sub[:count]} (#{mth})")
+          log(WRN, "Reset '#{id}' count to min 1 (#{mth})")
         end
       else
         sub[:count] = 1
@@ -5482,16 +5812,18 @@ module OSut
       # Log/reset if left-sided buffer under min jamb position.
       if sub.key?(:l_buffer)
         if sub[:l_buffer] < min_ljamb - TOL
+          log(WRN, "Reset '#{id}' left buffer #{sub[:l_buffer].round(3)}m (#{mth})")
           sub[:l_buffer] = min_ljamb
-          log(WRN, "Reset '#{id}' left buffer to #{sub[:l_buffer]} m (#{mth})")
+          log(WRN, "Left buffer '#{id}' reset to #{sub[:l_buffer].round(3)}m (#{mth})")
         end
       end
       # Log/reset if right-sided buffer beyond max jamb position.
       if sub.key?(:r_buffer)
         if sub[:r_buffer] > max_rjamb - TOL
+          log(WRN, "Reset '#{id}' right buffer #{sub[:r_buffer].round(3)}m (#{mth})")
           sub[:r_buffer] = min_rjamb
-          log(WRN, "Reset '#{id}' right buffer to #{sub[:r_buffer]} m (#{mth})")
+          log(WRN, "Right buffer '#{id}' reset to #{sub[:r_buffer].round(3)}m (#{mth})")
         end
       end
@@ -5511,15 +5843,15 @@ module OSut
           sub[:multiplier] = 0
           sub[:height    ] = 0 if sub.key?(:height)
           sub[:width     ] = 0 if sub.key?(:width)
-          log(ERR, "Skip: '#{id}' ratio ~0 (#{mth})")
+          log(ERR, "Skip: ratio ~0 (#{mth})")
           next
         end
         # Log/reset if "ratio" beyond min/max?
         unless sub[:ratio].between?(min, max)
-          sub[:ratio] = min if sub[:ratio] < min
-          sub[:ratio] = max if sub[:ratio] > max
-          log(WRN, "Reset ratio (min/max) to #{sub[:ratio]} (#{mth})")
+          log(WRN, "Reset ratio #{sub[:ratio].round(3)} (#{mth})")
+          sub[:ratio] = sub[:ratio].clamp(min, max)
+          log(WRN, "Ratio reset to #{sub[:ratio].round(3)} (#{mth})")
         end
         # Log/reset "count" unless 1.
@@ -5536,7 +5868,7 @@ module OSut
         if sub.key?(:l_buffer)
           if sub.key?(:centreline)
-            log(WRN, "Skip #{id} left buffer (vs centreline) (#{mth})")
+            log(WRN, "Skip '#{id}' left buffer (vs centreline) (#{mth})")
           else
             x0     = sub[:l_buffer] - frame
             xf     = x0 + w
@@ -5544,7 +5876,7 @@ module OSut
           end
         elsif sub.key?(:r_buffer)
           if sub.key?(:centreline)
-            log(WRN, "Skip #{id} right buffer (vs centreline) (#{mth})")
+            log(WRN, "Skip '#{id}' right buffer (vs centreline) (#{mth})")
           else
             xf     = max_x - sub[:r_buffer] + frame
             x0     = xf - w
@@ -5559,13 +5891,14 @@ module OSut
           sub[:multiplier] = 0
           sub[:height    ] = 0 if sub.key?(:height)
           sub[:width     ] = 0 if sub.key?(:width)
-          log(ERR, "Skip: invalid (ratio) width/centreline (#{mth})")
+          log(ERR, "Skip '#{id}': invalid (ratio) width/centreline (#{mth})")
           next
         end
         if sub.key?(:width) && (sub[:width] - width).abs > TOL
+          log(WRN, "Reset '#{id}' width (ratio) #{sub[:width].round(2)}m (#{mth})")
           sub[:width] = width
-          log(WRN, "Reset width (ratio) to #{sub[:width]} (#{mth})")
+          log(WRN, "Width (ratio) '#{id}' reset to #{sub[:width].round(2)}m (#{mth})")
         end
         sub[:width] = width unless sub.key?(:width)
@@ -5583,12 +5916,13 @@ module OSut
         width  = sub[:width] + frames
         gap    = (max_x - n * width) / (n + 1)
         gap    = sub[:offset] - width if sub.key?(:offset)
-        gap    = 0                    if gap < bfr
+        gap    = 0                    if gap < buffer
         offset = gap + width
         if sub.key?(:offset) && (offset - sub[:offset]).abs > TOL
+          log(WRN, "Reset '#{id}' sub offset #{sub[:offset].round(2)}m (#{mth})")
           sub[:offset] = offset
-          log(WRN, "Reset sub offset to #{sub[:offset]} m (#{mth})")
+          log(WRN, "Sub offset (#{id}) reset to #{sub[:offset].round(2)}m (#{mth})")
         end
         sub[:offset] = offset unless sub.key?(:offset)
@@ -5600,7 +5934,7 @@ module OSut
         if sub.key?(:l_buffer)
           if sub.key?(:centreline)
-            log(WRN, "Skip #{id} left buffer (vs centreline) (#{mth})")
+            log(WRN, "Skip '#{id}' left buffer (vs centreline) (#{mth})")
           else
             x0     = sub[:l_buffer] - frame
             xf     = x0 + w
@@ -5608,7 +5942,7 @@ module OSut
           end
         elsif sub.key?(:r_buffer)
           if sub.key?(:centreline)
-            log(WRN, "Skip #{id} right buffer (vs centreline) (#{mth})")
+            log(WRN, "Skip '#{id}' right buffer (vs centreline) (#{mth})")
           else
             xf     = max_x - sub[:r_buffer] + frame
             x0     = xf - w
@@ -5617,7 +5951,7 @@ module OSut
         end
         # Too wide?
-        if x0 < bfr - TOL2 || xf > max_x - bfr - TOL2
+        if x0 < buffer - TOL2 || xf > max_x - buffer - TOL2
           sub[:ratio     ] = 0 if sub.key?(:ratio)
           sub[:count     ] = 0
           sub[:multiplier] = 0
@@ -5633,10 +5967,9 @@ module OSut
       # Generate sub(s).
       sub[:count].times do |i|
-        name = "#{id}|#{i}"
+        name = "#{id}:#{i}"
         fr   = 0
         fr   = sub[:frame].frameWidth if sub[:frame]
         vec  = OpenStudio::Point3dVector.new
         vec << OpenStudio::Point3d.new(pos,               sub[:head], 0)
         vec << OpenStudio::Point3d.new(pos,               sub[:sill], 0)
@@ -5647,34 +5980,41 @@ module OSut
         # Log/skip if conflict between individual sub and base surface.
         vc = vec
         vc = offset(vc, fr, 300) if fr > 0
-        ok = fits?(vc, s)
-        log(ERR, "Skip '#{name}': won't fit in '#{nom}' (#{mth})") unless ok
-        break                                                      unless ok
+        unless fits?(vc, s)
+          log(ERR, "Skip '#{name}': won't fit in '#{nom}' (#{mth})")
+          break
+        end
         # Log/skip if conflicts with existing subs (even if same array).
+        conflict = false
         s.subSurfaces.each do |sb|
           nome = sb.nameString
           fd   = sb.windowPropertyFrameAndDivider
-          fr   = 0                     if fd.empty?
-          fr   = fd.get.frameWidth unless fd.empty?
+          fr   = fd.empty? ? 0 : fd.get.frameWidth
           vk   = sb.vertices
           vk   = offset(vk, fr, 300) if fr > 0
-          oops = overlaps?(vc, vk)
-          log(ERR, "Skip '#{name}': overlaps '#{nome}' (#{mth})") if oops
-          ok = false                                              if oops
-          break                                                   if oops
+          if overlaps?(vc, vk)
+            log(ERR, "Skip '#{name}': overlaps '#{nome}' (#{mth})")
+            conflict = true
+            break
+          end
         end
-        break unless ok
+        break if conflict
         sb = OpenStudio::Model::SubSurface.new(vec, mdl)
         sb.setName(name)
         sb.setSubSurfaceType(sub[:type])
-        sb.setConstruction(sub[:assembly])               if sub[:assembly]
-        ok = sb.allowWindowPropertyFrameAndDivider
-        sb.setWindowPropertyFrameAndDivider(sub[:frame]) if sub[:frame] && ok
-        sb.setMultiplier(sub[:multiplier])               if sub[:multiplier] > 1
+        sb.setConstruction(sub[:assembly]) if sub[:assembly]
+        sb.setMultiplier(sub[:multiplier]) if sub[:multiplier] > 1
+        if sub[:frame] && sb.allowWindowPropertyFrameAndDivider
+          sb.setWindowPropertyFrameAndDivider(sub[:frame])
+        end
         sb.setSurface(s)
         # Reset "pos" if array.
@@ -5685,32 +6025,15 @@ module OSut
     true
   end
-  ##
-  # Validates whether surface is considered a sloped roof (outdoor-facing,
-  # 10% < tilt < 90%).
-  #
-  # @param s [OpenStudio::Model::Surface] a model surface
-  #
-  # @return [Bool] whether surface is a sloped roof
-  # @return [false] if invalid input (see logs)
-  def slopedRoof?(s = nil)
-    mth = "OSut::#{__callee__}"
-    cl  = OpenStudio::Model::Surface
-    return mismatch("surface", s, cl, mth, DBG, false) unless s.is_a?(cl)
-    return false if facingUp?(s)
-    return false if facingDown?(s)
-    true
-  end
   ##
   # Returns the "gross roof area" above selected conditioned, occupied spaces.
   # This includes all roof surfaces of indirectly-conditioned, unoccupied spaces
   # like plenums (if located above any of the selected spaces). This also
   # includes roof surfaces of unconditioned or unenclosed spaces like attics, if
   # vertically-overlapping any ceiling of occupied spaces below; attic roof
-  # sections above uninsulated soffits are excluded, for instance.
+  # sections above uninsulated soffits are excluded, for instance. It does not
+  # include surfaces labelled as 'RoofCeiling', which do not comply with ASHRAE
+  # 90.1 or NECB tilt criteria - see 'roof?'.
   def grossRoofArea(spaces = [])
     mth = "OSut::#{__callee__}"
     up  = OpenStudio::Point3d.new(0,0,1) - OpenStudio::Point3d.new(0,0,0)
@@ -5721,6 +6044,7 @@ module OSut
     spaces = spaces.respond_to?(:to_a) ? spaces.to_a : []
     spaces = spaces.select { |space| space.is_a?(OpenStudio::Model::Space) }
     spaces = spaces.select { |space| space.partofTotalFloorArea }
+    spaces = spaces.reject { |space| unconditioned?(space) }
     return invalid("spaces", mth, 1, DBG, 0) if spaces.empty?
     # The method is very similar to OpenStudio-Standards' :
@@ -5732,17 +6056,18 @@ module OSut
     #
     # ... yet differs with regards to attics with overhangs/soffits.
-    # Start with roof surfaces of occupied spaces.
+    # Start with roof surfaces of occupied, conditioned spaces.
     spaces.each do |space|
       facets(space, "Outdoors", "RoofCeiling").each do |roof|
         next if rfs.key?(roof)
+        next unless roof?(roof)
         rfs[roof] = {m2: roof.grossArea, m: space.multiplier}
       end
     end
     # Roof surfaces of unoccupied, conditioned spaces above (e.g. plenums)?
-    # TO DO: recursive call for stacked spaces as atria (via AirBoundaries).
+    # @todo: recursive call for stacked spaces as atria (via AirBoundaries).
     spaces.each do |space|
       facets(space, "Surface", "RoofCeiling").each do |ceiling|
         floor = ceiling.adjacentSurface
@@ -5757,6 +6082,7 @@ module OSut
         facets(other, "Outdoors", "RoofCeiling").each do |roof|
           next if rfs.key?(roof)
+          next unless roof?(roof)
           rfs[roof] = {m2: roof.grossArea, m: other.multiplier}
         end
@@ -5764,7 +6090,7 @@ module OSut
     end
     # Roof surfaces of unoccupied, unconditioned spaces above (e.g. attics)?
-    # TO DO: recursive call for stacked spaces as atria (via AirBoundaries).
+    # @todo: recursive call for stacked spaces as atria (via AirBoundaries).
     spaces.each do |space|
       # When taking overlaps into account, the target space may not share the
       # same local transformation as the space(s) above.
@@ -5792,6 +6118,8 @@ module OSut
         ti = ti[:t]
         facets(other, "Outdoors", "RoofCeiling").each do |roof|
+          next unless roof?(roof)
           rvi  = ti * roof.vertices
           cst  = cast(cv0, rvi, up)
           next if cst.empty?
@@ -5799,8 +6127,7 @@ module OSut
           # The overlap calculation fails for roof and ceiling surfaces with
           # previously-added leader lines.
           #
-          # TODO: revise approach for attics ONCE skylight wells have been added.
-          olap = nil
+          # @todo: revise approach for attics ONCE skylight wells have been added.
           olap = overlap(cst, rvi, false)
           next if olap.empty?
@@ -5823,30 +6150,31 @@ module OSut
   end
   ##
-  # Identifies horizontal ridges between 2x sloped roof surfaces (same space).
-  # If successful, the returned Array holds 'ridge' Hashes. Each Hash holds: an
+  # Identifies horizontal ridges along 2x sloped (roof?) surfaces (same space).
+  # The concept of 'sloped' is harmonized with OpenStudio's "alignZPrime". If
+  # successful, the returned Array holds 'ridge' Hashes. Each Hash holds: an
   # :edge (OpenStudio::Point3dVector), the edge :length (Numeric), and :roofs
-  # (Array of 2x linked roof surfaces). Each roof surface may be linked to more
-  # than one horizontal ridge.
+  # (Array of 2x linked surfaces). Each surface may be linked to more than one
+  # horizontal ridge.
   #
-  # @param roofs [Array<OpenStudio::Model::Surface>] target roof 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| slopedRoof?(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.
@@ -5861,19 +6189,19 @@ 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|
-            break if match
+          segments(ruf).each do |edg|
+            break    if match
             next unless same?(edge, edg) || same?(edge, edg.reverse)
             ridge[:roofs] << ruf
@@ -5887,49 +6215,180 @@ module OSut
     ridges
   end
+  ##
+  # Preselects ideal spaces to toplight, based on 'addSkylights' options and key
+  # building model geometry attributes. Can be called from within 'addSkylights'
+  # by setting :ration (opts key:value argument) to 'true' ('false' by default).
+  # Alternatively, the method can be called prior to 'addSkylights'. The set of
+  # filters stems from previous rounds of 'addSkylights' stress testing. It is
+  # intended as an option to prune away less ideal candidate spaces (irregular,
+  # smaller) in favour of (larger) candidates (notably with more suitable
+  # roof geometries). This is key when dealing with attic and plenums, where
+  # 'addSkylights' seeks to add skylight wells (relying on roof cut-outs and
+  # leader lines). Another check/outcome is whether to prioritize skylight
+  # allocation in already sidelit spaces - opts[:sidelit] may be reset to 'true'.
+  #
+  # @param spaces [Array<OpenStudio::Model::Space>] candidate(s) to toplight
+  # @param [Hash] opts requested skylight attributes (same as 'addSkylights')
+  # @option opts [#to_f] :size (1.22m) template skylight width/depth (min 0.4m)
+  #
+  # @return [Array<OpenStudio::Model::Space>] candidates (see logs if empty)
+  def toToplit(spaces = [], opts = {})
+    mth  = "OSut::#{__callee__}"
+    gap4 = 0.4  # minimum skylight 16" width/depth (excluding frame width)
+    w    = 1.22 # default 48" x 48" skylight base
+    w2   = w * w
+    # Validate skylight size, if provided.
+    if opts.key?(:size)
+      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
+      else
+        return mismatch("size", opts[:size], Numeric, mth, DBG, [])
+      end
+    end
+    # Accept single 'OpenStudio::Model::Space' (vs an array of spaces). Filter.
+    #
+    # Whether individual spaces are UNCONDITIONED (e.g. attics, unheated areas)
+    # or flagged as NOT being part of the total floor area (e.g. unoccupied
+    # plenums), should of course reflect actual design intentions. It's up to
+    # modellers to correctly flag such cases - can't safely guess in lieu of
+    # design/modelling team.
+    #
+    # A friendly reminder: 'addSkylights' should be called separately for
+    # strictly SEMIHEATED spaces vs REGRIGERATED spaces vs all other CONDITIONED
+    # spaces, as per 90.1 and NECB requirements.
+    if spaces.respond_to?(:spaceType) || spaces.respond_to?(:to_a)
+      spaces = spaces.respond_to?(:to_a) ? spaces.to_a : [spaces]
+      spaces = spaces.select { |sp| sp.respond_to?(:spaceType) }
+      spaces = spaces.select { |sp| sp.partofTotalFloorArea }
+      spaces = spaces.reject { |sp| unconditioned?(sp) }
+      spaces = spaces.reject { |sp| vestibule?(sp) }
+      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, []) if spaces.empty?
+    else
+      return mismatch("spaces", spaces, Array, mth, DBG, [])
+    end
+    # Unfenestrated spaces have no windows, glazed doors or skylights. By
+    # default, 'addSkylights' will prioritize unfenestrated spaces (over all
+    # existing sidelit ones) and maximize skylight sizes towards achieving the
+    # required skylight area target. This concentrates skylights for instance in
+    # typical (large) core spaces, vs (narrower) perimeter spaces. However, for
+    # less conventional spatial layouts, this default approach can produce less
+    # optimal skylight distributions. A balance is needed to prioritize large
+    # unfenestrated spaces when appropriate on one hand, while excluding smaller
+    # unfenestrated ones on the other. Here, exclusion is based on the average
+    # floor area of spaces to toplight.
+    fm2  = spaces.sum(&:floorArea)
+    afm2 = fm2 / spaces.size
+    unfen = spaces.reject { |sp| daylit?(sp) }.sort_by(&:floorArea).reverse
+    # Target larger unfenestrated spaces, if sufficient in area.
+    if unfen.empty?
+      opts[:sidelit] = true
+    else
+      if spaces.size > unfen.size
+        ufm2  = unfen.sum(&:floorArea)
+        u0fm2 = unfen.first.floorArea
+        if ufm2 > 0.33 * fm2 && u0fm2 > 3 * afm2
+          unfen  = unfen.reject { |sp| sp.floorArea > 0.25 * afm2 }
+          spaces = spaces.reject { |sp| unfen.include?(sp) }
+        else
+          opts[:sidelit] = true
+        end
+      end
+    end
+    espaces = {}
+    rooms   = []
+    toits   = []
+    # Gather roof surfaces - possibly those of attics or plenums above.
+    spaces.each do |sp|
+      roofs(sp).each do |rf|
+        espaces[sp] = {roofs: []} unless espaces.key?(sp)
+        espaces[sp][:roofs] << rf unless espaces[sp][:roofs].include?(rf)
+      end
+    end
+    # Priortize larger spaces.
+    espaces = espaces.sort_by { |espace, _| espace.floorArea }.reverse
+    # Prioritize larger roof surfaces.
+    espaces.each do |_, datum|
+      datum[:roofs] = datum[:roofs].sort_by(&:grossArea).reverse
+    end
+    # Single out largest roof in largest space, key when dealing with shared
+    # attics or plenum roofs.
+    espaces.each do |espace, datum|
+      rfs = datum[:roofs].reject { |ruf| toits.include?(ruf) }
+      next if rfs.empty?
+      toits << rfs.sort { |ruf| ruf.grossArea }.reverse.first
+      rooms << espace
+    end
+    log(INF, "No ideal toplit candidates (#{mth})") if rooms.empty?
+    rooms
+  end
   ##
   # Adds skylights to toplight selected OpenStudio (occupied, conditioned)
-  # spaces, based on requested skylight-to-roof (SRR%) options (max 10%). If the
-  # user selects 0% (0.0) as the :srr while keeping :clear as true, the method
-  # simply purges all pre-existing roof subsurfaces (whether glazed or not) of
-  # selected spaces, and exits while returning 0 (without logging an error or
-  # warning). Pre-toplit spaces are otherwise ignored. Boolean options :attic,
-  # :plenum, :sloped and :sidelit, further restrict candidate roof surfaces. If
-  # applicable, options :attic and :plenum add skylight wells. Option :patterns
-  # restricts preset skylight allocation strategies in order of preference; if
-  # left empty, all preset patterns are considered, also in order of preference
-  # (see examples).
+  # spaces, based on requested skylight area, or a skylight-to-roof ratio (SRR%).
+  # If the user selects 0m2 as the requested :area (or 0 as the requested :srr),
+  # while setting the option :clear as true, the method simply purges all
+  # pre-existing roof fenestrated subsurfaces of selected spaces, and exits while
+  # returning 0 (without logging an error or warning). Pre-existing skylight
+  # wells are not cleared however. Pre-toplit spaces are otherwise ignored.
+  # Boolean options :attic, :plenum, :sloped and :sidelit further restrict
+  # candidate spaces to toplight. If applicable, options :attic and :plenum add
+  # skylight wells. Option :patterns restricts preset skylight allocation
+  # layouts in order of preference; if left empty, all preset patterns are
+  # considered, also in order of preference (see examples).
   #
   # @param spaces [Array<OpenStudio::Model::Space>] space(s) to toplight
   # @param [Hash] opts requested skylight attributes
-  # @option opts [#to_f] :srr skylight-to-roof ratio (0.00, 0.10]
+  # @option opts [#to_f] :area overall skylight area
+  # @option opts [#to_f] :srr skylight-to-roof ratio (0.00, 0.90]
   # @option opts [#to_f] :size (1.22) template skylight width/depth (min 0.4m)
   # @option opts [#frameWidth] :frame (nil) OpenStudio Frame & Divider (optional)
   # @option opts [Bool] :clear (true) whether to first purge existing skylights
+  # @option opts [Bool] :ration (true) finer selection of candidates to toplight
   # @option opts [Bool] :sidelit (true) whether to consider sidelit spaces
   # @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)
-  # @example (a) consider 2D array of individual skylights, e.g. n(1.2m x 1.2m)
+  # @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
   #   opts[:patterns] = ["array", "strips"]
   #
-  # @return [Float] returns gross roof area if successful (see logs if 0 m2)
+  # @return [Float] returns gross roof area if successful (see logs if 0m2)
   def addSkyLights(spaces = [], opts = {})
     mth   = "OSut::#{__callee__}"
     clear = true
-    srr   = 0.0
+    srr   = nil
+    area  = nil
     frame = nil   # FrameAndDivider object
     f     = 0.0   # FrameAndDivider frame width
-    gap   = 0.1   # min 2" around well (2x), as well as max frame width
+    gap   = 0.1   # min 2" around well (2x == 4"), as well as max frame width
     gap2  = 0.2   # 2x gap
     gap4  = 0.4   # minimum skylight 16" width/depth (excluding frame width)
     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:
@@ -5994,7 +6453,7 @@ module OSut
     # to exclude portions of any roof surface: all plenum roof surfaces (in
     # addition to soffit surfaces) would need to be insulated). The method takes
     # such circumstances into account, which requires vertically casting of
-    # surfaces ontoothers, as well as overlap calculations. If successful, the
+    # surfaces onto others, as well as overlap calculations. If successful, the
     # method returns the "GROSS ROOF AREA" (in m2), based on the above rationale.
     #
     # --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- #
@@ -6014,7 +6473,7 @@ module OSut
     # instance, if the GROSS ROOF AREA were based on insulated ceiling surfaces,
     # there would be a topological disconnect between flat ceiling and sloped
     # skylights above. Should NECB users first 'project' (sloped) skylight rough
-    # openings onto flat ceilings when calculating %SRR? Without much needed
+    # openings onto flat ceilings when calculating SRR%? Without much needed
     # clarification, the (clearer) 90.1 rules equally apply here to NECB cases.
     # If skylight wells are indeed required, well wall edges are always vertical
@@ -6037,19 +6496,8 @@ module OSut
     mdl = spaces.first.model
-    # Exit if mismatched or invalid argument classes/keys.
+    # Exit if mismatched or invalid options.
     return mismatch("opts", opts, Hash, mth, DBG, 0) unless opts.is_a?(Hash)
-    return  hashkey( "srr", opts, :srr, mth, ERR, 0) unless opts.key?(:srr)
-    # Validate requested skylight-to-roof ratio.
-    if opts[:srr].respond_to?(:to_f)
-      srr = opts[:srr].to_f
-      log(WRN, "Resetting srr to 0% (#{mth})")  if srr < 0
-      log(WRN, "Resetting srr to 10% (#{mth})") if srr > 0.10
-      srr = srr.clamp(0.00, 0.10)
-    else
-      return mismatch("srr", opts[:srr], Numeric, mth, DBG, 0)
-    end
     # Validate Frame & Divider object, if provided.
     if opts.key?(:frame)
@@ -6057,10 +6505,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
@@ -6085,6 +6533,27 @@ module OSut
     wl  = w0 + gap
     wl2 = wl * wl
+    # Validate requested skylight-to-roof ratio (or overall area).
+    if opts.key?(:area)
+      if opts[:area].respond_to?(:to_f)
+        area = opts[:area].to_f
+        log(WRN, "Area reset to 0.0m2 (#{mth})") if area < 0
+      else
+        return mismatch("area", opts[:area], Numeric, mth, DBG, 0)
+      end
+    elsif opts.key?(:srr)
+      if opts[:srr].respond_to?(:to_f)
+        srr = opts[:srr].to_f
+        log(WRN, "SRR (#{srr.round(2)}) reset to 0% (#{mth})")  if srr < 0
+        log(WRN, "SRR (#{srr.round(2)}) reset to 90% (#{mth})") if srr > 0.90
+        srr = srr.clamp(0.00, 0.10)
+      else
+        return mismatch("srr", opts[:srr], Numeric, mth, DBG, 0)
+      end
+    else
+      return hashkey("area", opts, :area, mth, ERR, 0)
+    end
     # Validate purge request, if provided.
     if opts.key?(:clear)
       clear = opts[:clear]
@@ -6095,35 +6564,97 @@ module OSut
       end
     end
-    getRoofs(spaces).each { |s| s.subSurfaces.map(&:remove) } if clear
+    # Purge if requested.
+    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 srr < TOL
+    return 0 if area && area.round(2) == 0
+    return 0 if srr  &&  srr.round(2) == 0
+    m2  = 0 # total existing skylight rough opening area
+    rm2 = grossRoofArea(spaces) # excludes e.g. overhangs
+    # Tally existing skylight rough opening areas.
+    spaces.each do |space|
+      m = space.multiplier
+      facets(space, "Outdoors", "RoofCeiling").each do |roof|
+        roof.subSurfaces.each do |sub|
+          next unless fenestration?(sub)
+          id  = sub.nameString
+          xm2 = sub.grossArea
+          if sub.allowWindowPropertyFrameAndDivider
+            unless sub.windowPropertyFrameAndDivider.empty?
+              fw   = sub.windowPropertyFrameAndDivider.get.frameWidth
+              vec  = offset(sub.vertices, fw, 300)
+              aire = OpenStudio.getArea(vec)
+              if aire.empty?
+                log(ERR, "Skipping '#{id}': invalid Frame&Divider (#{mth})")
+              else
+                xm2 = aire.get
+              end
+            end
+          end
+          m2 += xm2 * sub.multiplier * m
+        end
+      end
+    end
+    # Required skylight area to add.
+    sm2 = area ? area : rm2 * srr - m2
+    # Warn/skip if existing skylights exceed or ~roughly match targets.
+    if sm2.round(2) < w02.round(2)
+      if m2 > 0
+        log(INF, "Skipping: existing skylight area > request (#{mth})")
+        return rm2
+      else
+        log(INF, "Requested skylight area < min size (#{mth})")
+      end
+    elsif 0.9 * rm2.round(2) < sm2.round(2)
+      log(INF, "Skipping: requested skylight area > 90% of GRA (#{mth})")
+      return rm2
+    end
+    opts[:ration] = true unless opts.key?(:ration)
+    # By default, seek ideal candidate spaces/roofs. Bail out if unsuccessful.
+    unless opts[:ration] == false
+      spaces = toToplit(spaces, opts)
+      return rm2 if spaces.empty?
+    end
     # --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- #
     # The method seeks to insert a skylight array within the largest rectangular
     # 'bounded box' that neatly 'fits' within a given roof surface. This equally
     # applies to any vertically-cast overlap between roof and plenum (or attic)
     # floor, which in turn generates skylight wells. Skylight arrays are
-    # inserted from left/right + top/bottom (as illustrated below), once a roof
-    # (or cast 3D overlap) is 'aligned' in 2D (possibly also 'realigned').
+    # inserted from left-to-right & top-to-bottom (as illustrated below), once a
+    # roof (or cast 3D overlap) is 'aligned' in 2D.
     #
     # Depending on geometric complexity (e.g. building/roof concavity,
     # triangulation), the total area of bounded boxes may be significantly less
     # than the calculated "GROSS ROOF AREA", which can make it challenging to
-    # attain the desired %SRR. If :patterns are left unaltered, the method will
-    # select patterns that maximize the likelihood of attaining the requested
-    # %SRR, to the detriment of spatial distribution of daylighting.
+    # attain the requested skylight area. If :patterns are left unaltered, the
+    # method will select those that maximize the likelihood of attaining the
+    # requested target, to the detriment of spatial daylighting distribution.
     #
-    # The default skylight module size is 1.2m x 1.2m (4' x 4'), which be
-    # overridden by the user, e.g. 2.4m x 2.4m (8' x 8').
+    # The default skylight module size is 1.22m x 1.22m (4' x 4'), which can be
+    # overridden by the user, e.g. 2.44m x 2.44m (8' x 8'). However, skylight
+    # sizes usually end up either contracted or inflated to exactly meet a
+    # request skylight area or SRR%,
     #
     # Preset skylight allocation patterns (in order of precedence):
+    #
     #    1. "array"
     #   _____________________
     #  |   _      _      _   |  - ?x columns ("cols") >= ?x rows (min 2x2)
-    #  |  |_|    |_|    |_|  |  - SRR ~5% (1.2m x 1.2m), as illustrated
-    #  |                     |  - SRR ~19% (2.4m x 2.4m)
+    #  |  |_|    |_|    |_|  |  - SRR ~5% (1.22m x 1.22m), as illustrated
+    #  |                     |  - SRR ~19% (2.44m x 2.44m)
     #  |   _      _      _   |  - +suitable for wide spaces (storage, retail)
     #  |  |_|    |_|    |_|  |  - ~1.4x height + skylight width 'ideal' rule
     #  |_____________________|  - better daylight distribution, many wells
@@ -6132,21 +6663,21 @@ module OSut
     #   _____________________
     #  |   _      _      _   |  - ?x columns (min 2), 1x row
     #  |  | |    | |    | |  |  - ~doubles %SRR ...
-    #  |  | |    | |    | |  |  - SRR ~10% (1.2m x ?1.2m), as illustrated
-    #  |  | |    | |    | |  |  - SRR ~19% (2.4m x ?1.2m)
+    #  |  | |    | |    | |  |  - SRR ~10% (1.22m x ?1.22m), as illustrated
+    #  |  | |    | |    | |  |  - SRR ~19% (2.44m x ?1.22m)
     #  |  |_|    |_|    |_|  |  - ~roof monitor layout
     #  |_____________________|  - fewer wells
     #
     #    3. "strip"
     #    ____________________
     #   |                    |  - 1x column, 1x row (min 1x)
-    #   |   ______________   |  - SRR ~11% (1.2m x ?1.2m)
-    #   |  | ............ |  |  - SRR ~22% (2.4m x ?1.2m), as illustrated
+    #   |   ______________   |  - SRR ~11% (1.22m x ?1.22m)
+    #   |  | ............ |  |  - SRR ~22% (2.44m x ?1.22m), as illustrated
     #   |  |______________|  |  - +suitable for elongated bounded boxes
     #   |                    |  - 1x well
     #   |____________________|
     #
-    #   TO-DO: Support strips/strip patterns along ridge of paired roof surfaces.
+    # @todo: Support strips/strip patterns along ridge of paired roof surfaces.
     layouts  = ["array", "strips", "strip"]
     patterns = []
@@ -6174,27 +6705,26 @@ module OSut
     #   - large roof surface areas (e.g. retail, classrooms ... not corridors)
     #   - not sidelit (favours core spaces)
     #   - having flat roofs (avoids sloped roofs)
-    #   - not under plenums, nor attics (avoids wells)
+    #   - neither under plenums, nor attics (avoids wells)
     #
     # This ideal (albeit stringent) set of conditions is "combo a".
     #
-    # If required %SRR has not yet been achieved, the method decrementally drops
-    # selection criteria and starts over, e.g.:
+    # If the requested skylight area has not yet been achieved (after initially
+    # applying "combo a"), the method decrementally drops selection criteria and
+    # starts over, e.g.:
     #   - then considers sidelit spaces
     #   - then considers sloped roofs
     #   - then considers skylight wells
     #
     # A maximum number of skylights are allocated to roof surfaces matching a
-    # given combo. Priority is always given to larger roof areas. If
-    # unsuccessful in meeting the required %SRR target, a single criterion is
-    # then dropped (e.g. b, then c, etc.), and the allocation process is
-    # relaunched. An error message is logged if the %SRR isn't ultimately met.
+    # given combo, all the while giving priority to larger roof areas. An error
+    # message is logged if the target isn't ultimately achieved.
     #
-    # Through filters, users may restrict candidate roof surfaces:
+    # Through filters, users may in advance restrict candidate roof surfaces:
     #   b. above occupied sidelit spaces ('false' restricts to core spaces)
     #   c. that are sloped ('false' restricts to flat roofs)
-    #   d. above indirectly conditioned spaces (e.g. plenums, uninsulated wells)
-    #   e. above unconditioned spaces (e.g. attics, insulated wells)
+    #   d. above INDIRECTLY CONDITIONED spaces (e.g. plenums, uninsulated wells)
+    #   e. above UNCONDITIONED spaces (e.g. attics, insulated wells)
     filters = ["a", "b", "bc", "bcd", "bcde"]
     # Prune filters, based on user-selected options.
@@ -6203,18 +6733,18 @@ 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 reduced (after space/roof processing),
-    # depending on geometry, e.g.:
+    # Remaining filters may be further pruned automatically after space/roof
+    # processing, depending on geometry, e.g.:
     #  - if there are no sidelit spaces: filter "b" will be pruned away
     #  - if there are no sloped roofs  : filter "c" will be pruned away
     #  - if no plenums are identified  : filter "d" will be pruned away
@@ -6228,12 +6758,10 @@ module OSut
     attics   = {} # unoccupied UNCONDITIONED spaces above rooms
     ceilings = {} # of occupied CONDITIONED space (if plenums/attics)
-    # Select candidate 'rooms' to toplit - excludes plenums/attics.
+    # Candidate 'rooms' to toplit - excludes plenums/attics.
     spaces.each do |space|
-      next if unconditioned?(space)          # e.g. attic
-      next unless space.partofTotalFloorArea # occupied (not plenum)
+      id = space.nameString
-      # Already toplit?
       if daylit?(space, false, true, false)
         log(WRN, "#{id} is already toplit, skipping (#{mth})")
         next
@@ -6241,30 +6769,40 @@ module OSut
       # When unoccupied spaces are involved (e.g. plenums, attics), the occupied
       # space (to toplight) may not share the same local transformation as its
-      # unoccupied space(s) above. Fetching local transformation.
-      h  = 0
+      # unoccupied space(s) above. Fetching site transformation.
       t0 = transforms(space)
       next unless t0[:t]
-      toitures = facets(space, "Outdoors", "RoofCeiling")
-      plafonds = facets(space, "Surface", "RoofCeiling")
+      # Calculate space height.
+      hMIN  = 10000
+      hMAX  = 0
+      surfs = facets(space)
+      surfs.each { |surf| hMAX = [hMAX, surf.vertices.max_by(&:z).z].max }
+      surfs.each { |surf| hMIN = [hMIN, surf.vertices.min_by(&:z).z].min }
+      h = hMAX - hMIN
-      toitures.each { |surf| h = [h, surf.vertices.max_by(&:z).z].max }
-      plafonds.each { |surf| h = [h, surf.vertices.max_by(&:z).z].max }
+      unless h > 0
+        log(ERR, "#{id} height? #{hMIN.round(2)} vs #{hMAX.round(2)} (#{mth})")
+        next
+      end
       rooms[space]           = {}
-      rooms[space][:t      ] = t0[:t]
+      rooms[space][:t0     ] = t0[:t]
       rooms[space][:m      ] = space.multiplier
       rooms[space][:h      ] = h
-      rooms[space][:roofs  ] = toitures
+      rooms[space][:roofs  ] = facets(space, "Outdoors", "RoofCeiling")
       rooms[space][:sidelit] = daylit?(space, true, false, false)
       # Fetch and process room-specific outdoor-facing roof surfaces, the most
-      # basic 'set' to track:
-      #   - no skylight wells
+      # basic 'set' to track, e.g.:
+      #   - no skylight wells (i.e. no leader lines)
       #   - 1x skylight array per roof surface
-      #   - no need to preprocess space transformation
+      #   - no need to consider site transformation
       rooms[space][:roofs].each do |roof|
+        next unless roof?(roof)
         box = boundedBox(roof)
         next if box.empty?
@@ -6274,133 +6812,112 @@ module OSut
         bm2 = bm2.get
         next if bm2.round(2) < w02.round(2)
-        # Track if bounded box is significantly smaller than roof.
+        width = alignedWidth(box, true)
+        depth = alignedHeight(box, true)
+        next if width < wl * 3
+        next if depth < wl
+        # A set is 'tight' if the area of its bounded box is significantly
+        # smaller than that of its roof. A set is 'thin' if the depth of its
+        # bounded box is (too) narrow. If either is true, some geometry rules
+        # may be relaxed to maximize allocated skylight area. Neither apply to
+        # cases with skylight wells.
         tight = bm2 < roof.grossArea / 2 ? true : false
+        thin  = depth.round(2) < (1.5 * wl).round(2) ? true : false
         set           = {}
         set[:box    ] = box
         set[:bm2    ] = bm2
         set[:tight  ] = tight
+        set[:thin   ] = thin
         set[:roof   ] = roof
         set[:space  ] = space
+        set[:m      ] = space.multiplier
         set[:sidelit] = rooms[space][:sidelit]
-        set[:t      ] = rooms[space][:t      ]
-        set[:sloped ] = slopedRoof?(roof)
+        set[:t0     ] = rooms[space][:t0]
+        set[:t      ] = OpenStudio::Transformation.alignFace(roof.vertices)
         sets << set
       end
     end
     # Process outdoor-facing roof surfaces of plenums and attics above.
     rooms.each do |space, room|
-      t0    = room[:t]
-      toits = getRoofs(space)
-      rufs  = room.key?(:roofs) ? toits - room[:roofs] : toits
-      next if rufs.empty?
+      t0   = room[:t0]
+      rufs = roofs(space) - room[:roofs]
-      # Process room ceilings, as 1x or more are overlapping roofs above. Fetch
-      # vertically-cast overlaps.
       rufs.each do |ruf|
+        next unless roof?(ruf)
         espace = ruf.space
         next if espace.empty?
         espace = espace.get
         next if espace.partofTotalFloorArea
-        m  = espace.multiplier
-        ti = transforms(espace)
-        next unless ti[:t]
+        m = espace.multiplier
-        ti  = ti[:t]
-        vtx = ruf.vertices
-        # Ensure BLC vertex sequence.
-        if facingUp?(vtx)
-          vtx = ti * vtx
-          if xyz?(vtx, :z)
-            vtx = blc(vtx)
-          else
-            dZ  = vtx.first.z
-            vtz = blc(flatten(vtx)).to_a
-            vtx = []
-            vtz.each { |v| vtx << OpenStudio::Point3d.new(v.x, v.y, v.z + dZ) }
-          end
-          ruf.setVertices(ti.inverse * vtx)
-        else
-          tr  = OpenStudio::Transformation.alignFace(vtx)
-          vtx = blc(tr.inverse * vtx)
-          ruf.setVertices(tr * vtx)
+        if m != space.multiplier
+          log(ERR, "Skipping #{ruf.nameString} (multiplier mismatch) (#{mth})")
+          next
         end
-        ri = ti * ruf.vertices
-        facets(space, "Surface", "RoofCeiling").each do |tile|
-          vtx = tile.vertices
-          # Ensure BLC vertex sequence.
-          if facingUp?(vtx)
-            vtx = t0 * vtx
-            if xyz?(vtx, :z)
-              vtx = blc(vtx)
-            else
-              dZ  = vtx.first.z
-              vtz = blc(flatten(vtx)).to_a
-              vtx = []
-              vtz.each { |v| vtx << OpenStudio::Point3d.new(v.x, v.y, v.z + dZ) }
-            end
-            vtx = t0.inverse * vtx
-          else
-            tr  = OpenStudio::Transformation.alignFace(vtx)
-            vtx = blc(tr.inverse * vtx)
-            vtx = tr * vtx
-          end
+        ti = transforms(espace)
+        next unless ti[:t]
-          tile.setVertices(vtx)
+        ti   = ti[:t]
+        rpts = ti * ruf.vertices
-          ci0 = cast(t0 * tile.vertices, ri, ray)
+        # Process occupied room ceilings, as 1x or more are overlapping roof
+        # surfaces above. Vertically cast, then fetch overlap.
+        facets(space, "Surface", "RoofCeiling").each do |tile|
+          tpts = t0 * tile.vertices
+          ci0  = cast(tpts, rpts, ray)
           next if ci0.empty?
-          olap = overlap(ri, ci0, false)
+          olap = overlap(rpts, ci0)
           next if olap.empty?
+          om2 = OpenStudio.getArea(olap)
+          next if om2.empty?
+          om2 = om2.get
+          next if om2.round(2) < w02.round(2)
           box = boundedBox(olap)
           next if box.empty?
           # Adding skylight wells (plenums/attics) is contingent to safely
-          # linking new base roof 'inserts' through leader lines. Currently,
-          # this requires an offset from main roof surface edges.
+          # linking new base roof 'inserts' (as well as new ceiling ones)
+          # through 'leader lines'. This requires an offset to ensure no
+          # conflicts with roof or (ceiling) tile edges.
           #
-          # TO DO: expand the method to factor in cases where simple 'side'
+          # @todo: Expand the method to factor in cases where simple 'side'
           #        cutouts can be supported (no need for leader lines), e.g.
           #        skylight strips along roof ridges.
           box = offset(box, -gap, 300)
-          box = poly(box, false, false, false, false, :blc)
           next if box.empty?
           bm2 = OpenStudio.getArea(box)
           next if bm2.empty?
           bm2 = bm2.get
-          next if bm2.round(2) < w02.round(2)
+          next if bm2.round(2) < wl2.round(2)
-          # Vertically-cast box onto ceiling below.
-          cbox = cast(box, t0 * tile.vertices, ray)
+          width = alignedWidth(box, true)
+          depth = alignedHeight(box, true)
+          next if width < wl * 3
+          next if depth < wl * 2
+          # Vertically cast box onto tile below.
+          cbox = cast(box, tpts, ray)
           next if cbox.empty?
           cm2 = OpenStudio.getArea(cbox)
           next if cm2.empty?
-          cm2 = cm2.get
-          # Track if bounded boxes are significantly smaller than either roof
-          # or ceiling.
-          tight = bm2 < ruf.grossArea  / 2 ? true : false
-          tight = cm2 < tile.grossArea / 2 ? true : tight
+          cm2  = cm2.get
+          box  = ti.inverse * box
+          cbox = t0.inverse * cbox
           unless ceilings.key?(tile)
             floor = tile.adjacentSurface
@@ -6412,10 +6929,6 @@ module OSut
             floor = floor.get
-            # Ensure BLC vertex sequence.
-            vtx = t0 * vtx
-            floor.setVertices(ti.inverse * vtx.reverse)
             if floor.space.empty?
               log(ERR, "#{floor.nameString} space? (#{mth})")
               next
@@ -6428,32 +6941,40 @@ module OSut
               next
             end
-            ceilings[tile]         = {}
-            ceilings[tile][:roofs] = []
-            ceilings[tile][:space] = space
-            ceilings[tile][:floor] = floor
+            ceilings[tile]          = {}
+            ceilings[tile][:roofs ] = []
+            ceilings[tile][:space ] = space
+            ceilings[tile][:floor ] = floor
           end
           ceilings[tile][:roofs] << ruf
-          # More detailed skylight set entries with suspended ceilings.
+          # Skylight set key:values are more detailed with suspended ceilings.
+          # The overlap (:olap) remains in 'transformed' site coordinates (with
+          # regards to the roof). The :box polygon reverts to attic/plenum space
+          # coordinates, while the :cbox polygon is reset with regards to the
+          # occupied space coordinates.
           set           = {}
           set[:olap   ] = olap
           set[:box    ] = box
           set[:cbox   ] = cbox
+          set[:om2    ] = om2
           set[:bm2    ] = bm2
           set[:cm2    ] = cm2
-          set[:tight  ] = tight
+          set[:tight  ] = false
+          set[:thin   ] = false
           set[:roof   ] = ruf
           set[:space  ] = space
+          set[:m      ] = space.multiplier
           set[:clng   ] = tile
-          set[:t      ] = t0
+          set[:t0     ] = t0
+          set[:ti     ] = ti
+          set[:t      ] = OpenStudio::Transformation.alignFace(ruf.vertices)
           set[:sidelit] = room[:sidelit]
-          set[:sloped ] = slopedRoof?(ruf)
           if unconditioned?(espace) # e.g. attic
             unless attics.key?(espace)
-              attics[espace] = {t: ti, m: m, bm2: 0, roofs: []}
+              attics[espace] = {ti: ti, m: m, bm2: 0, roofs: []}
             end
             attics[espace][:bm2  ] += bm2
@@ -6464,7 +6985,7 @@ module OSut
             ceilings[tile][:attic] = espace
           else # e.g. plenum
             unless plenums.key?(espace)
-              plenums[espace] = {t: ti, m: m, bm2: 0, roofs: []}
+              plenums[espace] = {ti: ti, m: m, bm2: 0, roofs: []}
             end
             plenums[espace][:bm2  ] += bm2
@@ -6481,21 +7002,20 @@ module OSut
       end
     end
-    # Ensure uniqueness of plenum roofs, and set GROSS ROOF AREA.
+    # Ensure uniqueness of plenum roofs.
     attics.values.each do |attic|
       attic[:roofs ].uniq!
-      attic[:ridges] = getHorizontalRidges(attic[:roofs]) # TO-DO
+      attic[:ridges] = horizontalRidges(attic[:roofs]) # @todo
     end
     plenums.values.each do |plenum|
       plenum[:roofs ].uniq!
-      # plenum[:m2    ] = plenum[:roofs].sum(&:grossArea)
-      plenum[:ridges] = getHorizontalRidges(plenum[:roofs]) # TO-DO
+      plenum[:ridges] = horizontalRidges(plenum[:roofs]) # @todo
     end
-    # Regardless of the selected skylight arrangement pattern, the current
-    # solution may only consider attic/plenum sets that can be successfully
-    # linked to leader line anchors, for both roof and ceiling surfaces.
+    # Regardless of the selected skylight arrangement pattern, the solution only
+    # considers attic/plenum sets that can be successfully linked to leader line
+    # anchors, for both roof and ceiling surfaces. First, attic/plenum roofs.
     [attics, plenums].each do |greniers|
       k = greniers == attics ? :attic : :plenum
@@ -6512,7 +7032,8 @@ module OSut
           sts = sts.select { |st| st[:roof] == roof }
           next if sts.empty?
-          sts = sts.sort_by { |st| st[:bm2] }
+          sts = sts.sort_by { |st| st[:bm2] }.reverse
           genAnchors(roof, sts, :box)
         end
       end
@@ -6527,7 +7048,7 @@ module OSut
       next unless ceiling.key?(k)
       space = ceiling[:space]
-      spce  = ceiling[k     ]
+      spce  = ceiling[k]
       next unless ceiling.key?(:roofs)
       next unless rooms.key?(space)
@@ -6553,108 +7074,72 @@ module OSut
       next if stz.empty?
+      stz = stz.sort_by { |st| st[:cm2] }.reverse
       genAnchors(tile, stz, :cbox)
     end
     # Delete voided sets.
     sets.reject! { |set| set.key?(:void) }
-    m2  = 0 # existing skylight rough opening area
-    rm2 = grossRoofArea(spaces)
-    # Tally existing skylight rough opening areas (%SRR calculations).
-    rooms.values.each do |room|
-      m = room[:m]
-      room[:roofs].each do |roof|
-        roof.subSurfaces.each do |sub|
-          next unless fenestration?(sub)
-          id  = sub.nameString
-          xm2 = sub.grossArea
-          if sub.allowWindowPropertyFrameAndDivider
-            unless sub.windowPropertyFrameAndDivider.empty?
-              fw   = sub.windowPropertyFrameAndDivider.get.frameWidth
-              vec  = offset(sub.vertices, fw, 300)
-              aire = OpenStudio.getArea(vec)
-              if aire.empty?
-                log(ERR, "Skipping '#{id}': invalid Frame&Divider (#{mth})")
-              else
-                xm2 = aire.get
-              end
-            end
-          end
-          m2 += xm2 * sub.multiplier * m
-        end
-      end
-    end
-    # Required skylight area to add.
-    sm2 = rm2 * srr - m2
+    return empty("sets", mth, WRN, rm2) if sets.empty?
-    # Skip if existing skylights exceed or ~roughly match requested %SRR.
-    if sm2.round(2) < w02.round(2)
-      log(INF, "Skipping: existing srr > requested srr (#{mth})")
-      return 0
-    end
+    # Sort sets, from largest to smallest bounded box area.
+    sets = sets.sort_by { |st| st[:bm2] * st[:m] }.reverse
-    # Any sidelit/sloped roofs being targeted?
-    #
-    # TODO: enable double-ridged, sloped roofs have double-sloped
-    #       skylights/wells (patterns "strip"/"strips").
+    # Any sidelit and/or sloped roofs being targeted?
+    # @todo: enable double-ridged, sloped roofs have double-sloped
+    #        skylights/wells (patterns "strip"/"strips").
     sidelit = sets.any? { |set| set[:sidelit] }
     sloped  = sets.any? { |set| set[:sloped ] }
+    # Average sandbox area + revised 'working' SRR%.
+    sbm2 = sets.map { |set| set[:bm2] }.reduce(:+)
+    avm2 = sbm2 / sets.size
+    srr2 = sm2 / sets.size / avm2
     # Precalculate skylight rows + cols, for each selected pattern. In the case
     # of 'cols x rows' arrays of skylights, the method initially overshoots
-    # with regards to ideal skylight placement, e.g.:
+    # with regards to 'ideal' skylight placement, e.g.:
     #
     #   aceee.org/files/proceedings/2004/data/papers/SS04_Panel3_Paper18.pdf
     #
-    # ... yet skylight areas are subsequently contracted to strictly meet SRR%.
+    # Skylight areas are subsequently contracted to strictly meet the target.
     sets.each_with_index do |set, i|
-      id     = "set #{i+1}"
-      well   = set.key?(:clng)
-      space  = set[:space]
+      thin   = set[:thin ]
       tight  = set[:tight]
       factor = tight ? 1.75 : 1.25
+      well   = set.key?(:clng)
+      space  = set[:space]
       room   = rooms[space]
       h      = room[:h]
-      t      = OpenStudio::Transformation.alignFace(set[:box])
-      abox   = poly(set[:box], false, false, false, t, :ulc)
-      obox   = getRealignedFace(abox)
-      next unless obox[:set]
-      width = width(obox[:set])
-      depth = height(obox[:set])
-      area  = width * depth
-      skym2 = srr * area
+      width  = alignedWidth( set[:box], true)
+      depth  = alignedHeight(set[:box], true)
+      barea  = set.key?(:om2) ? set[:om2] : set[:bm2]
+      rtio   = barea / avm2
+      skym2  = srr2 * barea * rtio
-      # Flag sets if too narrow/shallow to hold a single skylight.
+      # Flag set if too narrow/shallow to hold a single skylight.
       if well
         if width.round(2) < wl.round(2)
-          log(ERR, "#{id}: Too narrow")
+          log(WRN, "set #{i+1} well: Too narrow (#{mth})")
           set[:void] = true
           next
         end
         if depth.round(2) < wl.round(2)
-          log(ERR, "#{id}: Too shallow")
+          log(WRN, "set #{i+1} well: Too shallow (#{mth})")
           set[:void] = true
           next
         end
       else
         if width.round(2) < w0.round(2)
-          log(ERR, "#{id}: Too narrow")
+          log(WRN, "set #{i+1}: Too narrow (#{mth})")
           set[:void] = true
           next
         end
         if depth.round(2) < w0.round(2)
-          log(ERR, "#{id}: Too shallow")
+          log(WRN, "set #{i+1}: Too shallow (#{mth})")
           set[:void] = true
           next
         end
@@ -6667,8 +7152,8 @@ module OSut
         rows = 1
         wx   = w0
         wy   = w0
-        wxl  = wl
-        wyl  = wl
+        wxl  = well ? wl : nil
+        wyl  = well ? wl : nil
         dX   = nil
         dY   = nil
@@ -6676,31 +7161,26 @@ module OSut
         when "array" # min 2x cols x min 2x rows
           cols = 2
           rows = 2
+          next if thin
           if tight
             sp = 1.4 * h / 2
-            lx = well ? width - cols * wxl : width - cols * wx
-            ly = well ? depth - rows * wyl : depth - rows * wy
+            lx = width - cols * wx
+            ly = depth - rows * wy
             next if lx.round(2) < sp.round(2)
             next if ly.round(2) < sp.round(2)
-            if well
-              cols = ((width - wxl) / (wxl + sp)).round(2).to_i + 1
-              rows = ((depth - wyl) / (wyl + sp)).round(2).to_i + 1
-            else
-              cols = ((width - wx) / (wx + sp)).round(2).to_i + 1
-              rows = ((depth - wy) / (wy + sp)).round(2).to_i + 1
-            end
+            cols = ((width - wx) / (wx + sp)).round(2).to_i + 1
+            rows = ((depth - wy) / (wy + sp)).round(2).to_i + 1
             next if cols < 2
             next if rows < 2
-            dX = well ? 0.0 : bfr + f
-            dY = well ? 0.0 : bfr + f
+            dX = bfr + f
+            dY = bfr + f
           else
             sp = 1.4 * h
             lx = well ? (width - cols * wxl) / cols : (width - cols * wx) / cols
-            ly = well ? (depth - rows * wyl) / rows : (depth - rows * wy) / cols
+            ly = well ? (depth - rows * wyl) / rows : (depth - rows * wy) / rows
             next if lx.round(2) < sp.round(2)
             next if ly.round(2) < sp.round(2)
@@ -6715,246 +7195,238 @@ module OSut
             next if cols < 2
             next if rows < 2
-            ly = well ? (depth - rows * wyl) / rows : (depth - rows * wy) / cols
+            ly = well ? (depth - rows * wyl) / rows : (depth - rows * wy) / rows
             dY = ly / 2
           end
-          # Current skylight area. If undershooting, adjust skylight width/depth
-          # as well as reduce spacing. For geometrical constrained cases,
-          # undershooting means not reaching 1.75x the required SRR%. Otherwise,
-          # undershooting means not reaching 1.25x the required SRR%. Any
-          # consequent overshooting is later corrected.
-          tm2       = wx * cols * wy * rows
-          undershot = tm2.round(2) < factor * skym2.round(2) ? true : false
+          # Default allocated skylight area. If undershooting, inflate skylight
+          # width/depth (with reduced spacing). For geometrically-constrained
+          # cases, undershooting means not reaching 1.75x the required target.
+          # Otherwise, undershooting means not reaching 1.25x the required
+          # target. Any consequent overshooting is later corrected.
+          tm2 = wx * cols * wy * rows
-          # Inflate skylight width/depth (and reduce spacing) to reach SRR%.
-          if undershot
+          # Inflate skylight width/depth (and reduce spacing) to reach target.
+          if tm2.round(2) < factor * skym2.round(2)
             ratio2 = 1 + (factor * skym2 - tm2) / tm2
             ratio  = Math.sqrt(ratio2)
-            sp  = w
+            sp  = wl
             wx *= ratio
             wy *= ratio
-            wxl = wx + gap
-            wyl = wy + gap
+            wxl = wx + gap if well
+            wyl = wy + gap if well
             if tight
-              if well
-                lx = (width - cols * wxl) / (cols - 1)
-                ly = (depth - rows * wyl) / (rows - 1)
-              else
-                lx = (width - cols * wx) / (cols - 1)
-                ly = (depth - rows * wy) / (rows - 1)
-              end
+              lx = (width - 2 * (bfr + f) - cols * wx) / (cols - 1)
+              ly = (depth - 2 * (bfr + f) - rows * wy) / (rows - 1)
               lx = lx.round(2) < sp.round(2) ? sp : lx
               ly = ly.round(2) < sp.round(2) ? sp : ly
-              if well
-                wxl = (width - (cols - 1) * lx) / cols
-                wyl = (depth - (rows - 1) * ly) / rows
-                wx  = wxl - gap
-                wy  = wyl - gap
-              else
-                wx  = (width - (cols - 1) * lx) / cols
-                wy  = (depth - (rows - 1) * ly) / rows
-                wxl = wx + gap
-                wyl = wy + gap
-              end
+              wx = (width - 2 * (bfr + f) - (cols - 1) * lx) / cols
+              wy = (depth - 2 * (bfr + f) - (rows - 1) * ly) / rows
             else
               if well
-                lx = (width - cols * wxl) / cols
-                ly = (depth - rows * wyl) / rows
-              else
-                lx = (width - cols * wx) / cols
-                ly = (depth - rows * wy) / rows
-              end
-              lx = lx.round(2) < sp.round(2) ? sp : lx
-              ly = ly.round(2) < sp.round(2) ? sp : ly
-              if well
+                lx  = (width - cols * wxl) / cols
+                ly  = (depth - rows * wyl) / rows
+                lx  = lx.round(2) < sp.round(2) ? sp : lx
+                ly  = ly.round(2) < sp.round(2) ? sp : ly
                 wxl = (width - cols * lx) / cols
                 wyl = (depth - rows * ly) / rows
                 wx  = wxl - gap
                 wy  = wyl - gap
-                lx  = (width - cols * wxl) / cols
                 ly  = (depth - rows * wyl) / rows
               else
+                lx  = (width - cols * wx) / cols
+                ly  = (depth - rows * wy) / rows
+                lx  = lx.round(2) < sp.round(2) ? sp : lx
+                ly  = ly.round(2) < sp.round(2) ? sp : ly
                 wx  = (width - cols * lx) / cols
                 wy  = (depth - rows * ly) / rows
-                wxl = wx + gap
-                wyl = wy + gap
-                lx  = (width - cols * wx) / cols
                 ly  = (depth - rows * wy) / rows
               end
-            end
-            dY = ly / 2
+              dY = ly / 2
+            end
           end
         when "strips" # min 2x cols x 1x row
           cols = 2
           if tight
             sp = h / 2
-            lx = well ? width - cols * wxl : width - cols * wx
-            ly = well ? depth - wyl : depth - wy
+            dX = bfr + f
+            lx = width - cols * wx
             next if lx.round(2) < sp.round(2)
-            next if ly.round(2) < sp.round(2)
-            if well
-              cols = ((width - wxl) / (wxl + sp)).round(2).to_i + 1
-            else
-              cols = ((width - wx) / (wx + sp)).round(2).to_i + 1
-            end
+            cols = ((width - wx) / (wx + sp)).round(2).to_i + 1
             next if cols < 2
-            if well
-              wyl = depth - ly
-              wy  = wyl - gap
+            if thin
+              dY = bfr + f
+              wy = depth - 2 * dY
+              next if wy.round(2) < gap4
             else
-              wy  = depth - ly
-              wyl = wy + gap
-            end
+              ly = depth - wy
+              next if ly.round(2) < wl.round(2)
-            dX = well ? 0 : bfr + f
-            dY = ly / 2
+              dY = ly / 2
+            end
           else
             sp = h
-            lx = well ? (width - cols * wxl) / cols : (width - cols * wx) / cols
-            ly = well ? depth - wyl : depth - wy
-            next if lx.round(2) < sp.round(2)
-            next if ly.round(2) < w.round(2)
             if well
+              lx = (width - cols * wxl) / cols
+              next if lx.round(2) < sp.round(2)
               cols = (width / (wxl + sp)).round(2).to_i
+              next if cols < 2
+              ly = depth - wyl
+              dY = ly / 2
+              next if ly.round(2) < wl.round(2)
             else
+              lx = (width - cols * wx) / cols
+              next if lx.round(2) < sp.round(2)
               cols = (width / (wx + sp)).round(2).to_i
-            end
+              next if cols < 2
-            next if cols < 2
+              if thin
+                dY = bfr + f
+                wy = depth - 2 * dY
+                next if wy.round(2) < gap4
+              else
+                ly = depth - wy
+                next if ly.round(2) < wl.round(2)
-            if well
-              wyl = depth - ly
-              wy  = wyl - gap
-            else
-              wy  = depth - ly
-              wyl = wy + gap
+                dY = ly / 2
+              end
             end
-            dY = ly / 2
           end
-          tm2       = wx * cols * wy
-          undershot = tm2.round(2) < factor * skym2.round(2) ? true : false
+          tm2 = wx * cols * wy
-          # Inflate skylight width (and reduce spacing) to reach SRR%.
-          if undershot
-            ratio2 = 1 + (factor * skym2 - tm2) / tm2
+          # Inflate skylight depth to reach target.
+          if tm2.round(2) < factor * skym2.round(2)
+            sp = wl
-            sp  = w
-            wx *= ratio2
-            wxl = wx + gap
+            # Skip if already thin.
+            unless thin
+              ratio2 = 1 + (factor * skym2 - tm2) / tm2
+              wy *= ratio2
-            if tight
               if well
-                lx = (width - cols * wxl) / (cols - 1)
+                wyl = wy + gap
+                ly  = depth - wyl
+                ly  = ly.round(2) < sp.round(2) ? sp : ly
+                wyl = depth - ly
+                wy  = wyl - gap
               else
-                lx = (width - cols * wx) / (cols - 1)
+                ly = depth - wy
+                ly = ly.round(2) < sp.round(2) ? sp : ly
+                wy = depth - ly
               end
-              lx = lx.round(2) < sp.round(2) ? sp : lx
+              dY = ly / 2
+            end
+          end
-              if well
-                wxl = (width - (cols - 1) * lx) / cols
-                wx  = wxl - gap
-              else
-                wx  = (width - (cols - 1) * lx) / cols
-                wxl = wx + gap
-              end
-            else
-              if well
-                lx = (width - cols * wxl) / cols
-              else
-                lx = (width - cols * wx) / cols
-              end
+          tm2 = wx * cols * wy
+          # Inflate skylight width (and reduce spacing) to reach target.
+          if tm2.round(2) < factor * skym2.round(2)
+            ratio2 = 1 + (factor * skym2 - tm2) / tm2
-              lx  = lx.round(2) < sp.round(2) ? sp : lx
+            wx *= ratio2
+            wxl = wx + gap if well
+            if tight
+              lx = (width - 2 * (bfr + f) - cols * wx) / (cols - 1)
+              lx = lx.round(2) < sp.round(2) ? sp : lx
+              wx = (width - 2 * (bfr + f) - (cols - 1) * lx) / cols
+            else
               if well
+                lx  = (width - cols * wxl) / cols
+                lx  = lx.round(2) < sp.round(2) ? sp : lx
                 wxl = (width - cols * lx) / cols
                 wx  = wxl - gap
-                lx  = (width - cols * wxl) / cols
               else
-                wx  = (width - cols * lx) / cols
-                wxl = wx + gap
                 lx  = (width - cols * wx) / cols
+                lx  = lx.round(2) < sp.round(2) ? sp : lx
+                wx  = (width - cols * lx) / cols
               end
             end
           end
         else # "strip" 1 (long?) row x 1 column
-          sp = w
-          lx = well ? width - wxl : width - wx
-          ly = well ? depth - wyl : depth - wy
           if tight
-            next if lx.round(2) < sp.round(2)
-            next if ly.round(2) < sp.round(2)
-            if well
-              wxl = width - lx
-              wyl = depth - ly
-              wx  = wxl - gap
-              wy  = wyl - gap
+            sp = gap4
+            dX = bfr + f
+            wx = width - 2 * dX
+            next if wx.round(2) < sp.round(2)
+            if thin
+              dY = bfr + f
+              wy = depth - 2 * dY
+              next if wy.round(2) < sp.round(2)
             else
-              wx  = width - lx
-              wy  = depth - ly
-              wxl = wx + gap
-              wyl = wy + gap
+              ly = depth - wy
+              dY = ly / 2
+              next if ly.round(2) < sp.round(2)
             end
-            dX = well ? 0.0 : bfr + f
-            dY = ly / 2
           else
+            sp = wl
+            lx = well ? width - wxl : width - wx
+            ly = well ? depth - wyl : depth - wy
+            dY = ly / 2
             next if lx.round(2) < sp.round(2)
             next if ly.round(2) < sp.round(2)
+          end
-            if well
-              wxl = width - lx
-              wyl = depth - ly
-              wx  = wxl - gap
-              wy  = wyl - gap
-            else
-              wx  = width - lx
-              wy  = depth - ly
-              wxl = wx + gap
-              wyl = wy + gap
-            end
+          tm2 = wx * wy
-            dY = ly / 2
+          # Inflate skylight width (and reduce spacing) to reach target.
+          if tm2.round(2) < factor * skym2.round(2)
+            unless tight
+              ratio2 = 1 + (factor * skym2 - tm2) / tm2
+              wx *= ratio2
+              if well
+                wxl = wx + gap
+                lx  = width - wxl
+                lx  = lx.round(2) < sp.round(2) ? sp : lx
+                wxl = width - lx
+                wx  = wxl - gap
+              else
+                lx  = width - wx
+                lx  = lx.round(2) < sp.round(2) ? sp : lx
+                wx  = width - lx
+              end
+            end
           end
-          tm2       = wx * wy
-          undershot = tm2.round(2) < factor * skym2.round(2) ? true : false
+          tm2 = wx * wy
-          # Inflate skylight depth to reach SRR%.
-          if undershot
-            ratio2 = 1 + (factor * skym2 - tm2) / tm2
+          # Inflate skylight depth to reach target. Skip if already tight thin.
+          if tm2.round(2) < factor * skym2.round(2)
+            unless thin
+              ratio2 = 1 + (factor * skym2 - tm2) / tm2
-            sp  = w
-            wy *= ratio2
-            wyl = wy + gap
+              wy *= ratio2
-            ly  = well ? depth - wy : depth - wyl
-            ly  = ly.round(2) < sp.round(2) ? sp : lx
+              if well
+                wyl = wy + gap
+                ly  = depth - wyl
+                ly  = ly.round(2) < sp.round(2) ? sp : ly
+                wyl = depth - ly
+                wy  = wyl - gap
+              else
+                ly = depth - wy
+                ly = ly.round(2) < sp.round(2) ? sp : ly
+                wy = depth - ly
+              end
-            if well
-              wyl = depth - ly
-              wy  = wyl - gap
-            else
-              wy  = depth - ly
-              wyl = wy + gap
+              dY = ly / 2
             end
           end
         end
@@ -6972,10 +7444,13 @@ module OSut
         set[pattern] = st
       end
+      set[:void] = true unless patterns.any? { |k| set.key?(k) }
     end
     # Delete voided sets.
     sets.reject! { |set| set.key?(:void) }
+    return empty("sets (2)", mth, WRN, rm2) if sets.empty?
     # Final reset of filters.
     filters.map! { |f| f.include?("b") ? f.delete("b") : f } unless sidelit
@@ -6986,15 +7461,15 @@ module OSut
     filters.reject! { |f| f.empty? }
     filters.uniq!
-    # Initialize skylight area tally.
+    # Initialize skylight area tally (to increment).
     skm2 = 0
     # Assign skylight pattern.
-    filters.each_with_index do |filter, i|
+    filters.each do |filter|
       next if skm2.round(2) >= sm2.round(2)
+      dm2 = sm2 - skm2 # differential (remaining skylight area to meet).
       sts = sets
-      sts = sts.sort_by { |st| st[:bm2] }.reverse!
       sts = sts.reject  { |st| st.key?(:pattern) }
       if filter.include?("a")
@@ -7029,33 +7504,49 @@ module OSut
           fpm2[pattern] = {m2: 0, tight: false} unless fpm2.key?(pattern)
-          fpm2[pattern][:m2   ] += wx * wy * cols * rows
-          fpm2[pattern][:tight] = st[:tight] ? true : false
+          fpm2[pattern][:m2   ] += st[:m] * wx * wy * cols * rows
+          fpm2[pattern][:tight] = true if st[:tight]
         end
       end
       pattern = nil
       next if fpm2.empty?
-      fpm2 = fpm2.sort_by { |_, fm2| fm2[:m2] }.to_h
-      # Select suitable pattern, often overshooting. Favour array unless
-      # geometrically constrainted.
+      # Favour (large) arrays if meeting residual target, unless constrained.
       if fpm2.keys.include?("array")
-        if (fpm2["array"][:m2]).round(2) >= sm2.round(2)
+        if fpm2["array"][:m2].round(2) >= dm2.round(2)
           pattern = "array" unless fpm2[:tight]
         end
       end
       unless pattern
-        if fpm2.values.first[:m2].round(2) >= sm2.round(2)
-          pattern = fpm2.keys.first
-        elsif fpm2.values.last[:m2].round(2) <= sm2.round(2)
-          pattern = fpm2.keys.last
+        fpm2   = fpm2.sort_by { |_, fm2| fm2[:m2] }.to_h
+        min_m2 = fpm2.values.first[:m2]
+        max_m2 = fpm2.values.last[:m2]
+        if min_m2.round(2) >= dm2.round(2)
+          # If not large array, then retain pattern generating smallest skylight
+          # area if ALL patterns >= residual target (deterministic sorting).
+          fpm2.keep_if { |_, fm2| fm2[:m2].round(2) == min_m2.round(2) }
+          if fpm2.keys.include?("array")
+            pattern = "array"
+          elsif fpm2.keys.include?("strips")
+            pattern = "strips"
+          else # fpm2.keys.include?("strip")
+            pattern = "strip"
+          end
         else
-          fpm2.keep_if { |_, fm2| fm2[:m2].round(2) >= sm2.round(2) }
-          pattern = fpm2.keys.first
+          # Pick pattern offering greatest skylight area (deterministic sorting).
+          fpm2.keep_if { |_, fm2| fm2[:m2].round(2) == max_m2.round(2) }
+          if fpm2.keys.include?("strip")
+            pattern = "strip"
+          elsif fpm2.keys.include?("strips")
+            pattern = "strips"
+          else # fpm2.keys.include?("array")
+            pattern = "array"
+          end
         end
       end
@@ -7086,55 +7577,162 @@ module OSut
       end
     end
-    # Skylight size contraction if overshot (e.g. -13.2% if overshot by +13.2%).
-    # This is applied on a surface/pattern basis; individual skylight sizes may
-    # vary from one surface to the next, depending on respective patterns.
+    # Delete incomplete sets (same as rejected if 'voided').
+    sets.reject! { |set| set.key?(:void) }
+    sets.select! { |set| set.key?(:pattern) }
+    return empty("sets (3)", mth, WRN, rm2) if sets.empty?
+    # Skylight size contraction if overshot (e.g. scale down by -13% if > +13%).
+    # Applied on a surface/pattern basis: individual skylight sizes may vary
+    # from one surface to the next, depending on respective patterns.
+    # First, skip whole sets altogether if their total m2 < (skm2 - sm2). Only
+    # considered if significant discrepancies vs average set skylight m2.
+    sbm2 = 0
+    sets.each do |set|
+      sbm2 += set[:cols] * set[:w] * set[:rows] * set[:d] * set[:m]
+    end
+    avm2 = sbm2 / sets.size
+    if skm2.round(2) > sm2.round(2)
+      sets.reverse.each do |set|
+        break unless skm2.round(2) > sm2.round(2)
+        stm2 = set[:cols] * set[:w] * set[:rows] * set[:d] * set[:m]
+        next unless stm2 < 0.75 * avm2
+        next unless stm2.round(2) < (skm2 - sm2).round(2)
+        skm2 -= stm2
+        set[:void] = true
+      end
+    end
+    sets.reject! { |set| set.key?(:void) }
+    return empty("sets (4)", mth, WRN, rm2) if sets.empty?
+    # Size contraction: round 1: low-hanging fruit.
     if skm2.round(2) > sm2.round(2)
       ratio2 = 1 - (skm2 - sm2) / skm2
       ratio  = Math.sqrt(ratio2)
-      skm2  *= ratio2
       sets.each do |set|
-        next if set.key?(:void)
-        next unless set.key?(:pattern)
+        am2 = set[:cols] * set[:w] * set[:rows] * set[:d] * set[:m]
+        xr  = set[:w]
+        yr  = set[:d]
-        pattern = set[:pattern]
-        next unless set.key?(pattern)
+        if xr > w0
+          xr = xr * ratio < w0 ? w0 : xr * ratio
+        end
-        case pattern
-        when "array" # equally adjust both width and depth
-          xr  = set[:w] * ratio
-          yr  = set[:d] * ratio
-          dyr = set[:d] - yr
-          set[:w ]  = xr
-          set[:d ]  = yr
-          set[:w0]  = set[:w] + gap
-          set[:d0]  = set[:d] + gap
-          set[:dY] += dyr / 2
-        when "strips" # adjust depth
-          xr2 = set[:w] * ratio2
-          set[:w ]  = xr2
-          set[:w0]  = set[:w] + gap
-        else # "strip", adjust width
-          yr2 = set[:d] * ratio2
-          dyr = set[:d] - yr2
-          set[:d ]  = yr2
-          set[:d0]  = set[:w] + gap
-          set[:dY] += dyr / 2
+        if yr > w0
+          yr = yr * ratio < w0 ? w0 : yr * ratio
         end
+        xm2 = set[:cols] * xr * set[:rows] * yr * set[:m]
+        next if xm2.round(2) == am2.round(2)
+        set[:dY] += (set[:d] - yr) / 2
+        set[:dX] += (set[:w] - xr) / 2 if set.key?(:dX)
+        set[:w ]  = xr
+        set[:d ]  = yr
+        set[:w0]  = set[:w] + gap
+        set[:d0]  = set[:d] + gap
+        skm2 -= (am2 - xm2)
       end
     end
-    # Generate skylight well roofs for attics & plenums.
+    # Size contraction: round 2: prioritize larger sets.
+    adm2 = 0
+    sets.each_with_index do |set|
+      next if set[:w].round(2) <= w0
+      next if set[:d].round(2) <= w0
+      adm2 += set[:cols] * set[:w] * set[:rows] * set[:d] * set[:m]
+    end
+    if skm2.round(2) > sm2.round(2) && adm2.round(2) > sm2.round(2)
+      ratio2 = 1 - (adm2 - sm2) / adm2
+      ratio  = Math.sqrt(ratio2)
+      sets.each do |set|
+        next if set[:w].round(2) <= w0
+        next if set[:d].round(2) <= w0
+        am2 = set[:cols] * set[:w] * set[:rows] * set[:d] * set[:m]
+        xr  = set[:w]
+        yr  = set[:d]
+        if xr > w0
+          xr = xr * ratio < w0 ? w0 : xr * ratio
+        end
+        if yr > w0
+          yr = yr * ratio < w0 ? w0 : yr * ratio
+        end
+        xm2 = set[:cols] * xr * set[:rows] * yr * set[:m]
+        next if xm2.round(2) == am2.round(2)
+        set[:dY] += (set[:d] - yr) / 2
+        set[:dX] += (set[:w] - xr) / 2 if set.key?(:dX)
+        set[:w ]  = xr
+        set[:d ]  = yr
+        set[:w0]  = set[:w] + gap
+        set[:d0]  = set[:d] + gap
+        skm2 -= (am2 - xm2)
+        adm2 -= (am2 - xm2)
+      end
+    end
+    # Size contraction: round 3: Resort to sizes < requested w0.
+    if skm2.round(2) > sm2.round(2)
+      ratio2 = 1 - (skm2 - sm2) / skm2
+      ratio  = Math.sqrt(ratio2)
+      sets.each do |set|
+        break unless skm2.round(2) > sm2.round(2)
+        am2 = set[:cols] * set[:w] * set[:rows] * set[:d] * set[:m]
+        xr  = set[:w]
+        yr  = set[:d]
+        if xr > gap4
+          xr = xr * ratio < gap4 ? gap4 : xr * ratio
+        end
+        if yr > gap4
+          yr = yr * ratio < gap4 ? gap4 : yr * ratio
+        end
+        xm2 = set[:cols] * xr * set[:rows] * yr * set[:m]
+        next if xm2.round(2) == am2.round(2)
+        set[:dY] += (set[:d] - yr) / 2
+        set[:dX] += (set[:w] - xr) / 2 if set.key?(:dX)
+        set[:w ]  = xr
+        set[:d ]  = yr
+        set[:w0]  = set[:w] + gap
+        set[:d0]  = set[:d] + gap
+        skm2 -= (am2 - xm2)
+      end
+    end
+    # Log warning if unable to entirely contract skylight dimensions.
+    if skm2.round(2) > sm2.round(2)
+      log(WRN, "Skylights slightly oversized (#{mth})")
+    end
+    # Generate skylight well vertices for roofs, attics & plenums.
     [attics, plenums].each do |greniers|
       k = greniers == attics ? :attic : :plenum
       greniers.each do |spce, grenier|
-        ti = grenier[:t]
         grenier[:roofs].each do |roof|
           sts = sets
           sts = sts.select { |st| st.key?(k) }
@@ -7150,15 +7748,15 @@ module OSut
           sts = sts.select { |st| st[:ld].key?(roof) }
           next if sts.empty?
-          # If successful, 'genInserts' returns extended roof surface vertices,
-          # including leader lines to support cutouts. The final selection is
+          # If successful, 'genInserts' returns extended ROOF surface vertices,
+          # including leader lines to support cutouts. The method also generates
+          # new roof inserts. See key:value pair :vts. The FINAL go/no-go is
           # contingent to successfully inserting corresponding room ceiling
-          # inserts (vis-à-vis attic/plenum floor below). The method also
-          # generates new roof inserts. See key:value pair :vts.
+          # inserts (vis-à-vis attic/plenum floor below).
           vz = genInserts(roof, sts)
-          next if vz.empty? # TODO log error if empty
+          next if vz.empty?
-          roof.setVertices(ti.inverse * vz)
+          roof.setVertices(vz)
         end
       end
     end
@@ -7178,14 +7776,15 @@ module OSut
       room    = rooms[space]
       grenier = greniers[spce]
-      ti      = grenier[:t]
-      t0      = room[:t]
+      ti      = grenier[:ti]
+      t0      = room[:t0]
       stz     = []
       ceiling[:roofs].each do |roof|
         sts = sets
         sts = sts.select { |st| st.key?(k) }
+        sts = sts.select { |st| st.key?(:pattern) }
         sts = sts.select { |st| st.key?(:clng) }
         sts = sts.select { |st| st.key?(:cm2) }
         sts = sts.select { |st| st.key?(:roof) }
@@ -7206,104 +7805,109 @@ module OSut
       next if stz.empty?
-      # Vertically-cast set roof :vtx onto ceiling.
-      stz.each do |st|
-        cvtx = cast(ti * st[:vtx], t0 * tile.vertices, ray)
-        st[:cvtx] = t0.inverse * cvtx
-      end
-      # Extended ceiling vertices.
-      vertices = genExtendedVertices(tile, stz, :cvtx)
-      next if vertices.empty?
-      # Reset ceiling and adjacent floor vertices.
-      tile.setVertices(t0.inverse * vertices)
-      floor.setVertices(ti.inverse * vertices.to_a.reverse)
       # Add new roof inserts & skylights for the (now) toplit space.
       stz.each_with_index do |st, i|
-        sub          = {}
-        sub[:type  ] = "Skylight"
-        sub[:width ] = st[:w] - f2
-        sub[:height] = st[:d] - f2
-        sub[:sill  ] = gap / 2
-        sub[:frame ] = frame if frame
+        sub         = {}
+        sub[:type ] = "Skylight"
+        sub[:frame] = frame if frame
+        sub[:sill ] = gap / 2
         st[:vts].each do |id, vt|
-          roof = OpenStudio::Model::Surface.new(t0.inverse * vt, mdl)
+          roof = OpenStudio::Model::Surface.new(t0.inverse * (ti * vt), mdl)
           roof.setSpace(space)
-          roof.setName("#{i}:#{id}:#{space.nameString}")
+          roof.setName("#{id}:#{space.nameString}")
           # Generate well walls.
-          v0 = roof.vertices
           vX = cast(roof, tile, ray)
-          s0 = getSegments(v0)
-          sX = getSegments(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
-            vec  = OpenStudio::Point3dVector.new
+            sg0 = sg
+            sgX = sX[j]
+            vec = OpenStudio::Point3dVector.new
             vec << sg0.first
             vec << sg0.last
             vec << sgX.last
             vec << sgX.first
-            grenier_wall = OpenStudio::Model::Surface.new(vec, mdl)
+            v_grenier = ti.inverse * vec
+            v_room    = (t0.inverse * vec).to_a.reverse
+            grenier_wall = OpenStudio::Model::Surface.new(v_grenier, mdl)
             grenier_wall.setSpace(spce)
-            grenier_wall.setName("#{id}:#{j}:#{spce.nameString}")
+            grenier_wall.setName("#{id}:#{i}:#{j}:#{spce.nameString}")
-            room_wall = OpenStudio::Model::Surface.new(vec.to_a.reverse, mdl)
+            room_wall = OpenStudio::Model::Surface.new(v_room, mdl)
             room_wall.setSpace(space)
-            room_wall.setName("#{id}:#{j}:#{space.nameString}")
+            room_wall.setName("#{id}:#{i}:#{j}:#{space.nameString}")
             grenier_wall.setAdjacentSurface(room_wall)
             room_wall.setAdjacentSurface(grenier_wall)
           end
-          # Add individual skylights.
-          addSubs(roof, [sub])
+          # Add individual skylights. Independently of the set layout (rows x
+          # cols), individual roof inserts may be deeper than wider (or
+          # vice-versa). Adapt skylight width vs depth accordingly.
+          if st[:d].round(2) > st[:w].round(2)
+            sub[:width ] = st[:d] - f2
+            sub[:height] = st[:w] - f2
+          else
+            sub[:width ] = st[:w] - f2
+            sub[:height] = st[:d] - f2
+          end
+          sub[:id] = roof.nameString
+          addSubs(roof, sub, false, true, true)
         end
       end
+      # Vertically-cast set roof :vtx onto ceiling.
+      stz.each do |st|
+        st[:cvtx] = t0.inverse * cast(ti * st[:vtx], t0 * tile.vertices, ray)
+      end
+      # Extended ceiling vertices.
+      vertices = genExtendedVertices(tile, stz, :cvtx)
+      next if vertices.empty?
+      # Reset ceiling and adjacent floor vertices.
+      tile.setVertices(vertices)
+      floor.setVertices(ti.inverse * (t0 * vertices).to_a.reverse)
     end
-    # New direct roof loop. No overlaps, so no need for relative space
-    # coordinate adjustments.
+    # Loop through 'direct' roof surfaces of rooms to toplit (no attics or
+    # plenums). No overlaps, so no relative space coordinate adjustments.
     rooms.each do |space, room|
       room[:roofs].each do |roof|
-        sets.each_with_index do |set, i|
-          next     if set.key?(:clng)
-          next unless set.key?(:box)
-          next unless set.key?(:roof)
-          next unless set.key?(:cols)
-          next unless set.key?(:rows)
-          next unless set.key?(:d)
-          next unless set.key?(:w)
-          next unless set.key?(:tight)
-          next unless set[:roof] == roof
-          tight = set[:tight]
-          d1 = set[:d] - f2
-          w1 = set[:w] - f2
-          # Y-axis 'height' of the roof, once re/aligned.
-          # TODO: retrieve st[:out], +efficient
-          y  = alignedHeight(set[:box])
-          dY = set[:dY] if set[:dY]
-          set[:rows].times.each do |j|
+        sets.each_with_index do |st, i|
+          next unless st.key?(:roof)
+          next unless st[:roof] == roof
+          next     if st.key?(:clng)
+          next unless st.key?(:box)
+          next unless st.key?(:cols)
+          next unless st.key?(:rows)
+          next unless st.key?(:d)
+          next unless st.key?(:w)
+          next unless st.key?(:dY)
+          w1 = st[:w ] - f2
+          d1 = st[:d ] - f2
+          dY = st[:dY]
+          st[:rows].times.each do |j|
             sub            = {}
             sub[:type    ] = "Skylight"
-            sub[:count   ] = set[:cols]
+            sub[:count   ] = st[:cols]
             sub[:width   ] = w1
             sub[:height  ] = d1
             sub[:frame   ] = frame if frame
-            sub[:id      ] = "set #{i+1}:#{j+1}"
+            sub[:id      ] = "#{roof.nameString}:#{i}:#{j}"
             sub[:sill    ] = dY + j * (2 * dY + d1)
-            sub[:r_buffer] = set[:dX] if set[:dX]
-            sub[:l_buffer] = set[:dX] if set[:dX]
-            addSubs(roof, [sub])
+            sub[:r_buffer] = st[:dX] if st[:dX]
+            sub[:l_buffer] = st[:dX] if st[:dX]
+            addSubs(roof, sub, false, true, true)
           end
         end
       end