tbd 3.4.5 → 3.5.0

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

@@ -1355,103 +1355,103 @@ module TBD
   ##
   # Thermally derates insulating material within construction.
   #
-  # @param id [#to_s] surface identifier
+  # @param id [#to_sym] surface identifier
   # @param [Hash] s TBD surface parameters
-  # @option s [#to_f] :heatloss heat loss from major thermal bridging, in W/K
-  # @option s [#to_f] :net surface net area, in m2
+  # @option s [Numeric] :heatloss heat loss from major thermal bridging, in W/K
+  # @option s [Numeric] :net surface net area, in m2
   # @option s [:massless, :standard] :ltype indexed layer type
-  # @option s [#to_i] :index deratable construction layer index
-  # @option s [#to_f] :r deratable layer Rsi-factor, in m2•K/W
+  # @option s [Integer] :index deratable construction layer index
+  # @option s [Numeric] :r deratable layer Rsi-factor, in m2•K/W
   # @param lc [OpenStudio::Model::LayeredConstruction] a layered construction
   #
-  # @return [OpenStudio::Model::Material] derated (cloned) material
+  # @return [OpenStudio::Model::OpaqueMaterial] derated (cloned) material
   # @return [nil] if invalid input (see logs)
   def derate(id = "", s = {}, lc = nil)
     mth = "TBD::#{__callee__}"
     m   = nil
-    id  = trim(id)
     kys = [:heatloss, :net, :ltype, :index, :r]
-    ck1 = s.is_a?(Hash)
-    ck2 = lc.is_a?(OpenStudio::Model::LayeredConstruction)
-    return mismatch("id"                , id, cl6, mth)     if id.empty?
-    return mismatch("#{id} surface"     , s , cl1, mth) unless ck1
-    return mismatch("#{id} construction", lc, cl2, mth) unless ck2
+    cl  = OpenStudio::Model::LayeredConstruction
+    return mismatch("lc", lc, cl, mth) unless lc.respond_to?(NS)
+    return mismatch("id", id, String, mth) unless id.respond_to?(:to_sym)
+
+    id  = trim(id)
+    nom = lc.nameString
+    return invalid("id", mth, 1) if id.empty?
+    return mismatch(nom, lc, cl, mth) unless lc.is_a?(cl)
+    return mismatch("#{nom} surface", s, Hash, mth) unless s.is_a?(Hash)
+
+    if nom.downcase.include?(" tbd")
+      log(WRN, "Won't derate '#{nom}': tagged as derated (#{mth})")
+      return m
+    end
 
     kys.each do |k|
       tag = "#{id} #{k}"
-      return hashkey(tag, s, k, mth, ERR) unless s.key?(k)
+      return hashkey(tag, s, k, mth) unless s.key?(k)
 
       case k
-      when :heatloss
-        return mismatch(tag, s[k], Numeric, mth) unless s[k].respond_to?(:to_f)
-        return zero(tag, mth, WRN)                   if s[k].to_f.abs < 0.001
-      when :net, :r
-        return mismatch(tag, s[k], Numeric, mth) unless s[k].respond_to?(:to_f)
-        return negative(tag, mth, 2, ERR)            if s[k].to_f < 0
-        return zero(tag, mth, WRN)                   if s[k].to_f.abs < 0.001
-      when :index
-        return mismatch(tag, s[k], Numeric, mth) unless s[k].respond_to?(:to_i)
-        return negative(tag, mth, 2, ERR)            if s[k].to_f < 0
-      else # :ltype
+      when :ltype
         next if [:massless, :standard].include?(s[k])
-        return invalid(tag, mth, 2, ERR)
-      end
-    end
+        return invalid(tag, mth, 2)
+      when :index
+        return mismatch(tag, s[k], Integer, mth) unless s[k].is_a?(Integer)
+        return invalid(tag, mth, 2) unless s[k].between?(0, lc.numLayers - 1)
+      else
+        return mismatch(tag, s[k], Numeric, mth) unless s[k].is_a?(Numeric)
+        next if k == :heatloss
 
