openstudio-standards 0.8.5 → 0.8.7

data/lib/openstudio-standards/btap/bridging.rb

@@ -1,5 +1,5 @@
 # **************************************************************************** /
-# *  Copyright (c) 2008-2025, Natural Resources Canada
+# *  Copyright (c) 2008-2026, Natural Resources Canada
 # *  All rights reserved.
 # *
 # *  This library is free software; you can redistribute it and/or
@@ -18,6 +18,7 @@
 # **************************************************************************** /
 
 require 'tbd'
+require 'json'
 
 module BTAP
   # ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- #
@@ -29,29 +30,19 @@ module BTAP
     # @author: Denis Bourgeois
 
     # --- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- --- #
-    # BTAP/TBD data initially extracted from the BTAP costing spreadsheet:
+    # BTAP/TBD parameters are based on BTAP costing data:
+    #   - paired low-performance (LP) vs high-performance (HP) wall variants
+    #   - range of clear-field Uo factors for each variant
+    #   - paired "bad" vs "good" PSI factor sets for each variant
     #
-    #   - range of clear-field Uo factors
-    #   - range of PSI factors (i.e. MAJOR thermal bridging), e.g. corners
-    #
-    # Ref: EVOKE BTAP costing spreadsheet modifications (2022), synced with:
+    # Ref: BTAP costing data modifications (2022), synced with:
     #      - Building Envelope Thermal Bridging Guide (BETBG)
     #      - ASHRAE RP-1365, ISO-12011, etc.
     #
-    # This module has been subsequently adapted following the adoption of new
-    # BTAP structure/envelope data model/classes.
+    # STRUCTURE parameters set paired constructions - see btap/structure.rb.
 
     # --- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- --- #
-    # BTAP costing data (both original BTAP envelope entries and EVOKE add-ons)
-    # hold sub-variants based on cladding/veneer, e.g.:
-    #
-    #   - "BTAP-ExteriorWall-WoodFramed-5" ... brick veneer
-    #   - "BTAP-ExteriorWall-WoodFramed-1" ... wood siding
-    #
-    # Not all of these sub-variants are currently used within BTAP, e.g.
-    # "BTAP-ExteriorWall-WoodFramed-1" is unused. BTAP/TBD data is limited
-    # to the following wall assemblies (paired LP & HP variants), which
-    # eventually should be located in a shared file (e.g. CSV, JSON).
+    # BTAP/TBD data groups above-grade wall assemblies as paired LP/HP variants.
     #
     #   -----   Low Performance (LP) assemblies
     #   ID    : layers
@@ -70,7 +61,7 @@ module BTAP
     #   MASS8 : precast  | xps     | wool | frame | gypsum ... switch from MASS4
     #
     # Paired LPs & HPs vall variants are critical for 'uprating' cases, e.g.
-    # NECB2017/2020. See below, and end of this document for additional NOTES.
+    # NECB2017/2020/2025. See below, and additional Notes at the very end.
 
     MASS2      = "BTAP-ExteriorWall-Mass-2"              # LP wall
     MASS2_BAD  = "BTAP-ExteriorWall-Mass-2 bad"          # LP "bad" PSI factors
@@ -100,114 +91,101 @@ module BTAP
     STEL2_BAD  = "BTAP-ExteriorWall-SteelFramed-2 bad"
     STEL2_GOOD = "BTAP-ExteriorWall-SteelFramed-2 good"
 
-    ROOF       = "BTAP-ExteriorRoof-IEAD-4"
-    FLOOR      = "BTAP-ExteriorFloor-SteelFramed-1"
+    # Insulated roofs, exposed floors (and attic floors) are also up/de-rated.
+    ROOF       = "BTAP-ExteriorRoof-IEAD-4"         # no LP/HP variants
+    FLOOR      = "BTAP-ExteriorFloor-SteelFramed-1" # no LP/HP variants
 
     # --- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- --- #
-    # There are 2 distinct BTAP "building_envelope.rb" files to enrich with
-    # TBD functionality (whether BTAP users choose to activate TBD or not):
+    # BTAP/TBD is de/activated by setting the NECB 'tbd_option' as follows:
+    #   - "none"         : TBD is deactivated, i.e. no uprating
+    #   - "bad" or "good": TBD derates envelope
+    #   - "uprate"       : TBD uprates initial Uo ... prior to derating
     #
-    #   1. BTAPPRE1980
-    #      - superclass for BTAP1980TO2010
-    #   2. NECB2011
-    #      - superclass for NECB2015
-    #      - superclass for NECB2017 (inherits from NECB2015)
-    #      - superclass for NECB2020 (inherits from NECB2017)
-    #      - superclass for ECMS
+    #   - (see necb_2011.rb/apply_thermal_bridging)
     #
-    # In both files, a BTAP/TBD option switch allows BTAP users to activate
-    # or deactivate TBD functionality :
-    #   - "none" : TBD is deactivated, i.e. no up/de-rating
-    #   - "bad" or "good": (BTAP-costed) PSI factor sets, i.e. derating only
-    #   - "uprate": iteratively determine initial Uo ... prior to derating
-    #
-    # For vintages < NECB2017, the default BTAP policy is to switch off TBD,
-    # i.e. 'none' (see the NOTE on this topic at the end of this document). To
-    # instead assess prescriptive Ut compliance for vintages NECB2017 and
-    # NECB2020, the BTAP/TBD must be set to "uprate" so it can iteratively reset
-    # combined Uo & PSI factors towards finding the least expensive, yet
-    # compliant, combination. Why? Improved Uo assembly variants are necessarily
-    # required, given:
+    # For NECB editions prior to NECB2017, the current recommended BTAP policy
+    # is to switch off TBD (i.e. 'none') - see Note on this topic at the end of
+    # this document. To instead assess prescriptive Ut compliance for NECB
+    # editions 2017 through 2025, BTAP/TBD must be set to "uprate" so it can
+    # iteratively reset combined Uo & PSI factors towards finding the most
+    # affordable (yet compliant) Ut combination. Why? Improved Uo assembly
+    # variants are necessarily required, given:
     #
     #   Ut = Uo + ( ∑psi x L )/A + ( ∑khi x n )/A   (ref: rd2.github.io/tbd)
     #
     # If one ignores linear ("( ∑psi x L )/A") and point ("( ∑khi x n )/A")
-    # conductances, Ut simply equates to Uo. Yet for ANY added linear or
-    # point conductance, Uo factors must necessarily be lower than required
-    # NECB2017 or NECB2020 Ut factors. EVOKE's 2022 contribution extends
-    # initial (pre-2022) BTAP wall assembly variants, offering much
-    # lower Uo factors (in some cases slightly below 0.1 W/m2.K or ~R70).
-    # These BTAP upgrades provide more options for attaining required Ut
-    # factors. For some variants, this simply implies a thicker insulation
-    # layer. For others, it involves more radical assembly changes, such
-    # as switching over to the latest commercially-available HP
-    # thermally-broken cladding clips. While some solutions are simple
-    # (free) detailing changes, most improvements increase construction
-    # costs. Despite adding new HP assemblies, it is unlikely that TBD
-    # will find NECB2017 or NECB2020 compliant combinations (prescriptive
-    # path) for EVERY OpenStudio model. Read here as to "why?":
+    # conductances, Ut simply equates to Uo. Yet for ANY added linear or point
+    # conductance, Uo factors must necessarily be lower than required NECB2017+
+    # Ut factor requirements. BTAP HP wall assembly variants indeed offer much
+    # lower Uo factors (than required Ut), down to 0.1 W/m2.K or ~R70. These
+    # BTAP upgrades certainly provide more options for attaining required Ut
+    # factors. In practice, this simply implies a thicker insulation layer. For
+    # others, it involves more radical assembly changes, such as switching over
+    # to the latest commercially-available HP thermally-broken cladding clips.
+    # While some solutions are simple (free) detailing changes, most
+    # improvements increase construction costs. Despite adding new BTAP HP
+    # assemblies, it is unlikely that TBD will find NECB2017+ compliant
+    # combinations (prescriptive path) for EVERY OpenStudio model. Why?
     #
-    #   github.com/rd2/tbd/blob/f34ec6a017fcc0f6022f2a46e056b46b9d036b3b/
-    #   spec/tbd_tests_spec.rb#L9219
+    #   github.com/rd2/tbd/blob/dd6f12f8f2c24950485918c7eaca57d8f091a64d/spec/
+    #   tbd_tests_spec.rb#L1674
     #
     # For these reasons, BTAP's use of TBD rests on an ITERATIVE uprating
-    # solution for NECB2017 and NECB2020:
+    # solution for NECB2017+:
     #
     #   1. TBD attempts to achieve NECB-required area-weighted Ut factors
     #      for above-grade walls (then for roofs and exposed floors),
     #      starting with the least expensive combination:
-    #        - highest admissible Uo factors for the climate zone
-    #        - "bad" (LP) thermal bridging details
+    #        - LP variant
+    #        - "bad" thermal bridging details
     #
     #   2. If, for a given OpenStudio model, required area-weighted Ut
     #      factors cannot be achieved, TBD then switches over to "good"
-    #      (HP) thermal bridging detailing for that same assembly, and
-    #      repeats the exercise.
+    #      thermal bridging detailing for that same assembly, and repeats the
+    #      exercise.
     #
-    #   3. A subsequent failed attempt triggers a switch over to EVOKE's
-    #      HP (improved Uo) assemblies. For instance:
+    #   3. A subsequent failed attempt triggers a switch over to HP variants.
+    #      For instance:
     #        - "BTAP-ExteriorWall-WoodFramed-5" ... switches over to:
     #        - "BTAP-ExteriorWall-WoodFramed-7"
     #
     #      ... switching over to another assembly this way also means
-    #      reverting back to "bad" (LP) thermal bridging PSI factors.
+    #      reverting back to "bad" thermal bridging PSI factors.
     #
-    #   4. A final switch to "good" (HP) details is available (last resort).
+    #   4. A final switch to "good" details is triggered if needed.
     #
     # If NONE of the available combinations are sufficient:
-    #   - TBD red-flags a failed attempt at NECB2017 or NECB2020 compliance
-    #   - TBD keeps iteration #4 Uo + PSI combo, then derates before a
-    #     BTAP simulation run (giving some performance gap indication)
+    #   - TBD red-flags a failed attempt at NECB2017+ compliance
+    #   - TBD keeps iteration #4 (HP Uo + "good" PSI combo), then derates before
+    #     a BTAP simulation run (giving some performance gap indication)
 
     # --- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- --- #
     # Notes:
     #
-    #   - Steel-framed assemblies: the selected HP variant has metal
-    #     cladding. The only LP steel-framed BTAP option is wood-clad -
-    #     something of an anomaly in commercial construction. By making the
-    #     switch earlier to metal cladding, everywhere in Canada except
-    #     (milder) SW BC and SW NS, it is hoped that a more consistent,
-    #     apples-to-apples comparison is ensured.
+    #   - Steel-framed assemblies: the costed HP variant has metal cladding.
+    #     The costed LP variant is wood-clad - something of an anomaly in
+    #     commercial construction. By making the switch earlier to metal
+    #     cladding, everywhere in Canada except (milder) SW BC and SW NS, it is
+    #     hoped that a more consistent, apples-to-apples comparison is ensured.
     #
-    #   - ROOF and (exposed) floor surfaces refer to a single LP/HP selection
-    #     respectively. This is expected to change in the future @todo.
+    #   - ROOF and FOOR surfaces refer to a single LP/HP selection respectively.
 
     # --- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- --- #
     # Preset BTAP/TBD wall assembly parameters.
     @@data = {}
 
     # Construction sub-variant identified strictly by Uo, e.g. 0.314 W/m2.K.
-    @@data[MASS2] = {uos: [0.314, 0.278, 0.247, 0.210, 0.183]}
-    @@data[MASSB] = {uos: [0.130, 0.100]}
+    @@data[MASS2] = {uos: [0.314, 0.278, 0.247, 0.210, 0.183]}        # :lp
+    @@data[MASSB] = {uos: [0.130, 0.100]}                             # :hp
 
-    @@data[MASS4] = {uos: [0.314, 0.278, 0.247, 0.210, 0.183]}
-    @@data[MASS8] = {uos: [0.130, 0.100]}
+    @@data[MASS4] = {uos: [0.314, 0.278, 0.247, 0.210, 0.183]}        # :lp
+    @@data[MASS8] = {uos: [0.130, 0.100]}                             # :hp
 
-    @@data[WOOD5] = {uos: [0.314, 0.278, 0.247, 0.210, 0.183]}
-    @@data[WOOD7] = {uos: [0.130]}
+    @@data[WOOD5] = {uos: [0.314, 0.278, 0.247, 0.210, 0.183]}        # :lp
+    @@data[WOOD7] = {uos: [0.130]}                                    # :hp
 
-    @@data[STEL1] = {uos: [0.314, 0.278]}
-    @@data[STEL2] = {uos: [0.247, 0.210, 0.183, 0.130, 0.100, 0.080]}
+    @@data[STEL1] = {uos: [0.314, 0.278]}                             # :lp
+    @@data[STEL2] = {uos: [0.247, 0.210, 0.183, 0.130, 0.100, 0.080]} # :hp
 
     @@data[FLOOR] = {uos: [0.227, 0.183, 0.162, 0.142, 0.116, 0.101]}
     @@data[ROOF ] = {uos: [0.227, 0.193, 0.183, 0.162, 0.156, 0.142, 0.138, 0.121, 0.100]}
@@ -221,7 +199,7 @@ module BTAP
 
     # Thermal bridge types :balcony, :party and :joint are NOT expected to
     # be processed soon within BTAP. They are neither costed out, nor are carbon
-    # intensities (kg CO2eq/linear meter) associated to them. At some point, it
+    # intensities (kgCO2-eq/linear meter) associated to them. At some point, it
     # may be wise to do so (notably cantilevered balconies in MURBs) - @todo.
     # Default, generic BETBG PSI factors are nonetheless provided here:
     #   - for "bad" BTAP cases : generic BETBG set "bad"
@@ -405,26 +383,108 @@ module BTAP
     # --- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- --- #
 
     ##
-    # Retrieves BTAP-costed assembly.
+    # Returns current BTAP list of admissible edges (i.e. linear thermal
+    # bridges), as Symbols. These are key for 'gen_tallies' & BTAP costing (TBD
+    # tracks a wider range of thermal bridge types than BTAP costing currently
+    # supports). This may be updated in the future.
     #
-    # @param structure [BTAP::Structure] BTAP Structure object
-    # @param stype [:walls, :floors or :roofs] surface type
-    # @param perform [:hp or :lp] high- or low-performance variant
+    # @return [Array] admissible BTAP-costed edge types (Symbols)
+    def self.admissible_edges
+      [:rimjoist, :parapet, :fenestration, :corner, :grade]
+    end
+
+    ##
+    # Returns paired low-performance (LP) & high-performance (HP) BTAP-costed
+    # wall assembly identifiers, based on user-provided assembly ID. If valid,
+    # solution returns a Hash holding 2 keys (:lp and :hp).
     #
-    # @return [String] BTAP assembly identifier for costing
-    def costed_assembly(structure = nil, stype = :walls, perform = :lp)
-      stype   = :walls unless [:roofs, :floors].include?(stype)
-      perform = :lp    unless perform == :hp
-      return STEL1 unless structure.is_a?(BTAP::Structure)
-
-      # Select BTAP-costed assembly, matching:
-      #   - BTAP::Structure generated construction parameters
-      #   - requested high (HP) vs low-performance (LP) PSI-factor level
-      #
-      # Ideally, chosen PSI factor sets and matching OpenStudio constructions
-      # shouldn't strictly be based on selected BTAP assemblies (e.g.
+    # @param id [String] a valid BTAP-costed wall assembly identifier
+    #
+    # @return [Hash] assembly :lp & :hp identifiers (empty if invalid input)
+    def assembly_id(id = "")
+      return {} unless @@data.key?(id)
+      pair = {}
+
+      if id == MASS2 || id == MASSB
+        pair[:lp] = MASS2
+        pair[:hp] = MASSB
+      elsif id == MASS4 || id == MASS8
+        pair[:lp] = MASS4
+        pair[:hp] = MASS8
+      elsif id == WOOD5 || id == WOOD7
+        pair[:lp] = WOOD5
+        pair[:hp] = WOOD7
+      elsif id == STEL1 || id == STEL2
+        pair[:lp] = STEL1
+        pair[:hp] = STEL2
+      end
+
+      pair
+    end
+
+    ##
+    # Returns an above-grade (opaque) BTAP-costed assembly identifier that
+    # matches selection criteria. Solution may return an assembly's low
+    # performance (:lp) or its paired high-performance (:hp) variant. Defaults
+    # to STEL2 (walls) if invalid input.
+    #
+    # @param [Hash] argh options
+    # @option argh [Symbol] :stype (:walls, :floors or :roofs)
+    # @option argh [Symbol] :perform (:lp or :hp) wall variant
+    # @option argh [Symbol] :framing (:steel, :wood, :cmu)
+    # @option argh [Symbol] :cladding (:heavy)
+    # @option argh [Symbol] :finish (:heavy)
+    # @option argh [String] :id a BTAP-costed assembly (often :lp)
+    # @option argh [Float] :uo desired U-factor
+    #
+    # @return [String] BTAP costed assembly identifier
+    def costed_assembly(argh = {})
+      return STEL2 unless argh.respond_to?(:keys)
+
+      # Key input.
+      stype = argh.key?(:stype) ? argh[:stype] : :walls
+      stype = :walls unless [:roofs, :floors].include?(stype)
+
+      # No BTAP variants yet for roofs or floors.
+      return ROOF  if stype == :roofs
+      return FLOOR if stype == :floors
+
+      # Low-performance (:lp) or high-performance (:hp) variant?
+      perform = argh.key?(:perform) ? argh[:perform] : :lp
+      perform = :lp unless perform == :hp
+
+      # Prioritizing BTAP-costed wall assembly identifiers.
+      if argh.key?(:id)
+        pair = assembly_id(argh[:id])
+
+        unless pair.empty?
+          if argh.key?(:uo)
+            uo = costed_uo(pair[perform], argh[:uo])
+            perform = :hp if uo.nil?
+          end
+
+          return pair[perform]
+        end
+      end
+
+      # Relying instead on STRUCTURE-based parameters.
+      framing  = argh.key?(:framing)  ? argh[:framing ] : :steel
+      cladding = argh.key?(:cladding) ? argh[:cladding] : :light
+      finish   = argh.key?(:finish)   ? argh[:finish  ] : :light
+
+      framing  = :steel unless [:wood, :cmu].include?(framing)
+      cladding = :light unless cladding == :heavy
+      finish   = :light unless finish   == :heavy
+
+      # Select BTAP-costed wall assembly, matching:
+      #   - BTAP::Structure generated construction parameters (e.g. framing)
+      #   - requested high- (:hp) vs low-performance (:lp) variant
+      pair = {}
+
+      # Note: Chosen PSI factor sets and matching OpenStudio constructions
+      # shouldn't strictly be based on selected BTAP-costed assemblies (e.g.
       # wood-framed vs steel-framed, cladding choice), but also on selected
-      # building 'structure', e.g.:
+      # building STRUCTURE, e.g.:
       #
       #   - "wood-framed" MURB
       #   - "steel post/beam" office building
@@ -432,43 +492,32 @@ module BTAP
       #   - "metal(-building)" warehouse
       #   - "mass-timber (CLT)" university pavilion
       #
-      # Major thermal bridges often consist of anchors or supports that transmit
-      # structural loads (and by the same token, 'heat') to a building's main
-      # structure. Examples include balconies, parapets and shelf angles.
-      # Highly conductive building structures (e.g. steel, aluminium) exacerbate
-      # thermal bridging effects - so building structural selection matters.
+      # Linear thermal bridges often consist of structural elements that
+      # transmit envelope structural loads (and by the same token, 'heat') to a
+      # building's main structure. Examples include balconies, parapets and
+      # shelf angles. Highly conductive building structural materials (e.g.
+      # steel, concrete) exacerbate thermal bridging - building structural
+      # choices should matter.
       #
       # The BTAP::Structure module generates such attributes, yet BTAP's costed
       # thermal bridging database doesn't yet distinguish between building
       # structures - @todo. For the moment, BTAP PSI set selection is strictly
       # based on BTAP::Structure's :framing, :cladding and :finish attributes,
-      # which must be set prior to initiating BTAP's TBD's thermal bridging
-      # solution:
-
-      # Light gauge steel framing by default. Override if wood, cmu or precast.
-      case stype
-      when :roofs  then return ROOF
-      when :floors then return FLOOR
+      # which are set prior to initiating BTAP's TBD solution.
+      case framing
+      when :wood then pair = assembly_id(WOOD5)
+      when :cmu  then pair = assembly_id(MASS2)
       else
-        case structure.framing
-        when :wood
-          c1 = WOOD5
-          c2 = WOOD7
-        when :cmu
-          c1 = MASS2
-          c2 = MASSB
-        else
-          if structure.cladding == :heavy && structure.finish == :heavy
-            c1 = MASS4
-            c2 = MASS8
-          else
-            c1 = STEL1
-            c2 = STEL2
-          end
-        end
+        pair = assembly_id(STEL1)
+        pair = assembly_id(MASS4) if cladding == :heavy && finish == :heavy
+      end
+
+      if argh.key?(:uo)
+        uo = costed_uo(pair[perform], argh[:uo])
+        perform = :hp if uo.nil?
       end
 
-      perform == :lp ? c1 : c2
+      pair[perform]
     end
 
     ##
@@ -564,229 +613,399 @@ module BTAP
     attr_reader :tally
 
     ##
-    # Initializes OpenStudio model-specific BTAP/TBD data - uprates/derates.
+    # Initializes BTAP/TBD data, uprates/derates, generates output.
     #
     # @param model [OpenStudio::Model::Model] a model
     # @param [Hash] argh BTAP/TBD argument hash
-    # @option argh [BTAP::Structure] structure a BTAP STRUCTURE object
-    # @option argh [Hash] walls exterior wall parameters e.g. :uo, :ut
-    # @option argh [Hash] floors exposed floor parameters e.g. :uo, :ut
-    # @option argh [Hash] roofs exterior roof parameters e.g. :uo, :ut
-    # @option argh [:good, :bad] quality derating option (if not uprating)
-    # @option argh [Boolean] interpolate if TBD interpolates among Uo (uprate)
+    # @option argh [BTAP::Structure] :structure a BTAP STRUCTURE instance
+    # @option argh [Hash] :walls exterior wall parameters (:uo, :ut)
+    # @option argh [Hash] :floors exposed floor parameters (:uo, :ut)
+    # @option argh [Hash] :roofs exterior roof parameters (:uo, :ut)
+    # @option argh [:good, :bad] :quality of thermal bridging (derating)
+    # @option argh [Boolean] :interpolate between costed Uo factors (uprating)
     def initialize(model = nil, argh = {})
-      btp       = BTAP::Resources::Envelope::Constructions # alias
-      mth       = "BTAP::Bridging::#{__callee__}"
-      @model    = {}
-      @tally    = {}
+      mth = "BTAP::Bridging::#{__callee__}"
+
+      # Track warnings & errors.
       @feedback = {logs: []}
-      lgs       = @feedback[:logs]
+      lgs = @feedback[:logs]
+
+      # Store model & arguments.
+      @model = {osm: model, argh: argh}
 
-      # Populate and validate BTAP/TBD & OpenStudio model parameters. This does
+      # Validate and populate BTAP/TBD & OpenStudio model parameters. This does
       # a safe TBD trial run, returning true if successful. If false, TBD leaves
       # the model unaltered. Check @feedback logs.
-      return unless self.populate(model, argh)
+      return unless populate
 
-      # Initialize loop controls and flags.
-      initial  = true
-      complies = false
-      comply   = {} # specific to :walls, :floors & :roofs (if uprating)
-      perform  = :lp
-      quality  = argh[:quality] == :good ? :good : :bad
-      combo    = "#{perform.to_s}_#{quality.to_s}".to_sym # e.g. :lp_bad
-      args     = {} # TBD's own argument hash
-
-      # Initialize surface types & TBD arguments for iterative uprating runs.
-      @model[:stypes].each do |stypes|
-        next unless argh[stypes].key?(:ut)
-
-        stype  = stypes.to_s.chop
-        uprate = "uprate_#{stypes.to_s}".to_sym
-        option = "#{stype}_option".to_sym
-        ut     = "#{stype}_ut".to_sym
-
-        args[uprate] = true
-        args[option] = "ALL #{stype} constructions"
-        args[ut    ] = argh[stypes][:ut]
+      # Tracking uprating success, separately for :walls, :roofs vs :floors.
+      comply = {}
 