-    if lc.nameString.downcase.include?(" tbd")
-      log(WRN, "Won't derate '#{id}': tagged as derated (#{mth})")
-      return m
+        return negative(tag, mth, 2) if s[k] < 0
+        return zero(tag, mth) if s[k].abs < 0.001
+      end
     end
 
     model = lc.model
-    ltype = s[:ltype   ]
-    index = s[:index   ].to_i
-    net   = s[:net     ].to_f
-    r     = s[:r       ].to_f
-    u     = s[:heatloss].to_f / net
+    ltype = s[:ltype]
+    index = s[:index]
+    net   = s[:net]
+    r     = s[:r]
+    u     = s[:heatloss] / net
     loss  = 0
-    de_u  = 1 / r + u # derated U
-    de_r  = 1 / de_u  # derated R
+    de_u  = 1 / r + u # derated insulating material U
+    de_r  = 1 / de_u  # derated insulating material R
 
     if ltype == :massless
-      m    = lc.getLayer(index).to_MasslessOpaqueMaterial
+      m = lc.getLayer(index).to_MasslessOpaqueMaterial
       return invalid("#{id} massless layer?", mth, 0) if m.empty?
-      m    = m.get
-      up   = ""
-      up   = "uprated " if m.nameString.downcase.include?(" uprated")
-      m    = m.clone(model).to_MasslessOpaqueMaterial.get
-             m.setName("#{id} #{up}m tbd")
-      de_r = 0.001                   unless de_r > 0.001
-      loss = (de_u - 1 / de_r) * net unless de_r > 0.001
-             m.setThermalResistance(de_r)
+
+      m  = m.get
+      up = m.nameString.downcase.include?(" uprated") ? "uprated " : ""
+      m  = m.clone(model).to_MasslessOpaqueMaterial.get
+      m.setName("#{id} #{up}m tbd")
+
+      de_r = RMIN                    unless de_r > RMIN
+      loss = (de_u - 1 / de_r) * net unless de_r > RMIN
+
+      unless m.setThermalResistance(de_r)
+        return invalid("Can't derate #{id}: RSi#{de_r.round(2)}", mth)
+      end
     else
-      m    = lc.getLayer(index).to_StandardOpaqueMaterial
+      m = lc.getLayer(index).to_StandardOpaqueMaterial
       return invalid("#{id} standard layer?", mth, 0) if m.empty?
-      m    = m.get
-      up   = ""
-      up   = "uprated " if m.nameString.downcase.include?(" uprated")
-      m    = m.clone(model).to_StandardOpaqueMaterial.get
-             m.setName("#{id} #{up}m tbd")
-      k    = m.thermalConductivity
-
-      if de_r > 0.001
-        d  = de_r * k
-
-        unless d > 0.003
-          d    = 0.003
-          k    = d / de_r
-          k    = 3                    unless k < 3
-          loss = (de_u - k / d) * net unless k < 3
-        end
-      else # de_r < 0.001 m2•K/W
-        d    = 0.001 * k
-        d    = 0.003                  unless d > 0.003
-        k    = d / 0.001              unless d > 0.003
-        loss = (de_u - k / d) * net
+
+      m  = m.get
+      up = m.nameString.downcase.include?(" uprated") ? "uprated " : ""
+      m  = m.clone(model).to_StandardOpaqueMaterial.get
+      m.setName("#{id} #{up}m tbd")
+
+      d  = m.thickness
+      k  = (d / de_r).clamp(KMIN, KMAX)
+      d  = (k * de_r).clamp(DMIN, DMAX)
+
+      loss = (de_u - k / d) * net unless d / k > RMIN
+
+      unless m.setThermalConductivity(k)
+        return invalid("Can't derate #{id}: K#{k.round(3)}", mth)
       end
 
-      m.setThickness(d)
-      m.setThermalConductivity(k)
+      unless m.setThickness(d)
+        return invalid("Can't derate #{id}: #{(d*1000).to_i}mm", mth)
+      end
     end
 
     if m && loss > TOL