-        comply[stypes] = false
-      end
+      # TRUE if TBD successfully uprates all surface types.
+      complies = false
 
-      # Building-wide PSI set.
-      @model[:constructions].values.each do |v|
-        args[:io_path] = v[combo] if v.key?(combo)
-      end
+      # Initialize TBD's own argument hash.
+      args = {option: "", io_path: inputs( @model[:quality] )}
 
-      return false if args[:io_path].nil?
+      # Uprating? Possibly 2x trial runs to identify candidate constructions.
+      2.times do |i|
+        break unless @model[:uprating]
+        break if complies
+        break if @model[:quality] == :good && i > 0
 
-      args[:option ] = ""
+        # Reset overall PSI factor quality.
+        @model[:quality] = :good unless i.zero?
 
-      loop do
-        if initial
-          initial = false
-        else
-          # Subsequent uprating runs. Upgrade technologies. Reset TBD args.
-          if quality == :bad
-            quality = :good
-            combo   = "#{perform.to_s}_#{quality.to_s}".to_sym
+        # Reset TBD arguments.
+        args = {option: "", io_path: inputs( @model[:quality] )}
 
-            @model[:constructions].values.each do |v|
-              args[:io_path] = v[combo] if v.key?(combo)
-            end
-          elsif perform == :lp
-            # Switch 'perform' from :lp to :hp - reset quality to :bad.
-            perform = :hp
-            quality = :bad
-            combo   = "#{perform.to_s}_#{quality.to_s}".to_sym
-
-            @model[:constructions].values.each do |v|
-              args[:io_path] = v[combo] if v.key?(combo)
-            end
-          end
+        # Add surface type (uprating) inputs to TBD argument hash.
+        @model[:stypes].each do |stypes, u|
+          stype  = stypes.to_s.chop               # e.g. "wall" (from :walls)
+          uprate = "uprate_#{stypes.to_s}".to_sym # e.g. :uprate_walls
+          option = "#{stype}_option".to_sym       # e.g. :wall_option
+          ut     = "#{stype}_ut".to_sym           # e.g. :wall_ut
 
-          # Delete previously-generated TBD args Uo key/value pairs.
-          @model[:stypes].each do |stypes|
-            next unless comply.key?(stypes)
+          args[uprate] = true
+          args[option] = "ALL #{stype} constructions"
+          args[ut    ] = u[:ut]
 
-            uo = "#{stypes.to_s.chop}_uo".to_sym
-            args.delete(uo) if args.key?(uo)
-          end
+          comply[stypes] = false
         end
 
-        # Run TBD on cloned OpenStudio model - compliant combo?
+        # Trial runs on cloned OpenStudio model.
         mdl = OpenStudio::Model::Model.new
         mdl.addObjects(model.toIdfFile.objects)
         TBD.clean!
+        TBD.process(mdl, args)
+
+        # If uprating is successful, TBD 'args' hash holds (new) uprated Uo
+        # keys/values for :walls, :floors and/or :roofs.
+        complies = true
+
+        # Even if all constructions were successfully uprated by TBD, BTAP
+        # may not hold costed assembly variants that match required targets.
+        # If TBD-uprated Uo factors are lower than any of these admissible
+        # BTAP Uo factors, the solution logs the failed attempt and defaults
+        # to the lowest Uo factors in the BTAP costing database.
+        @model[:stypes].keys.each do |stypes|
+          break unless complies
+
+          # Initialize.
+          comply[stypes] = true
 
-        # fil = File.join("/Users/rd2/Desktop/test.osm")
-        # mdl.save(fil, true)
+          stype_uo = "#{stypes.to_s.chop}_uo".to_sym
+          target   = args.key?(stype_uo) ? args[stype_uo] : nil
+
+          unless target
+            comply[stypes] = false
+            complies = false
+            next
+          else
+            bOPTs         = {} # building
+            bOPTs[:id   ] = @model[:building][stypes][:id]
+            bOPTs[:stype] = stypes
+            bOPTs[:uo   ] = target
+            bID = costed_assembly(bOPTs)
+
+            unless costed_uo(bID, target)
+              comply[stypes] = false
+              complies = false
+              next
+            end
+
+            unless @model[:attic][stypes].empty?
+              types = case stypes
+                      when :roofs  then :floors
+                      when :floors then :roofs
+                      else              :walls
+                      end
+
+              aOPTs         = {} # attic(s)
+              aOPTs[:id   ] = @model[:attic][types][:id]
+              aOPTs[:stype] = types
+              aOPTs[:uo   ] = target
+              aID = costed_assembly(aOPTs)
+
+              unless costed_uo(aID, target)
+                comply[types] = false
+                complies = false
+                next
+              end
+            end
 
-        res = TBD.process(mdl, args)
+            @model[:spaces].each do |id, sp|
+              break unless comply[stypes]
 
-        # Halt all processes if fatal errors raised by TBD (e.g. badly formatted
-        # TBD arguments, poorly-structured OpenStudio models).
-        if TBD.fatal?
-          TBD.logs.each { |lg| lgs << lg[:message] if lg[:level] == TBD::FTL }
-          break
+              sOPTs         = {} # customized spaces
+              sOPTs[:id   ] = sp[stypes][:id]
+              sOPTs[:stype] = stypes
+              sOPTs[:uo   ] = target
+              sID = costed_assembly(sOPTs)
+
+              unless costed_uo(sID, target)
+                comply[stypes] = false
+                complies = false
+                next
+              end
+            end
+          end
         end
 
-        complies = true
-        # Check if TBD-uprated Uo factors are valid: TBD args hash holds (new)
-        # uprated Uo keys/values for :walls, :floors and/or :roofs if uprating
-        # is successful. In most cases, uprating tends to fail for wall
-        # constructions rather than roof or floor constructions, due to the
-        # typically larger density of linear thermal bridging per surface area
-        # Yet even if all constructions were successfully uprated by TBD, one
-        # must then determine if BTAP holds admissible (i.e. costed) assembly
-        # variants with corresponding Uo factors. If TBD-uprated Uo factors are
-        # lower than any of these admissible BTAP Uo factors, then no
-        # commercially available solution can been identified.
-        @model[:stypes].each do |stypes|
-          next unless comply.key?(stypes) # true only if uprating
-
-          # TBD-estimated Uo target to meet NECB-required Ut - nil if invalid.
+        # Skip if first iteration fails.
+        next if i.zero? && complies == false
+
+        @model[:stypes].each do |stypes, u|
           stype_uo = "#{stypes.to_s.chop}_uo".to_sym
           target   = args.key?(stype_uo) ? args[stype_uo] : nil
-          assembly = self.costed_assembly(argh[:structure], stypes, perform)
 
-          uo = target ? self.costed_uo(assembly, target) : nil
+          if target
+            u[:uo] = target
+
+            bOPTs         = {} # building
+            bOPTs[:id   ] = @model[:building][stypes][:id]
+            bOPTs[:stype] = stypes
+            bOPTs[:uo   ] = target
+            bID = costed_assembly(bOPTs)
+
+            @model[:building][stypes][:id] = bID
+            bUo = costed_uo(bID, target)
+
+            if bUo
+              bUo = target if @model[:interpolate]
 
-          if uo
-            uo = target if argh[:interpolate]
-            comply[stypes] = true
+              # Candidate construction successfully identified.
+              @model[:building][stypes][:compliant] = true
+              @model[:building][stypes][:uo       ] = bUo
+            else
+              bUo = lowest_uo(bID)
+              comply[stypes] = false
+              complies = false
+
+              # Fallback.
+              @model[:building][stypes][:compliant] = false
+              @model[:building][stypes][:uo       ] = bUo
+            end
+
+            unless @model[:attic][stypes].empty?
+              types = case stypes
+                      when :roofs  then :floors
+                      when :floors then :roofs
+                      else              :walls
+                      end
+
+              aOPTs         = {} # attic
+              aOPTs[:id   ] = @model[:attic][types][:id]
+              aOPTs[:stype] = types
+              aOPTs[:uo   ] = target
+              aID = costed_assembly(aOPTs)
+
+              @model[:attic][types][:id] = aID
+              aUo = costed_uo(aID, target)
+
+              if aUo
+                aUo = target if @model[:interpolate]
+
+                # Candidate construction successfully identified.
+                @model[:attic][types][:compliant] = true
+                @model[:attic][types][:uo       ] = aUo
+              else
+                aUo = lowest_uo(aID)
+                comply[types] = false
+                complies = false
+
+                # Fallback.
+                @model[:attic][types][:compliant] = false
+                @model[:attic][types][:uo       ] = aUo
+              end
+            end
+
+            @model[:spaces].each do |id, sp|
+              sOPTs         = {} # customized space(s)
+              sOPTs[:id   ] = sp[stypes][:id]
+              sOPTs[:stype] = stypes
+              sOPTs[:uo   ] = target
+              sID = costed_assembly(sOPTs)
+
+              sp[stypes][:id] = sID
+              sUo = costed_uo(sID, target)
+
+              if sUo
+                sUo = target if @model[:interpolate]
+
+                # Candidate construction successfully identified.
+                sp[stypes][:compliant] = true
+                sp[stypes][:uo       ] = sUo
+              else
+                sUo = lowest_uo(sID)
+                comply[stypes] = false
+                complies = false
+
+                # Fallback.
+                sp[stypes][:compliant] = false
+                sp[stypes][:uo] = sUo
+              end
+            end
           else
-            uo = self.lowest_uo(assembly)
             comply[stypes] = false
-          end
+            complies = false
+
+            bID = @model[:building][stypes][:id]
+            bUo = lowest_uo(bID)
+
+            bOPTs         = {}
+            bOPTs[:id   ] = bID
+            bOPTs[:stype] = stypes
+            bOPTs[:uo   ] = bUo
+            bID = costed_assembly(bOPTs)
+            bUo = costed_uo(bID, bUo)
+
+            @model[:building][stypes][:compliant] = false
+            @model[:building][stypes][:id       ] = bID
+            @model[:building][stypes][:uo       ] = bUo
+
+            u[:uo] = bUo
+
+            unless @model[:attic][stypes].empty?
+              types = case stypes
+                      when :roofs  then :floors
+                      when :floors then :roofs
+                      else              :walls
+                      end
+
+              aID = @model[:building][types][:id]
+              aUo = lowest_uo(aID)
+
+              aOPTs         = {}
+              aOPTs[:id   ] = aID
+              aOPTs[:stype] = types
+              aOPTs[:uo   ] = aUo
+              aID = costed_assembly(aOPTs)
+              aUo = costed_uo(aID, aUo)
+
+              @model[:attic][types][:compliant] = false
+              @model[:attic][types][:id       ] = aID
+              @model[:attic][types][:uo       ] = aUo
+            end
 
-          @model[:constructions].each do |lc, v|
-            next unless v[:stypes] == stypes
+            @model[:spaces].each do |id, sp|
+              sID = sp[stypes][:id]
+              sUo = lowest_uo(sID)
 
-            v[:uo] = uo
-            v[:compliant] = comply[stypes]
-          end
+              sOPTs         = {}
+              sOPTs[:id   ] = sID
+              sOPTs[:stype] = stypes
+              sOPTs[:uo   ] = sUo
+              sID = costed_assembly(sOPTs)
+              sUo = costed_uo(sID, sUo)
 
-          complies = false unless comply[stypes]
+              sp[stypes][:compliant] = false
+              sp[stypes][:id       ] = sID
+              sp[stypes][:uo       ] = sUo
+            end
+          end
         end
-
-        # Exit if successful or if final BTAP uprating option.
-        break if combo == :hp_good
-        break if complies
       end
 
       # Post-loop steps (if uprating).
-      @model[:stypes].each do |stypes|
+      @model[:stypes].each do |stypes, u|
         next unless comply.key?(stypes) # true only if uprating
 
-        # Cancel uprating request before final derating.
-        stype  = stypes.to_s.chop
-        uprate = "uprate_#{stypes.to_s}".to_sym
-        option = "#{stype}_option".to_sym
-        ut     = "#{stype}_ut".to_sym
-        args.delete(uprate)
-        args.delete(option)
-        args.delete(ut)
-
         # Reset uprated Uo factor for each 'deratable' construction.
-        @model[:constructions].each do |lc, v|
-          next unless v[:stypes] == stypes
+        bLC  = @model[:building][stypes][:lc]
+        bFr  = @model[:building][stypes][:film]
+        bIx  = @model[:building][stypes][:indx]
+        bUo  = @model[:building][stypes][:uo]
+        bRSI = TBD.resetUo(bLC, bFr, bIx, bUo)
+
+        # Re/set Uo as AdditionalProperty:
+        addprop(bLC, "btap_uo", bUo)
+
+        # Repeat for attics (if applicable).
+        unless @model[:attic][stypes].empty?
+          types = case stypes
+                  when :roofs  then :floors
+                  when :floors then :roofs
+                  else              :walls
+                  end
+
+          aLC  = @model[:attic][types][:lc]
+          aFr  = @model[:attic][types][:film]
+          aIx  = @model[:attic][types][:indx]
+          aUo  = @model[:attic][types][:uo]
+          aRSI = TBD.resetUo(aLC, aFr, aIx, aUo)
+
+          # Re/set Uo as AdditionalProperty:
+          addprop(aLC, "btap_uo", aUo)
+        end
 
-          v[:r] = TBD.resetUo(lc, v[:filmRSI], v[:index], v[:uo])
+        # Repeat for customized spaces (if applicable).
+        @model[:spaces].values.each do |sp|
+          sLC = sp[stypes][:lc]
+          sFr = sp[stypes][:film]
+          sIx = sp[stypes][:indx]
+          sUo = sp[stypes][:uo]
+          sRSI = TBD.resetUo(sLC, sFr, sIx, sUo)
+
+          # Re/set Uo as AdditionalProperty:
+          addprop(sLC, "btap_uo", sUo)
         end
       end
 
-      @model[:comply  ] = comply
-      @model[:complies] = complies
-      @model[:perform ] = perform
-      @model[:quality ] = quality
-      @model[:combo   ] = combo
+      complies = true unless @model[:uprating]
+      @model[:comply  ] = comply   # true/false, specific to surface type
+      @model[:complies] = complies # true/false for entire model
+
+      # Log NECB Part 3 prescriptive compliance as AdditionalProperty.
+      if @model[:uprating]
+        model.getBuilding.additionalProperties.setFeature("tbd_compliance", complies)
+      end
 
       # Run "process" TBD one last time, on "model" (not cloned "mdl").
+      args = {option: "", io_path: inputs( @model[:quality] )}
       TBD.clean!
-      res = TBD.process(model, args)
+      TBD.process(model, args)
 
-      @model[:io      ] = res[:io      ] # TBD outputs (i.e. "tbd.out.json")
-      @model[:surfaces] = res[:surfaces] # TBD derated surface data
-      @model[:argh    ] = argh           # method argument hash
-      @model[:args    ] = args           # last TBD inputs (i.e. "tbd.json")
+      @model[:args    ] = args # last TBD inputs (i.e. "tbd.json")
+      @model[:io      ] = args[:io]
+      @model[:surfaces] = args[:surfaces]
 
-      self.gen_tallies                   # tallies for BTAP costing
-      self.gen_feedback                  # log success messages for BTAP
+      gen_tallies  # tallies for BTAP costing
+      gen_feedback # log success messages for BTAP
     end
 
     ##
-    # Populates and validates BTAP/TBD & OpenStudio model parameters for thermal
-    # bridging. This also does a safe TBD trial run, returning true if
-    # successful. Check @feedback logs if false.
-    #
-    # @param model [OpenStudio::Model::Model] a model
-    # @param [Hash] argh BTAP/TBD argument hash
-    # @option argh [BTAP::Structure] structure a BTAP STRUCTURE object
-    # @option argh [Hash] walls exterior wall parameters e.g. :uo, :ut
-    # @option argh [Hash] floors exposed floor parameters e.g. :uo, :ut
-    # @option argh [Hash] roofs exterior roof parameters e.g. :uo, :ut
-    # @option argh [Symbol] quality derating option (if not uprating)
-    # @option argh [Boolean] interpolate if TBD should pick between Uo values
+    # Minimally validates an OpenStudio model, as well as BTAP/TBD parameters,
+    # towards thermal bridging calculations. This also does a safe TBD trial
+    # run, returning true if successful. Check @feedback logs if false.
+    # AdditionalProperties may be re/set in the OpenStudio model.
     #
     # @return [Boolean] true if valid (check @feedback logs if false)
-    def populate(model = nil, argh = {})
-      mth  = "BTAP::Bridging::#{__callee__}"
-      args = { option: "(non thermal bridging)" } # for initial TBD dry run
-      lgs  = @feedback[:logs]
-      cl   = OpenStudio::Model::LayeredConstruction
+    def populate()
+      mth = "BTAP::Bridging::#{__callee__}"
+      lgs = @feedback[:logs]
+      cl  = OpenStudio::Model::LayeredConstruction
+
+      model = @model[:osm]
+      argh  = @model[:argh]
 
+      # Valid model?
       unless model.is_a?(OpenStudio::Model::Model)
         lgs << "Invalid OpenStudio model to de/up-rate (#{mth})"
         return false
       end
 
+      # Valid argument hash?
       unless argh.is_a?(Hash)
         lgs << "Invalid BTAP/TBD argument Hash (#{mth})"
         return false
       end
 
+      # Valid BTAP::Structure instance?
       if argh.key?(:structure)
-        unless argh[:structure].is_a?(BTAP::Structure)
+        stc = argh[:structure]
+
+        unless stc.is_a?(BTAP::Structure)
           lgs << "Invalid BTAP::Structure (#{mth})"
           return false
         end
@@ -795,15 +1014,10 @@ module BTAP
         return false
       end
 
-      # Building-wide envelope (e.g. assemblies, U-factors, PSI-factors) options
-      # depend on building structure-dependent features such as framing,
-      # cladding, etc. This will need to adapt to upcoming story/space
-      # construction/PSI customization - @todo.
-      strc = argh[:structure]
-
-      argh[:interpolate] = false unless argh.key?(:interpolate)
-      argh[:interpolate] = false unless [true, false].include?(argh[:interpolate])
+      # Uprating? Initialize.
+      @model[:uprating] = false
 
+      # All 3 surface types initiated?
       [:walls, :floors, :roofs].each do |stypes|
         unless argh.key?(stypes)
           lgs << "Missing BTAP/TBD #{stypes} (#{mth})"
@@ -824,6 +1038,8 @@ module BTAP
 
         next unless argh[stypes].key?(:ut)
 
+        # Uprating!
+        @model[:uprating] = true if stypes == :walls
         ut = argh[stypes][:ut]
 
         unless ut.is_a?(Numeric) && ut.between?(TBD::UMIN, TBD::UMAX)
@@ -832,230 +1048,802 @@ module BTAP
         end
       end
 