@@ -1941,14 +1941,38 @@ module TBD
             ids = windows.keys + doors.keys + skylights.keys
           end
 
-          unless ids.include?(i)
-            log(ERR, "Orphaned subsurface #{i} (mth)")
+          adj = nil
+
+          unless ids.include?(i) # adjacent sub surface?
+            sb = model.getSubSurfaceByName(i)
+
+            if sb.empty?
+              log(DBG, "Orphaned subsurface #{i} (#{mth})?")
+            else
+              sb  = sb.get
+              adj = sb.adjacentSubSurface
+
+              if adj.empty?
+                log(DBG, "Orphaned sub #{i} (#{mth})?")
+              end
+            end
+
             next
           end
 
-          window   =   windows.key?(i) ?   windows[i] : {}
-          door     =     doors.key?(i) ?     doors[i] : {}
-          skylight = skylights.key?(i) ? skylights[i] : {}
+          if adj
+            window   =   windows.key?(i) ?   windows[i] : {}
+            door     =     doors.key?(i) ?     doors[i] : {}
+            skylight = skylights.key?(i) ? skylights[i] : {}
+          else
+            window   =   windows.key?(i) ?   windows[i] : {}
+            door     =     doors.key?(i) ?     doors[i] : {}
+            skylight = skylights.key?(i) ? skylights[i] : {}
+          end
+
+          # window   =   windows.key?(i) ?   windows[i] : {}
+          # door     =     doors.key?(i) ?     doors[i] : {}
+          # skylight = skylights.key?(i) ? skylights[i] : {}
 
           sub = window   unless window.empty?
           sub = door     unless door.empty?
@@ -2939,12 +2963,12 @@ module TBD
     up = argh[:uprate_walls] || argh[:uprate_roofs] || argh[:uprate_floors]
     uprate(model, tbd[:surfaces], argh) if up
 
-    # Derated (cloned) constructions are unique to each deratable surface.
-    # Unique construction names are prefixed with the surface name,
-    # and suffixed with " tbd", indicating that the construction is
-    # henceforth thermally derated. The " tbd" expression is also key in
-    # avoiding inadvertent derating - TBD will not derate constructions
-    # (or rather layered materials) having " tbd" in their OpenStudio name.
+    # A derated (cloned) construction and (cloned) insulating layer are unique
+    # to each deratable surface. Unique construction and material names are
+    # prefixed with the surface name, and suffixed with " tbd", indicating that
+    # the construction is henceforth thermally derated. The " tbd" expression
+    # is also key in avoiding inadvertent sequential derating - TBD will not
+    # derate a construction/material pair having " tbd" in their OpenStudio name.
     tbd[:surfaces].each do |id, surface|
       next unless surface.key?(:construction)
       next unless surface.key?(:index)
@@ -3138,9 +3162,9 @@ module TBD
     argh[:uprate_walls ] = false unless argh.key?(:uprate_walls )
     argh[:uprate_roofs ] = false unless argh.key?(:uprate_roofs )
     argh[:uprate_floors] = false unless argh.key?(:uprate_floors)
-    argh[:wall_ut      ] = 5.678 unless argh.key?(:wall_ut      )
-    argh[:roof_ut      ] = 5.678 unless argh.key?(:roof_ut      )
-    argh[:floor_ut     ] = 5.678 unless argh.key?(:floor_ut     )
+    argh[:wall_ut      ] = UMAX  unless argh.key?(:wall_ut      )
+    argh[:roof_ut      ] = UMAX  unless argh.key?(:roof_ut      )
+    argh[:floor_ut     ] = UMAX  unless argh.key?(:floor_ut     )
     argh[:wall_option  ] = ""    unless argh.key?(:wall_option  )
     argh[:roof_option  ] = ""    unless argh.key?(:roof_option  )
     argh[:floor_option ] = ""    unless argh.key?(:floor_option )

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