-      # Run TBD on a cloned OpenStudio model (dry run).
+      # When uprating: interpolating between discrete Uo factors?
+      @model[:interpolate] = argh.key?(:interpolate) ? argh[:interpolate] : true
+      @model[:interpolate] = false unless @model[:interpolate] == true
+
+      # Selected PSI factor quality (:good or :bad):
+      #   - required when strictly derating
+      #   - iteratively reset when uprating
+      @model[:quality] = argh.key?(:quality) ? argh[:quality] : :bad
+      @model[:quality] = :bad unless @model[:quality] == :good
+
+      # NECB 2011-2015 Uo targets.
+      wUo = argh[:walls ][:uo]
+      rUo = argh[:roofs ][:uo]
+      fUo = argh[:floors][:uo]
+
+      # NECB 2017-2025 Ut targets - Uo is reset when uprating.
+      wUt = argh[:walls ].key?(:ut) ? argh[:walls ][:ut] : wUo
+      rUt = argh[:roofs ].key?(:ut) ? argh[:roofs ][:ut] : rUo
+      fUt = argh[:floors].key?(:ut) ? argh[:floors][:ut] : fUo
+
+      # Track building, attic(s), customized spaces & actual surface types.
+      @model[:building] = {walls: {}, roofs: {}, floors: {}}
+      @model[:attic   ] = {walls: {}, roofs: {}, floors: {}}
+      @model[:spaces  ] = {}
+      @model[:stypes  ] = {}
+
+      # Track constructions. REMOVE @todo.
+      @model[:constructions] = {}
+
+      # Track 'building' default construction set.
+      bldg = model.getBuilding
+      bset = bldg.defaultConstructionSet
+
+      if bset.empty?
+        lgs << "No BUILDING default construction set (#{mth})"
+        return false
+      end
+
+      bset = bset.get
+      extC = bset.defaultExteriorSurfaceConstructions
+
+      if extC.empty?
+        lgs << "No BUILDING default exterior constructions (#{mth})"
+        return false
+      end
+
+      wallC   = extC.get.wallConstruction
+      roofC   = extC.get.roofCeilingConstruction
+      floorC  = extC.get.floorConstruction
+
+      if wallC.empty? || roofC.empty? || floorC.empty?
+        lgs << "Missing BUILDING default exterior constructions (#{mth})"
+        return false
+      end
+
+      wallC   = wallC.get.to_LayeredConstruction
+      roofC   = roofC.get.to_LayeredConstruction
+      floorC  = floorC.get.to_LayeredConstruction
+
+      if wallC.empty? || roofC.empty? || floorC.empty?
+        lgs << "BUILDING default exterior layered constructions (#{mth})"
+        return false
+      end
+
+      wallC   = wallC.get
+      roofC   = roofC.get
+      floorC  = floorC.get
+      walliL  = TBD.insulatingLayer(wallC)
+      roofiL  = TBD.insulatingLayer(roofC)
+      flooriL = TBD.insulatingLayer(floorC)
+
+      if walliL[:index].nil? || roofiL[:index].nil? || flooriL.nil?
+        lgs << "Missing BUILDING insulating layer(s) (#{mth})"
+        return false
+      end
+
+      # Previously-assigned BTAP-costed surface air film resistances?
+      wFR = prop(wallC,  "btap_film", Float)
+      rFR = prop(roofC,  "btap_film", Float)
+      fFR = prop(floorC, "btap_film", Float)
+      wFR = 0 unless wFR
+      rFR = 0 unless rFR
+      fFR = 0 unless fFR
+
+      # Previously-assigned construction net area?
+      wM2 = prop(wallC,  "btap_area", Float)
+      rM2 = prop(roofC,  "btap_area", Float)
+      fM2 = prop(floorC, "btap_area", Float)
+
+      wM2 = wallC.getNetArea  unless wM2
+      rM2 = roofC.getNetArea  unless rM2
+      fM2 = floorC.getNetArea unless fM2
+
+      # Previously-assigned BTAP-costed construction IDs?
+      wID = prop(wallC,  "btap_id", String)
+      rID = prop(roofC,  "btap_id", String)
+      fID = prop(floorC, "btap_id", String)
+      wID = "" unless wID
+      rID = "" unless rID
+      fID = "" unless fID
+      wID = "" unless data.include?(wID)
+      rID = "" unless data.include?(rID)
+      fID = "" unless data.include?(fID)
+
+      # Fallback: BTAP-costed wall construction from STRUCTURE parameters.
+      if wID.empty?
+        opts            = {}
+        opts[:framing ] = stc.framing
+        opts[:cladding] = stc.cladding
+        opts[:finish  ] = stc.finish
+        opts[:perform ] = :lp
+        opts[:stype   ] = :walls
+        opts[:uo      ] = wUo
+        wID = BTAP::Bridging.costed_assembly(argh)
+      end
+
+      # Fallback: BTAP-costed roof construction from STRUCTURE parameters.
+      if rID.empty?
+        opts            = {}
+        opts[:framing ] = stc.framing
+        opts[:cladding] = stc.cladding
+        opts[:finish  ] = stc.finish
+        opts[:perform ] = :lp
+        opts[:stype   ] = :roofs
+        opts[:uo      ] = rUo
+        rID = BTAP::Bridging.costed_assembly(argh)
+      end
+
+      # Fallback: BTAP-costed floor construction from STRUCTURE parameters.
+      if fID.empty?
+        opts            = {}
+        opts[:framing ] = stc.framing
+        opts[:cladding] = stc.cladding
+        opts[:finish  ] = stc.finish
+        opts[:perform ] = :lp
+        opts[:stype   ] = :floors
+        opts[:uo      ] = fUo
+        fID = BTAP::Bridging.costed_assembly(argh)
+      end
+
+      addprop(bldg,   "btap_ut",   wUt)
+      addprop(bldg,   "btap_uo",   wUo)
+      addprop(bldg,   "btap_id",   wID)
+      addprop(bldg,   "btap_area", wM2)
+      addprop(bldg,   "btap_film", wFR)
+      addprop(wallC,  "btap_ut",   wUt)
+      addprop(wallC,  "btap_uo",   wUo)
+      addprop(wallC,  "btap_id",   wID)
+      addprop(wallC,  "btap_area", wM2)
+      addprop(wallC,  "btap_film", wFR)
+      addprop(roofC,  "btap_ut",   rUt)
+      addprop(roofC,  "btap_uo",   rUo)
+      addprop(roofC,  "btap_id",   rID)
+      addprop(roofC,  "btap_area", rM2)
+      addprop(roofC,  "btap_film", rFR)
+      addprop(floorC, "btap_ut",   fUt)
+      addprop(floorC, "btap_uo",   fUo)
+      addprop(floorC, "btap_id",   fID)
+      addprop(floorC, "btap_area", fM2)
+      addprop(floorC, "btap_film", fFR)
+
+      # Building shortcuts.
+      @model[:building][:walls ][:lc  ] = wallC
+      @model[:building][:roofs ][:lc  ] = roofC
+      @model[:building][:floors][:lc  ] = floorC
+      @model[:building][:walls ][:indx] = walliL[:index]
+      @model[:building][:roofs ][:indx] = roofiL[:index]
+      @model[:building][:floors][:indx] = flooriL[:index]
+      @model[:building][:walls ][:area] = wM2
+      @model[:building][:roofs ][:area] = rM2
+      @model[:building][:floors][:area] = fM2
+      @model[:building][:walls ][:id  ] = wID
+      @model[:building][:roofs ][:id  ] = rID
+      @model[:building][:floors][:id  ] = fID
+      @model[:building][:walls ][:film] = wFR
+      @model[:building][:roofs ][:film] = rFR
+      @model[:building][:floors][:film] = fFR
+      @model[:building][:walls ][:ut  ] = wUt
+      @model[:building][:roofs ][:ut  ] = rUt
+      @model[:building][:floors][:ut  ] = fUt
+      @model[:building][:walls ][:uo  ] = wUo
+      @model[:building][:roofs ][:uo  ] = rUo
+      @model[:building][:floors][:uo  ] = fUo
+
+      # Repeat for unoccupied, unconditioned spaces (e.g. crawlspaces, attics).
+      attics = []
+
+      model.getSpaces.each do |space|
+        next if space.partofTotalFloorArea
+        next unless TBD.unconditioned?(space)
+
+        attics << space
+      end
+
+      # All attic/crawlspace spaces reference the same default construction set.
+      unless attics.empty?
+        attic = attics.first
+        aset  = attic.defaultConstructionSet
+
+        unless aset.empty?
+          aset = aset.get
+
+          if aset == bset
+            lgs << "BUILDING/ATTIC shared default construction set (#{mth})"
+            return false
+          end
+
+          # Attic/crawlspace interzone constructions are insulated.
+          intC = aset.defaultInteriorSurfaceConstructions
+
+          if intC.empty?
+            lgs << "No ATTIC default interior constructions (#{mth})"
+            return false
+          end
+
+          wallC  = intC.get.wallConstruction
+          roofC  = intC.get.roofCeilingConstruction
+          floorC = intC.get.floorConstruction
+
+          if wallC.empty? || roofC.empty? || floorC.empty?
+            lgs << "Missing ATTIC default exterior constructions (#{mth})"
+            return false
+          end
+
+          wallC   = wallC.get.to_LayeredConstruction
+          roofC   = roofC.get.to_LayeredConstruction
+          floorC  = floorC.get.to_LayeredConstruction
+
+          if wallC.empty? || roofC.empty? || floorC.empty?
+            lgs << "ATTIC default interior layered constructions (#{mth})"
+            return false
+          end
+
+          wallC   = wallC.get
+          roofC   = roofC.get
+          floorC  = floorC.get
+          walliL  = TBD.insulatingLayer(wallC)
+          roofiL  = TBD.insulatingLayer(roofC)
+          flooriL = TBD.insulatingLayer(floorC)
+
+          if walliL[:index].nil? || roofiL[:index].nil? || flooriL.nil?
+            lgs << "Missing ATTIC insulating layer(s) (#{mth})"
+            return false
+          end
+
+          # Previously-assigned BTAP-costed surface air film resistances?
+          wFR = prop(wallC,  "btap_film", Float)
+          rFR = prop(roofC,  "btap_film", Float)
+          fFR = prop(floorC, "btap_film", Float)
+          wFR = 0 unless wFR
+          rFR = 0 unless rFR
+          fFR = 0 unless fFR
+
+          # Previously-assigned construction net area?
+          wM2 = prop(wallC,  "btap_area", Float)
+          rM2 = prop(roofC,  "btap_area", Float)
+          fM2 = prop(floorC, "btap_area", Float)
+          wM2 = wallC.getNetArea  unless wM2
+          rM2 = roofC.getNetArea  unless rM2
+          fM2 = floorC.getNetArea unless fM2
+
+          # Previously-assigned BTAP-costed wall construction ID?
+          wID = prop(wallC,  "btap_id", String)
+          rID = prop(roofC,  "btap_id", String)
+          fID = prop(floorC, "btap_id", String)
+          wID = "" unless wID
+          rID = "" unless rID
+          fID = "" unless fID
+          wID = "" unless data.include?(wID)
+          rID = "" unless data.include?(rID)
+          fID = "" unless data.include?(fID)
+
+          # Fallback: BTAP-costed wall construction from STRUCTURE parameters.
+          if wID.empty?
+            opts            = {}
+            opts[:framing ] = stc.framing
+            opts[:cladding] = stc.cladding
+            opts[:finish  ] = stc.finish
+            opts[:perform ] = :lp
+            opts[:stype   ] = :walls
+            opts[:uo      ] = wUo
+            wID = BTAP::Bridging.costed_assembly(argh)
+          end
+
+          # Fallback: BTAP-costed roof construction from STRUCTURE parameters.
+          if rID.empty?
+            opts            = {}
+            opts[:framing ] = stc.framing
+            opts[:cladding] = stc.cladding
+            opts[:finish  ] = stc.finish
+            opts[:perform ] = :lp
+            opts[:stype   ] = :floors # not roofs:
+            opts[:uo      ] = fUo     # not rUo
+            rID = BTAP::Bridging.costed_assembly(argh)
+          end
+
+          # Fallback: BTAP-costed floor construction from STRUCTURE parameters.
+          if fID.empty?
+            opts            = {}
+            opts[:framing ] = stc.framing
+            opts[:cladding] = stc.cladding
+            opts[:finish  ] = stc.finish
+            opts[:perform ] = :lp
+            opts[:stype   ] = :roofs # not floors
+            opts[:uo      ] = rUo    # not fUo
+            fID = BTAP::Bridging.costed_assembly(argh)
+          end
+
+          # Re/set AdditionalProperties of ATTIC interior constructions.
+          addprop(wallC,  "btap_ut",   wUt)
+          addprop(wallC,  "btap_uo",   wUo)
+          addprop(wallC,  "btap_id",   wID)
+          addprop(wallC,  "btap_area", wM2)
+          addprop(wallC,  "btap_film", wFR)
+          addprop(roofC,  "btap_ut",   fUt) # not roof Ut
+          addprop(roofC,  "btap_uo",   fUo) # not roof Uo
+          addprop(roofC,  "btap_id",   rID)
+          addprop(roofC,  "btap_area", rM2)
+          addprop(roofC,  "btap_film", rFR)
+          addprop(floorC, "btap_ut",   rUt) # not floor Ut
+          addprop(floorC, "btap_uo",   rUo) # not floor Uo
+          addprop(floorC, "btap_id",   fID)
+          addprop(floorC, "btap_area", fM2)
+          addprop(floorC, "btap_film", fFR)
+
+          # Add interior wall parameters to attic spaces.
+          attics.each do |att|
+            addprop(att, "btap_ut",   wUt)
+            addprop(att, "btap_uo",   wUo)
+            addprop(att, "btap_id",   wID)
+            addprop(att, "btap_area", wM2)
+            addprop(att, "btap_film", wFR)
+          end
+
+          # Shortcuts.
+          @model[:attic][:walls ][:lc  ] = wallC
+          @model[:attic][:roofs ][:lc  ] = roofC
+          @model[:attic][:floors][:lc  ] = floorC
+          @model[:attic][:walls ][:indx] = walliL[:index]
+          @model[:attic][:roofs ][:indx] = roofiL[:index]
+          @model[:attic][:floors][:indx] = flooriL[:index]
+          @model[:attic][:walls ][:area] = wM2
+          @model[:attic][:roofs ][:area] = rM2
+          @model[:attic][:floors][:area] = fM2
+          @model[:attic][:walls ][:id  ] = wID
+          @model[:attic][:roofs ][:id  ] = rID
+          @model[:attic][:floors][:id  ] = fID
+          @model[:attic][:walls ][:film] = wFR
+          @model[:attic][:roofs ][:film] = rFR
+          @model[:attic][:floors][:film] = fFR
+          @model[:attic][:walls ][:ut  ] = wUt
+          @model[:attic][:roofs ][:ut  ] = fUt
+          @model[:attic][:floors][:ut  ] = rUt
+          @model[:attic][:walls ][:uo  ] = wUo
+          @model[:attic][:roofs ][:uo  ] = fUo
+          @model[:attic][:floors][:uo  ] = rUo
+        end
+      end
+
+      # Repeat for customized spaces.
+      stc.spaces.each do |id, sp|
+        space = model.getSpaceByName(id)
+        next if space.empty?
+
+        space = space.get
+        sset  = space.defaultConstructionSet
+        next if sset.empty?
+
+        sset = sset.get
+        next if sset == bset
+
+        extC = sset.defaultExteriorSurfaceConstructions
+        next if extC.empty?
+
+        wallC  = extC.get.wallConstruction
+        roofC  = extC.get.roofCeilingConstruction
+        floorC = extC.get.floorConstruction
+        next if wallC.empty?
+        next if roofC.empty?
+        next if floorC.empty?
+
+        wallC   = wallC.get.to_LayeredConstruction
+        roofC   = roofC.get.to_LayeredConstruction
+        floorC  = floorC.get.to_LayeredConstruction
+        next if wallC.empty?
+        next if roofC.empty?
+        next if floorC.empty?
+
+        wallC   = wallC.get
+        roofC   = roofC.get
+        floorC  = floorC.get
+        walliL  = TBD.insulatingLayer(wallC)
+        roofiL  = TBD.insulatingLayer(roofC)
+        flooriL = TBD.insulatingLayer(floorC)
+        next if walliL[:index].nil?
+        next if roofiL[:index].nil?
+        next if flooriL[:index].nil?
+
+        # Previously-assigned BTAP-costed surface air film resistances?
+        wFR = prop(wallC,  "btap_film", Float)
+        rFR = prop(roofC,  "btap_film", Float)
+        fFR = prop(floorC, "btap_film", Float)
+        wFR = 0 unless wFR
+        rFR = 0 unless rFR
+        fFR = 0 unless fFR
+
+        # Previously-assigned construction net area?
+        wM2 = prop(wallC,  "btap_area", Float)
+        rM2 = prop(roofC,  "btap_area", Float)
+        fM2 = prop(floorC, "btap_area", Float)
+        wM2 = wallC.getNetArea  unless wM2
+        rM2 = roofC.getNetArea  unless rM2
+        fM2 = floorC.getNetArea unless fM2
+
+        # Previously-assigned BTAP-costed construction IDs?
+        wID = prop(wallC,  "btap_id", String)
+        rID = prop(roofC,  "btap_id", String)
+        fID = prop(floorC, "btap_id", String)
+        wID = "" unless wID
+        rID = "" unless rID
+        fID = "" unless fID
+        wID = "" unless data.include?(wID)
+        rID = "" unless data.include?(rID)
+        fID = "" unless data.include?(fID)
+
+        # Fallback: BTAP-costed wall construction from STRUCTURE parameters.
+        if wID.empty?
+          opts            = {}
+          opts[:framing ] = sp[:framing]
+          opts[:cladding] = sp[:cladding]
+          opts[:finish  ] = sp[:finish]
+          opts[:perform ] = :lp
+          opts[:stype   ] = :walls
+          opts[:uo      ] = wUo
+          wID = BTAP::Bridging.costed_assembly(argh)
+        end
+
+        # Fallback: BTAP-costed roof construction from STRUCTURE parameters.
+        if rID.empty?
+          opts            = {}
+          opts[:framing ] = sp[:framing]
+          opts[:cladding] = sp[:cladding]
+          opts[:finish  ] = sp[:finish]
+          opts[:perform ] = :lp
+          opts[:stype   ] = :roofs
+          opts[:uo      ] = rUo
+          rID = BTAP::Bridging.costed_assembly(argh)
+        end
+
+        # Fallback: BTAP-costed floor construction from STRUCTURE parameters.
+        if fID.empty?
+          opts            = {}
+          opts[:framing ] = sp[:framing]
+          opts[:cladding] = sp[:cladding]
+          opts[:finish  ] = sp[:finish]
+          opts[:perform ] = :lp
+          opts[:stype   ] = :floors
+          opts[:uo      ] = fUo
+          fID = BTAP::Bridging.costed_assembly(argh)
+        end
+
+        # Re/set AdditionalProperties to space exterior constructions.
+        addprop(space,  "btap_ut",   wUt)
+        addprop(space,  "btap_uo",   wUo)
+        addprop(space,  "btap_id",   wID)
+        addprop(space,  "btap_area", wM2)
+        addprop(space,  "btap_film", wFR)
+        addprop(wallC,  "btap_ut",   wUt)
+        addprop(wallC,  "btap_uo",   wUo)
+        addprop(wallC,  "btap_id",   wID)
+        addprop(wallC,  "btap_area", wM2)
+        addprop(wallC,  "btap_film", wFR)
+        addprop(roofC,  "btap_ut",   rUt)
+        addprop(roofC,  "btap_uo",   rUo)
+        addprop(roofC,  "btap_id",   rID)
+        addprop(roofC,  "btap_area", rM2)
+        addprop(roofC,  "btap_film", rFR)
+        addprop(floorC, "btap_ut",   fUt)
+        addprop(floorC, "btap_uo",   fUo)
+        addprop(floorC, "btap_id",   fID)
+        addprop(floorC, "btap_area", fM2)
+        addprop(floorC, "btap_film", fFR)
+
+        @model[:spaces][id] = {walls: {}, roofs: {}, floors: {}}
+
+        # Custom space shortcuts.
+        @model[:spaces][id][:walls ][:lc  ] = wallC
+        @model[:spaces][id][:roofs ][:lc  ] = roofC
+        @model[:spaces][id][:floors][:lc  ] = floorC
+        @model[:spaces][id][:walls ][:indx] = walliL[:index]
+        @model[:spaces][id][:roofs ][:indx] = roofiL[:index]
+        @model[:spaces][id][:floors][:indx] = flooriL[:index]
+        @model[:spaces][id][:walls ][:area] = wM2
+        @model[:spaces][id][:roofs ][:area] = rM2
+        @model[:spaces][id][:floors][:area] = fM2
+        @model[:spaces][id][:walls ][:id  ] = wID
+        @model[:spaces][id][:roofs ][:id  ] = rID
+        @model[:spaces][id][:floors][:id  ] = fID
+        @model[:spaces][id][:walls ][:film] = wFR
+        @model[:spaces][id][:roofs ][:film] = rFR
+        @model[:spaces][id][:floors][:film] = fFR
+        @model[:spaces][id][:walls ][:ut  ] = wUt
+        @model[:spaces][id][:roofs ][:ut  ] = rUt
+        @model[:spaces][id][:floors][:ut  ] = fUt
+        @model[:spaces][id][:walls ][:uo  ] = wUo
+        @model[:spaces][id][:roofs ][:uo  ] = rUo
+        @model[:spaces][id][:floors][:uo  ] = fUo
+      end
+
+      # Dry TBD run on a clone of the OpenStudio model.
       mdl = OpenStudio::Model::Model.new
       mdl.addObjects(model.toIdfFile.objects)
+
+      args = {option: "", io_path: inputs( @model[:quality] )}
       TBD.clean!
-      res = TBD.process(mdl, args)
+      TBD.process(mdl, args)
 
-      # TBD validation of OpenStudio model.
       if TBD.fatal? || TBD.error?
         lgs << "TBD-identified FATAL error(s):"     if TBD.fatal?
         lgs << "TBD-identified non-FATAL error(s):" if TBD.error?
-
         TBD.logs.each { |log| lgs << log[:message] }
         return false if TBD.fatal?
       end
 
-      # Fetch number of stories in OpenStudio model.
-      stories = model.getBuilding.standardsNumberOfAboveGroundStories
-      stories = stories.get                  unless stories.empty?
-      stories = model.getBuildingStorys.size unless stories.is_a?(Integer)
-
-      # Story/space construction/PSI customization is yet to be implemented.
-      # Keeping placeholders for now - @todo.
-      @model[:stories] = stories.clamp(1, 999)
-      @model[:spaces ] = {}
-
-      # Initialize deratable opaque, layered constructions & surface types.
-      @model[:constructions] = {}
-      @model[:stypes       ] = []
-
-      if res[:surfaces].nil?
+      if args[:surfaces].nil? || args[:surfaces].empty?
         lgs << "No deratable surfaces in model (#{mth})"
         return false
       end
 
-      # TBD surface objects hold certain attributes (keys) to signal if they're
-      # deratable. Concentrating only on those. Relying on reported strings
-      # (e.g. surface identifier) or integers (e.g. a layer :index) seems fine.
-      # Yet referecing TBD-cloned OpenStudio objects (e.g. key :construction)
-      # is a no-no (e.g. seg faults).
-      res[:surfaces].each do |id, surface|
+      if args[:io][:edges].empty?
+        lgs << "No deratable linear thermal bridge edges in model (#{mth})"
+        return false
+      end
+
+      # Process surfaces deemed 'deratable' by TBD.
+      args[:surfaces].each do |identifier, surface|
         next unless surface.key?(:type)      # :wall, :ceiling or :floor
-        next unless surface.key?(:filmRSI)   # sum of air film resistances
+        next unless surface.key?(:net)       # surface net area
         next unless surface.key?(:index)     # deratable layer index
         next unless surface.key?(:r)         # deratable layer RSi
         next unless surface.key?(:deratable) # true or false
-
         next unless surface[:deratable]
-        next unless surface[:index    ]
+        next unless surface[:index]
 
         stypes = case surface[:type]
                  when :wall    then :walls
                  when :floor   then :floors
                  when :ceiling then :roofs
-                 else ""
+                 else next
                  end
 
-        next if stypes.empty?
+        # Track deratable surface types, e.g. any exposed :floors?
+        unless @model[:stypes].include?(stypes)
+          @model[:stypes][stypes] = {uo: argh[stypes][:uo]}
 
-        # Track surface type.
-        @model[:stypes] << stypes unless @model[:stypes].include?(stypes)
-
-        # Track TBD-targeted constructions for uprating/derating.
-        srf = model.getSurfaceByName(id)
-
-        if srf.empty?
-          lgs << "Mismatched surface: #{id} (#{mth})?"
-          return false
+          if argh[stypes].key?(:ut)
+            @model[:stypes][stypes][:ut] = argh[stypes][:ut]
+          else
+            @model[:stypes][stypes][:ut] = argh[stypes][:uo]
+          end
         end
+      end
 
-        srf = srf.get
-        space = srf.space
+      true
+    end
 
-        if space.empty?
-          lgs << "Missing space: #{id} (#{mth})?"
-          return false
-        end
+    ##
+    # Assigns a BTAP attribute (as AdditionalProperty) to an OpenStudio Model
+    # object, e.g. a building, one or more spaces, layered constructions.
+    #
+    # @param obj [-] one or more OpenStudio::Model objects
+    # @param tag [#to_sym] attribute identifier
+    # @param prp [#to_sym or Numeric] attribute (or property)
+    #
+    # @return [Boolean] true if successful
+    def addprop(obj = nil, tag = "", prp = "")
+      return false unless tag.respond_to?(:to_sym)
 
-        space = space.get
-        lc = srf.construction
+      # 1x OpenStudio::Model object, or multiple similar objects?
+      obj = obj.respond_to?(:to_a) ? obj.to_a : [obj]
+      return false unless obj.first.respond_to?(:model)
 
-        if lc.empty?
-          lgs << "Mismatched construction: #{id} (#{mth})?"
-          return false
-        end
+      cls = obj.first.class
+      tag = tag.to_s
+      return false if tag.empty?
 
-        lc = lc.get.to_LayeredConstruction
+      obj.each { |ob| return false unless ob.is_a?(cls) }
 
-        if lc.empty?
-          lgs << "Mismatched layered construction: #{id} (#{mth})?"
-          return false
-        end
+      if prp.respond_to?(:to_sym)
+        prp = prp.to_s
+        return false if prp.empty?
+      else
+        return false unless prp.is_a?(Numeric)
+      end
 
-        lc = lc.get
-
-        unless @model[:constructions].key?(lc)
-          @model[:constructions][lc]             = {}
-          @model[:constructions][lc][:index    ] = surface[:index]   # material
-          @model[:constructions][lc][:r        ] = surface[:r]       # material
-          @model[:constructions][lc][:filmRSI  ] = surface[:filmRSI] # assembly
-          @model[:constructions][lc][:uo       ] = nil               # assembly
-          @model[:constructions][lc][:compliant] = nil               # assembly
-          @model[:constructions][lc][:stypes   ] = []
-          @model[:constructions][lc][:surfaces ] = []
-          @model[:constructions][lc][:spaces   ] = []
-
-          # Generate TBD input hashes for both :good & :bad PSI factor sets.
-          # This depends solely on assigned wall constructions (e.g. steel- vs
-          # wood-framed) - not roof or floor constructions. Until space- and
-          # storey-specific structure/construction customization is enabled in
-          # BTAP, this is set for the entire building. In other words - for now
-          # - there should be a single assigned layered construction for all
-          # walls in a BTAP-altered OpenStudio model.
-          if stypes == :walls
-            @model[:constructions][lc][:lp_bad ] = self.inputs(strc, :lp, :bad )
-            @model[:constructions][lc][:lp_good] = self.inputs(strc, :lp, :good)
-            @model[:constructions][lc][:hp_bad ] = self.inputs(strc, :hp, :bad )
-            @model[:constructions][lc][:hp_good] = self.inputs(strc, :hp, :good)
-          end
-        end
+      obj.each { |ob| ob.additionalProperties.setFeature(tag, prp) }
 
-        # Select lowest applicable air film resistances (given surface slope).
-        film = [@model[:constructions][lc][:filmRSI], surface[:filmRSI]].min
+      true
+    end
 
-        @model[:constructions][lc][:filmRSI ] = film
-        @model[:constructions][lc][:stypes  ] << stypes           # 1x
-        @model[:constructions][lc][:surfaces] << id               # many
-        @model[:constructions][lc][:spaces  ] << space.nameString # less
+    ##
+    # Fetches a BTAP attribute (as AdditionalProperty), from an OpenStudio Model
+    # object, e.g. a building, a space, a layered construction.
+    #
+    # @param obj [#model] an OpenStudio::Model object
+    # @param tag [#to_sym] attribute tag
+    # @param typ [-] attribute type, e.g. String, Symbol, Integer
+    #
+    # @return [String or Float] attribute value (nil if invalid input)
+    def prop(obj = nil, tag = "", typ = nil)
+      return nil unless obj.respond_to?(:model)
+      return nil unless tag.respond_to?(:to_sym)
+
+      tag = tag.to_s
+      return nil if tag.empty?
+
+      if typ == Integer
+        prp = obj.additionalProperties.getFeatureAsInteger(tag)
+      elsif typ <= Numeric
+        prp = obj.additionalProperties.getFeatureAsDouble(tag)
+      else
+        prp = obj.additionalProperties.getFeatureAsString(tag)
       end
 