@@ -1,121 +1,121 @@
-require 'matrix'
-
-class Matrix
-  def []=(i, j, x)
-    @rows[i][j] = x
-  end
-end
-
-module Topolys
-
-  # Transformations can be applied to Geometry. Ported from OpenStudio Transformation library.
-
-  class Transformation
-  
-    # @return [Matrix] internal 4x4 matrix
-    attr_reader :matrix
-    
-    ##
-    # Initializes an Transformation object
-    #
-    # @param [Matrix] matrix A 4x4 matrix, defaults to identity
-    def initialize(matrix=Matrix.identity(4))
-      raise "Incorrect argument for Transformation, expected Matrix but got #{matrix.class}" unless matrix.is_a?(Matrix)
-      @matrix = matrix
-    end
-    
-    # translation along vector
-    def Transformation.translation(translation)
-      return nil if !translation.is_a?(Vector3D)
-      
-      matrix = Matrix.identity(4)
-      matrix[0,3] = translation.x
-      matrix[1,3] = translation.y
-      matrix[2,3] = translation.z      
-      
-      return Transformation.new(matrix)
-    end
-  
-    ##
-    # Initializes a rotation about origin defined by axis and angle (radians)
-    #
-    def Transformation.rotation(axis, radians)
-      return nil if !axis.is_a?(Vector3D)
-      return nil if !radians.is_a?(Numeric)
-      return nil if (axis.magnitude < Float::EPSILON)
-      normal = axis
-      normal.normalize!
-      
-      # Rodrigues' rotation formula / Rotation matrix from Euler axis/angle
-      # I*cos(radians) + I*(1-cos(radians))*axis*axis^T + Q*sin(radians)
-      # Q = [0, -axis[2], axis[1]; axis[2], 0, -axis[0]; -axis[1], axis[0], 0]
-      p = normal.outer_product(normal)
-      i = Matrix.identity(3)
-      q = Matrix.zero(3)
-      q[0,1] = -normal.z
-      q[0,2] =  normal.y
-      q[1,0] =  normal.z
-      q[1,2] = -normal.x
-      q[2,0] = -normal.y
-      q[2,1] =  normal.x
-
-      # rotation matrix
-      r = i*Math.cos(radians) + (1-Math.cos(radians))*p + q*Math.sin(radians)
-
-      matrix = Matrix.identity(4)
-      matrix[0,0] = r[0,0]
-      matrix[0,1] = r[0,1]
-      matrix[0,2] = r[0,2]
-      matrix[1,0] = r[1,0]
-      matrix[1,1] = r[1,1]
-      matrix[1,2] = r[1,2]
-      matrix[2,0] = r[2,0]
-      matrix[2,1] = r[2,1]
-      matrix[2,2] = r[2,2]
-      
-      return Transformation.new(matrix)
-    end
-
-    ##
-    # Multiplies a Transformation by geometry class
-    #
-    # @param [Obj] obj A geometry object
-    #
-    # @return [Obj] Returns a new, transformed object - nil if not a geometry object
-    def *(obj)
-      if obj.is_a?(Point3D)
-        return mult_point(obj)
-      elsif obj.is_a?(Vector3D)
-        return mult_vector(obj)
-      elsif obj.is_a?(Array)
-        return mult_array(obj)
-      elsif obj.is_a?(Transformation)
-        return mult_transformation(obj)
-      end
-      return nil
-    end
-    
-    private
-    
-    def mult_point(point)
-      temp = Matrix.column_vector([point.x, point.y, point.z, 1])
-      temp = @matrix*temp
-      return Point3D.new(temp[0,0],temp[1,0],temp[2,0])
-    end
-    
-    def mult_vector(vector)
-      temp = Matrix.column_vector([vector.x, vector.y, vector.z, 1])
-      temp = @matrix*temp
-      return Vector3D.new(temp[0,0],temp[1,0],temp[2,0])
-    end
-    
-    def mult_array(array)
-      array.map {|obj| self*obj}
-    end
-    
-    def mult_transformation(obj)
-      Transformation.new(@matrix * obj.matrix)
-    end
-
-  end
+require 'matrix'
+
+class Matrix
+  def []=(i, j, x)
+    @rows[i][j] = x
+  end
+end
+
+module Topolys
+
+  # Transformations can be applied to Geometry. Ported from OpenStudio Transformation library.
+
+  class Transformation
+  
+    # @return [Matrix] internal 4x4 matrix
+    attr_reader :matrix
+    
+    ##
+    # Initializes an Transformation object
+    #
+    # @param [Matrix] matrix A 4x4 matrix, defaults to identity
+    def initialize(matrix=Matrix.identity(4))
+      raise "Incorrect argument for Transformation, expected Matrix but got #{matrix.class}" unless matrix.is_a?(Matrix)
+      @matrix = matrix
+    end
+    
+    # translation along vector
+    def Transformation.translation(translation)
+      return nil if !translation.is_a?(Vector3D)
+      
+      matrix = Matrix.identity(4)
+      matrix[0,3] = translation.x
+      matrix[1,3] = translation.y
+      matrix[2,3] = translation.z      
+      
+      return Transformation.new(matrix)
+    end
+  
+    ##
+    # Initializes a rotation about origin defined by axis and angle (radians)
+    #
+    def Transformation.rotation(axis, radians)
+      return nil if !axis.is_a?(Vector3D)
+      return nil if !radians.is_a?(Numeric)
+      return nil if (axis.magnitude < Float::EPSILON)
+      normal = axis
+      normal.normalize!
+      
+      # Rodrigues' rotation formula / Rotation matrix from Euler axis/angle
+      # I*cos(radians) + I*(1-cos(radians))*axis*axis^T + Q*sin(radians)
+      # Q = [0, -axis[2], axis[1]; axis[2], 0, -axis[0]; -axis[1], axis[0], 0]
+      p = normal.outer_product(normal)
+      i = Matrix.identity(3)
+      q = Matrix.zero(3)
+      q[0,1] = -normal.z
+      q[0,2] =  normal.y
+      q[1,0] =  normal.z
+      q[1,2] = -normal.x
+      q[2,0] = -normal.y
+      q[2,1] =  normal.x
+
+      # rotation matrix
+      r = i*Math.cos(radians) + (1-Math.cos(radians))*p + q*Math.sin(radians)
+
+      matrix = Matrix.identity(4)
+      matrix[0,0] = r[0,0]
+      matrix[0,1] = r[0,1]
+      matrix[0,2] = r[0,2]
+      matrix[1,0] = r[1,0]
+      matrix[1,1] = r[1,1]
+      matrix[1,2] = r[1,2]
+      matrix[2,0] = r[2,0]
+      matrix[2,1] = r[2,1]
+      matrix[2,2] = r[2,2]
+      
+      return Transformation.new(matrix)
+    end
+
+    ##
+    # Multiplies a Transformation by geometry class
+    #
+    # @param [Obj] obj A geometry object
+    #
+    # @return [Obj] Returns a new, transformed object - nil if not a geometry object
+    def *(obj)
+      if obj.is_a?(Point3D)
+        return mult_point(obj)
+      elsif obj.is_a?(Vector3D)
+        return mult_vector(obj)
+      elsif obj.is_a?(Array)
+        return mult_array(obj)
+      elsif obj.is_a?(Transformation)
+        return mult_transformation(obj)
+      end
+      return nil
+    end
+    
+    private
+    
+    def mult_point(point)
+      temp = Matrix.column_vector([point.x, point.y, point.z, 1])
+      temp = @matrix*temp
+      return Point3D.new(temp[0,0],temp[1,0],temp[2,0])
+    end
+    
+    def mult_vector(vector)
+      temp = Matrix.column_vector([vector.x, vector.y, vector.z, 1])
+      temp = @matrix*temp
+      return Vector3D.new(temp[0,0],temp[1,0],temp[2,0])
+    end
+    
+    def mult_array(array)
+      array.map {|obj| self*obj}
+    end
+    
+    def mult_transformation(obj)
+      Transformation.new(@matrix * obj.matrix)
+    end
+
+  end
 end