-      # Loop through all tracked deratable constructions. Ensure a single
-      # surface type per construction. Ensure at least one wall construction.
-      @model[:constructions].values.each { |v| v[:stypes].uniq! }
-      nb = 0
+      prp.empty? ? nil : prp.get
+    end
 
-      @model[:constructions].each do |lc, v|
-        if v[:stypes].size != 1
-          lgs << "Multiple surface types per construction (#{mth})?"
-          return false
-        else
-          v[:stypes] = v[:stypes].first
+    ##
+    # Generates TBD input hash. Relies on OpenStudio model, BTAP::Structure
+    # attributes and additional parameters set at initialization.
+    #
+    # @param quality [:good, :bad] thermal bridging PSI set quality
+    #
+    # @return [Hash] TBD inputs (empty if invalid input)
+    def inputs(quality = :good)
+      argh = @model[:argh]
+      mdl  = @model[:osm]
 
-          # Assign construction for each deratable surface.
-          v[:surfaces].each do |id|
-            surface = model.getSurfaceByName(id)
-            next if surface.empty?
+      # PSI set quality?
+      quality = :good unless quality == :bad
 
-            surface.get.setConstruction(lc)
-          end
-        end
+      # Initialize TBD input hash.
+      input  = {}
+      psis   = {} # construction-specific PSI sets
+      spaces = {} # custom space-specific PSI references
 
-        nb += 1 if v[:stypes] == :walls
-      end
+      # A single, default PSI-factor set for the building.
+      bldg = @model[:building]
+      bID  = bldg[:walls][:id]
+      bPSI = set(bID, quality)
+      psis[ bPSI[:id] ] = bPSI
 
-      if nb < 1
-        lgs << "No deratable walls (#{mth})?"
-        return false
-      end
+      # Repeat for customized spaces, e.g.
+      #   - "cmu" gymnasium walls in an otherwise "steel" post/frame school
+      @model[:spaces].each do |id, sp|
+        cID = sp[:walls ][:id]
+        next if cID == bID
 
-      @model[:osm] = model
+        # Fetch BTAP PSI factor set identifier, e.g. STEL1_GOOD
+        cPSI = set(cID, quality)
+        next if psis.key?( cPSI[:id] )
 
-      true
-    end
+        # Append customized PSI-factor set.
+        psis[ cPSI[:id] ] = cPSI
 
-    ##
-    # Generate TBD input hash.
-    #
-    # @param structure [BTAP::Structure] a BTAP STRUCTURE object
-    # @param perform [Symbol] :lp or :hp wall variant
-    # @param quality [Symbol] :bad or :good PSI-factor
-    #
-    # @return [Hash] TBD inputs
-    def inputs(structure = nil, perform = :hp, quality = :good)
-      input   = {}
-      psis    = {} # construction-specific PSI sets
-      perform = :hp   unless [:lp, :hp].include?(perform)
-      quality = :good unless [:bad, :good].include?(quality)
-
-      # A single PSI set for the entire building, based strictly on exterior
-      # wall selection. Adapt once BTAP::Structure supports STRUCTURE
-      # assignements per OpenStudio's building-to-space hierarchy, e.g. "cmu"
-      # gymnasium walls in an otherwise "steel"post/frame school. @todo
-      assembly = self.costed_assembly(structure, :walls, perform)
-      building_psi = self.set(assembly, quality)
-
-      psis[ building_psi[:id] ] = building_psi
+        # Add reference to customized space PSI-factor set.
+        spaces[id] = { id: id, psi: cPSI[:id] }
+      end
 
       # TBD JSON schema added as a reminder. No schema validation in BTAP.
       schema = "https://github.com/rd2/tbd/blob/master/tbd.schema.json"
 
       input[:schema     ] = schema
-      input[:description] = "TBD input for BTAP" # append run # ?
-      input[:psis       ] = psis.values          # maybe more than 1 in future
-      input[:building   ] = { psi: building_psi[:id] }
+      input[:description] = "TBD input for BTAP"
+      input[:psis       ] = psis.values
+      input[:spaces     ] = spaces.values unless spaces.empty?
+      input[:building   ] = { psi: bPSI[:id] }
 
       input
     end
 
     ##
-    # Generate BTAP/TBD tallies
+    # Generate BTAP/TBD tallies, namely for QAQC, costing & embodied carbon.
     #
     # @return [Boolean] true if BTAP/TBD tally is successful
     def gen_tallies
-      edges = {}
       return false unless @model.key?(:io)
-      return false unless @model.key?(:constructions)
-      return false unless @model[:io].key?(:edges)
+      return false unless @model[:io][:edges]
+
+      # Initialize.
+      @tally = {edges: {}}
+      model  = @model[:osm]
+      bldg   = @model[:osm].getBuilding
+
+      # TBD/BTAP track a wider range of thermal bridge types than BTAP costing
+      # currently supports. Current BTAP-costed, linear thermal bridge types:
+      @model[:bridges] = BTAP::BridgingData.admissible_edges
 
       @model[:io][:edges].each do |e|
-        # Content of TBD-generated 'edges' (hashes):
-        #      psi: BTAP PSI set ID, e.g. "BTAP-ExteriorWall-Mass-6 good"
-        #     type: thermal bridge type, e.g. :corner
-        #   length: (in m)
-        # surfaces: linked OpenStudio surface IDs
-        edges[e[:type]]           = {} unless edges.key?(e[:type])
-        edges[e[:type]][e[:psi]]  = 0  unless edges[e[:type]].key?(e[:psi])
-        edges[e[:type]][e[:psi]] += e[:length]
+        pID = e[:psi]
+        next if e[:length] < 0.025
+
+        # Prune away concave/convex suffixes.
+        type = e[:type].to_s.gsub(/concave|convex/, "")
+
+        # Recast linear bridge types: match ~limited costed options.
+        type = case type
+               when /balcony/ then :rimjoist
+               when /roof/    then :parapet
+               when /sky/     then :fenestration
+               when /sill/    then :fenestration
+               when /jamb/    then :fenestration
+               when /head/    then :fenestration
+               when /door/    then ""
+               when /party/   then ""
+               when /joint/   then ""
+               else type.to_sym
+               end
+
+        next unless @model[:bridges].include?(type)
+
+        # Split PSI identifier: construction 'ID' + PSI 'quality'.
+        cID, quality = pID.split(" ")
+
+        # Valid?
+        quality = quality.to_sym
+        next unless data.key?(cID)
+        next unless data[cID].key?(quality)
+        next unless data[cID][quality].key?(type)
+        next unless data[cID][quality][:id] == pID
+
+        # Determine multiplier(s).
+        mSb = 1
+        mSp = 1
+
+        # SubSurface multiplier.
+        e[:surfaces].each do |srf|
+          if type == :fenestration
+            unless model.getSubSurfaceByName(srf).empty?
+              mlt = model.getSubSurfaceByName(srf).get.multiplier
+              mSb = mlt if mlt > mSb
+            end
+          end
+
+          next if model.getSurfaceByName(srf).empty?
+          next if model.getSurfaceByName(srf).get.space.empty?
+
+          # Space multiplier.
+          mlt = model.getSurfaceByName(srf).get.space.get.multiplier
+          mSp = mlt if mlt > mSp
+        end
+
+        @tally[:edges][type]       = {} unless @tally[:edges].key?(type)
+        @tally[:edges][type][pID]  = 0  unless @tally[:edges][type].key?(pID)
+        @tally[:edges][type][pID] += e[:length] * mSb * mSp
       end
 
-      return false if edges.empty?
+      addprop(bldg, "psi_quality", @model[:quality])
 
-      @tally[:edges] = edges
-      @tally[:constructions] = @model[:constructions]
+      # Add (to a model's building) PSI tallies as AdditionalProperties.
+      @tally[:edges].each do |type, edge|
+        edge.each.with_index(1) do |(pID, m), i|
+          next if m < 0.025
 
-      true
+          tag = "PSI" + type.to_s + i.to_s
+          val = "#{pID} #{m.round(2)}"
+          addprop(bldg, tag, val)
+        end
+      end
+
+      # Update other related parameters (as building AdditionalProperties).
+      addprop(bldg, "btap_uo", @model[:building][:walls][:uo])
+      addprop(bldg, "btap_id", @model[:building][:walls][:id])
+
+      # Repeat for attic(s) - if applicable.
+      unless @model[:attic][:walls].empty?
+        model.getSpaces.each do |space|
+          next if space.partofTotalFloorArea
+          next unless TBD.unconditioned?(space)
+
+          addprop(space, "btap_uo", @model[:attic][:walls][:uo])
+          addprop(space, "btap_id", @model[:attic][:walls][:id])
+        end
+      end
+
+      # Repeat for customized spaces.
+      @model[:spaces].each do |id, sp|
+        space = model.getSpaceByName(id)
+        next if space.empty?
+
+        space = space.get
+        addprop(space, "btap_uo", sp[:walls][:uo])
+        addprop(space, "btap_id", sp[:walls][:id])
+      end
+
+      @tally[:edges].empty? ? false : true
     end
 
     ##
@@ -1066,151 +1854,117 @@ module BTAP
       lgs = @feedback[:logs]
       return false unless @model.key?(:complies) # all model constructions
       return false unless @model.key?(:comply)   # surface type specific ...
-      return false unless @model.key?(:argh)     # BTAP/TBD inputs + ouputs
       return false unless @model.key?(:stypes)   # :walls, :roofs, :floors
 
-      argh = @model[:argh]
-
       # Uprating. Report first on surface types (compliant or not).
-      @model[:stypes].each do |stypes|
+      @model[:stypes].each do |stypes, u|
+        next unless @model[:uprating]
         next unless @model[:comply].key?(stypes)
 
-        ut  = format("%.3f", argh[stypes][:ut])
         lg  = @model[:comply][stypes] ? "Compliant " : "Non-compliant "
-        lg += "#{stypes}: Ut #{ut} W/m2.K"
+        lg += stypes.to_s
+        lgs << lg
+
+        bUt  = format("%.3f", @model[:building][stypes][:ut])
+        bUo  = format("%.3f", @model[:building][stypes][:uo])
+        bCP  = @model[:building][stypes][:compliant]
+        bID  = @model[:building][stypes][:id]
+        lg   = "  - "
+        lg  += bCP ? " Compliant " : " Non-compliant "
+        lg  += "BUILDING: Ut #{bUt} W/m2.K "
+        lg  += "(Uo #{bUo} W/m2.K, #{bID})"
+        lg  += " - #{@model[:quality]}" if stypes == :walls
         lgs << lg
 
-        # Report then on required Uo factor per construction (compliant or not).
-        @model[:constructions].each do |lc, v|
-          next unless v.key?(:stypes)
-          next unless v.key?(:uo)
-          next unless v.key?(:compliant)
-          next unless v.key?(:surfaces)
-          next unless v[:stypes  ] == stypes
-          next     if v[:surfaces].empty?
-
-          uo  = format("%.3f", v[:uo])
-          lg  = v[:compliant] ? "   Compliant " : "   Non-compliant "
-          lg += "#{lc.nameString} Uo #{uo} (W/K.m2)"
+        unless @model[:attic][stypes].empty?
+          types = case stypes
+                  when :roofs  then :floors
+                  when :floors then :roofs
+                  else              :walls
+                  end
+
+          aUt  = format("%.3f", @model[:attic][types][:ut])
+          aUo  = format("%.3f", @model[:attic][types][:uo])
+          aCP  = @model[:attic][types][:compliant]
+          aID  = @model[:attic][types][:id]
+          lg   = "  - "
+          lg  += aCP ? " Compliant " : " Non-compliant "
+          lg  += "ATTIC: Ut #{aUt} W/m2.K "
+          lg  += "(Uo #{aUo} W/m2.K, #{aID})"
+          lg  += " - #{@model[:quality]}" if stypes == :walls
           lgs << lg
         end
-      end
 
-      # Summary of TBD-derated constructions.
-      @model[:osm].getSurfaces.each do |s|
-        next if s.construction.empty?
-        next if s.construction.get.to_LayeredConstruction.empty?
-
-        lc = s.construction.get.to_LayeredConstruction.get
-        id = lc.nameString
-        next unless id.include?(" c tbd")
+        @model[:spaces].each do |id, sp|
+          sUt  = format("%.3f", sp[stypes][:ut])
+          sUo  = format("%.3f", sp[stypes][:uo])
+          sCP  = sp[stypes][:compliant]
+          sID  = sp[stypes][:id]
+          sQY  =
+          lg   = "  - "
+          lg  += sCP ? " Compliant " : " Non-compliant "
+          lg  += "SPACE #{id}: Ut #{sUt} W/m2.K "
+          lg  += "(Uo #{sUo} W/m2.K, #{sID})"
+          lg  += " - #{@model[:quality]}" if stypes == :walls
+          lgs << lg
+        end
+      end
 
-        rsi  = TBD.rsi(lc, s.filmResistance)
-        usi  = format("%.3f", 1/rsi)
-        rsi  = format("%.1f", rsi)
-        area = format("%.1f", lc.getNetArea) + " m2"
+      # Report on edges (as linear thermal bridges).
+      lgs << "Edges (i.e. linear thermal bridges):"
 
-        lgs << "~ '#{id}' derated Rsi: #{rsi} [Usi #{usi} x #{area}]"
-      end
+      @tally[:edges].each do |type, edge|
+        edge.each.with_index(1) do |(pID, m), i|
+          next if m < 0.025
 
-      # Log PSI factor tallies (per thermal bridge type).
-      if @tally.key?(:edges)
-        @tally[:edges].each do |type, e|
-          next if type == :transition
+          lgs << " #{type}: ".rjust(15) + pID.ljust(37) + " #{m.round(1)} m".rjust(9)
 
-          lgs << "# '#{type}' (#{e.size}x):"
+          # LargeOffice (without factoring space/subsurface multipliers):
+          #      fenestration: BTAP-ExteriorWall-SteelFramed-2 good  1802.1 m
+          #             grade: BTAP-ExteriorWall-SteelFramed-2 good   243.7 m
+          #          rimjoist: BTAP-ExteriorWall-SteelFramed-2 good   487.4 m
+          #           parapet: BTAP-ExteriorWall-SteelFramed-2 good   243.7 m
+          #            corner: BTAP-ExteriorWall-SteelFramed-2 good    47.6 m
 
-          e.each do |psi, length|
-            l = format("%.2f", length)
-            lgs << "... PSI set '#{psi}' : #{l} m"
-          end
+          # LargeOffice (with factoring space/subsurface multipliers):
+          #      fenestration: BTAP-ExteriorWall-SteelFramed-2 good  6280.0 m
+          #             grade: BTAP-ExteriorWall-SteelFramed-2 good   243.7 m
+          #          rimjoist: BTAP-ExteriorWall-SteelFramed-2 good  2680.6 m
+          #           parapet: BTAP-ExteriorWall-SteelFramed-2 good   243.7 m
+          #            corner: BTAP-ExteriorWall-SteelFramed-2 good   190.2 m
         end
       end
 
       true
     end
-
-    # def get_material_quantities()
-    #   material_quantities = {}
-    #   csv = CSV.read("#{File.dirname(__FILE__)}/../../../data/inventory/thermal_bridging.csv", headers: true)
-    #   tally_edges = @tally[:edges].transform_keys(&:to_s)
-    #
-    #   tally_edges.each do |edge_type_full, value|
-    #     edge_type = edge_type_full.delete_suffix('convex')
-    #     edge_type = 'fenestration' if ['head', 'jamb', 'sill'].include?(edge_type)
-    #
-    #     value.each do |wall_ref_and_quality, quantity|
-    #       /(.*)\s(.*)/ =~ wall_ref_and_quality
-    #       wall_reference = $1
-    #       quality = $2
-    #
-    #       if wall_reference =='BTAP-ExteriorWall-SteelFramed-1'
-    #         wall_reference = 'BTAP-ExteriorWall-SteelFramed-2'
-    #       end
-    #
-    #       next if edge_type == 'transition'
-    #
-    #       result = csv.find { |row| row['edge_type'] == edge_type &&
-    #         row['quality'] == quality &&
-    #         row['wall_reference'] == wall_reference
-    #       }
-    #
-    #       if result.nil?
-    #         puts ("#{edge_type}-#{wall_reference}-#{quality}")
-    #         puts "not found in tb database"
-    #         next
-    #       end
-    #
-    #       # Split
-    #       material_opaque_id_layers = result['material_opaque_id_layers'].split(",")
-    #       id_layers_quantity_multipliers = result['id_layers_quantity_multipliers'].split(",")
-    #
-    #       material_opaque_id_layers.zip(id_layers_quantity_multipliers).each do |id, scale|
-    #         material_quantities[id] = 0.0 if material_quantities[id].nil?
-    #         material_quantities[id] = material_quantities[id] + scale.to_f * quantity.to_f
-    #       end
-    #     end
-    #   end
-    #
-    #   material_opaque_id_quantities = []
-    #
-    #   material_quantities.each do |id,quantity|
-    #     material_opaque_id_quantities << { 'materials_opaque_id' => id, 'quantity' => quantity, 'domain'=> 'thermal_bridging' }
-    #   end
-    #
-    #   return material_opaque_id_quantities
-    # end
   end
 end
 
 # ----- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ----- #
-# NOTE: BTAP supports Uo variants for each of the aforementioned wall
+# Note: BTAP supports Uo variants for each of the aforementioned wall
 #       constructions, e.g. meeting NECB2011 and NECB2015 prescriptive "Uo"
 #       requirements for each NECB climate zone. By definition, these Uo
-#       variants ignore the effects of MAJOR thermal bridging, such as
+#       variants ignore the effects of MAJOR linear thermal bridging, such as
 #       intermediate slab edges. This does not imply that NECB2011 and NECB2015
-#       do not hold prescriptive requirements for MAJOR thermal bridging. There
-#       are indeed a handful of general, qualitative requirements (those of the
-#       MNECB1997) that would make NECB2011- and NECB2015-compliant buildings
-#       slightly better than BTAPPRE1980 "bottom-of-the-barrel" construction,
-#       but likely not any better than circa 1990s "run-of-the-mill" commercial
-#       construction. Currently, BTAP does not assess the impact of MAJOR
-#       thermal bridging for vintages < NECB2017. But ideally it SHOULD, if the
-#       goal remains a fair assessment of the (relative) contribution of more
-#       recent NECB requirements (e.g. 2020).
-
-# NOTE: The BTAP costing spreadsheet holds entries for curtain wall (CW)
-#       spandrel inserts above/below fenestration for certain spacetypes, see:
-#
-#         test/necb/unit_tests/resources/btap_spandrels.png
-#
-#       This is yet to be implemented. This note is an "aide-mémoire" for future
+#       do not hold prescriptive requirements for MAJOR linear thermal bridging.
+#       There are indeed a handful of general, descriptive requirements (those
+#       of the MNECB1997) that would make NECB2011- and NECB2015-compliant
+#       buildings slightly better than BTAPPRE1980 bottom-of-the-barrel
+#       construction, but likely not any better than circa 1990s run-of-the-mill
+#       commercial construction. Currently, BTAP does not assess the impact of
+#       MAJOR linear thermal bridging for vintages < NECB2017. But ideally it
+#       SHOULD, if the goal remains a fair assessment of the (relative)
+#       contribution of more recent NECB requirements (e.g. 2025).
+
+# Note: The original BTAP costing database holds entries for curtain wall (CW)
+#       spandrel inserts above/below fenestration for certain spacetypes. This
+#       is yet to be implemented. This note is an "aide-mémoire" for future
 #       consideration. The BETBG does not hold any CW glazed spandrels achieving
-#       U factors ANYWHERE near NECB requirements, regardless of NECB vintage or
-#       NECB climate zone. Same for the Guide to Low Thermal Energy Demand for
-#       Large Buildings. The original intention was to rely on BTAP variants
-#       "Metal-2" and "Metal-3" as HP CW spandrels ACTUALLY achieving NECB
-#       prescriptive targets, which could only be possible in practice at
+#       U-factors ANYWHERE near NECB requirements, regardless of NECB vintage or
+#       NECB climate zone. Same for the 'Guide to Low Thermal Energy Demand for
+#       Large Buildings'. It seems the original intent was to rely on BTAP
+#       variants "Metal-2" and "Metal-3" as HP CW spandrels ACTUALLY achieving
+#       NECB prescriptive targets, which could only be possible in practice at
 #       great cost and effort (e.g. a 2nd insulated wall behind the spandrel).
 #
 #       If TBD's uprating calculations (e.g. NECB 2017) were in theory no longer
@@ -1219,39 +1973,34 @@ end
 #       to be altered. Otherwise, adaptations would be required. PSI factors are
 #       noticeably different for spandrels (obviously no lintels/shelf-angles).
 #       More importantly, the default assumption with CW technology is that
-#       there wouldn't be any additional linear conductances to consider along
-#       vision vs spandrel sections (as perimeter heat loss would already have
-#       been considered as per NFRC or CSA rating methodologies). On the other
-#       hand, vision jambs along non-CW assemblies (i.e. original BTAP
-#       intention) most certainly constitute (new) MAJOR thermal bridges to
+#       there wouldn't be any linear thermal bridges along shared vision vs
+#       spandrel edges (as perimeter heat loss would already have been taken
+#       into as consideration, as per NFRC or CSA rating methodologies). On the
+#       other hand, CW vision jambs along non-CW assemblies (i.e. original BTAP
+#       goal) most certainly constitute (new) MAJOR linear thermal bridges to
 #       consider (just as with shared edges between spandrels and other wall
 #       assemblies). Again, none of these features are currently implemented
 #       within BTAP. Recommended (future) solution, if desired:
 #
 #         - Automated OSM façade-splitting feature
 #           - insert spandrels above/below windows
-#             > ~200 lines of Ruby code
 #           - simple cases only e.g., vertical, no overlaps, h > 200mm
-#             > split above/below plenum walls as well
-#             > potentially another 200 lines to catch invalid input
+#             - split above/below plenum walls as well
 #
 #        - Further develop PSI sets to cover CWs (see below)
 #          - e.g. PSI factors for CW vision "jamb" transitions
 #          - e.g. PSI factors for CW spandrel "jamb" transitions
 #
 #       These added features would simplify the process tremendously. Yet
-#       without admissible CW spandrel U factors down to 0.130 or 0.100 W/m2.K,
-#       TBD's uprating features would necessarily push OTHER wall constructions
-#       to compensate - noticeably for climate zone 7 (or colder). This would
-#       make it MUCH MORE difficult to identify NECB2017 or NECB2020 compliant
-#       combinations of Uo+PSI factors if ever HP CW spandrels were integrated
-#       within BTAP.
-
-# NOTE: Some of the aforementioned constructions have exterior brick veneer.
+#       without admissible CW spandrel U-factors down to 0.130 or 0.100 W/m2.K,
+#       this would make it pretty much impossible to identify NECB2017 through
+#       NECB2025 compliant combinations of Uo+PSI factors.
+
+# Note: Some of the aforementioned constructions have exterior brick veneer.
 #       For 2-story OpenStudio models with punch windows (i.e. not strip
 #       windows), one would NOT expect a continuous steel shelf angle along the
-#       intermediate floor slab edge (typically a MAJOR thermal bridge). One
-#       would instead expect loose lintels above punch windows, just as with
+#       intermediate floor slab edge (typically a MAJOR linear thermal bridge).
+#       One would instead expect loose lintels above punch windows, just as with
 #       doors. Loose lintels usually compound heat loss along window head edges,
 #       but are currently considered as factored in the retained PSI factors for
 #       window and door head details (a postulate that likely needs revision).
@@ -1268,10 +2017,3 @@ end
 #       costing ($/m2), yet should be limited to doors (@todo). A more flexible,
 #       general solution would be required for 3rd-party OpenStudio models
 #       (without strip windows as a basic fenestration layout).
-#
-# NOTE: BTAP costing: In addition to the listed items for parapets as MAJOR
-#       thermal bridges (eventually generating an overall $ per linear meter),
-#       BTAP costing requires extending the areas (m2) of OpenStudio wall
-#       surfaces (along parapet edges) by 3'-6" (1.1 m) x parapet lengths, to
-#       account for the extra cost of completely wrapping the parapet in
-#       insulation for "good" (HP) details. See final TBD tally - @todo.