openstudio-standards 0.2.14 → 0.2.15.pre.rc1

data/lib/openstudio-standards/btap/WeatherData1.json

@@ -1,4 +1,58 @@
 [
+    {
+    "file": "CAN_NB_Moncton-Greater.Moncton.LeBlanc.Intl.AP.717050_CWEC2016.epw",
+    "location_name": "CAN-NB-Moncton-Greater Moncton LeBlanc Intl AP",
+    "energy_plus_location_name": "Moncton-Greater Moncton LeBlanc Intl AP_NB_CAN",
+    "country": "CAN",
+    "state_province_region": "NB",
+    "city": "Moncton-Greater Moncton LeBlanc Intl AP",
+    "hdd10": 2336.0,
+    "hdd18": 4418.0,
+    "cdd10": 933.0,
+    "cdd18": 133.0,
+    "latitude": 46.1122,
+    "longitude": -64.6786,
+    "elevation": 27.0,
+    "deltadb": 27.0,
+    "climate_zone": "6A",
+    "boiler_fueltype": "NaturalGas",
+    "baseboard_type": "Hot Water",
+    "mau_type": true,
+    "mau_heating_coil_type": "Hot Water",
+    "mau_cooling_type": "DX",
+    "chiller_type": "Scroll",
+    "heating_coil_type_sys_3": "Gas",
+    "heating_coil_type_sys4": "Gas",
+    "heating_coil_type_sys6": "Hot Water",
+    "fan_type": "var_speed_drive"
+  },
+  {
+    "file": "CAN_NU_Iqaluit.AP.719090_CWEC2016.epw",
+    "location_name": "CAN-NU-Iqaluit AP",
+    "energy_plus_location_name": "Iqaluit AP_NU_CAN",
+    "country": "CAN",
+    "state_province_region": "NU",
+    "city": "Iqaluit AP",
+    "hdd10": 6781.0,
+    "hdd18": 9794.0,
+    "cdd10": 29.0,
+    "cdd18": 0.0,
+    "latitude": 63.75,
+    "longitude": -68.55,
+    "elevation": 34,
+    "deltadb": 11,
+    "climate_zone": "8",
+    "boiler_fueltype": "FuelOilNo2",
+    "baseboard_type": "Hot Water",
+    "mau_type": true,
+    "mau_heating_coil_type": "Hot Water",
+    "mau_cooling_type": "DX",
+    "chiller_type": "Scroll",
+    "heating_coil_type_sys_3": "Electric",
+    "heating_coil_type_sys4": "Electric",
+    "heating_coil_type_sys6": "Electric",
+    "fan_type": "var_speed_drive"
+  },
   {
     "file": "CAN_BC_Abbotsford.711080_CWEC.epw",
     "location_name": "CAN-BC-Abbotsford",

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

@@ -726,16 +726,18 @@ end
 def get_total_nominal_capacity (model)
   total_nominal_capacity = 0
   model.getSpaces.sort.each do |space|
-    zone_name = space.thermalZone.get.name.get.upcase
-    area = model.sqlFile().get().execAndReturnFirstDouble("SELECT Value FROM TabularDataWithStrings WHERE ReportName='InputVerificationandResultsSummary' AND ReportForString='Entire Facility' AND TableName='Zone Summary' AND ColumnName='Area' AND RowName='#{zone_name}'")
-    area = validate_optional(area, model, -1)
-    multiplier = model.sqlFile().get().execAndReturnFirstDouble("SELECT Value FROM TabularDataWithStrings WHERE ReportName='InputVerificationandResultsSummary' AND ReportForString='Entire Facility' AND TableName='Zone Summary' AND ColumnName='Multipliers' AND RowName='#{zone_name}'")
-    multiplier = validate_optional(multiplier, model, -1)
-    area_per_person = model.sqlFile().get().execAndReturnFirstDouble("SELECT Value FROM TabularDataWithStrings WHERE ReportName='InputVerificationandResultsSummary' AND ReportForString='Entire Facility' AND TableName='Zone Summary' AND ColumnName='People' AND RowName='#{zone_name}'")
-    area_per_person = validate_optional(area_per_person, model, -1)
-    next if area_per_person == 0
-    puts "area: #{area}  multiplier: #{multiplier}   area_per_person: #{area_per_person}"
-    total_nominal_capacity += area*multiplier/area_per_person
+    unless space.thermalZone.empty?
+      zone_name = space.thermalZone.get.name.get.upcase
+      area = model.sqlFile().get().execAndReturnFirstDouble("SELECT Value FROM TabularDataWithStrings WHERE ReportName='InputVerificationandResultsSummary' AND ReportForString='Entire Facility' AND TableName='Zone Summary' AND ColumnName='Area' AND RowName='#{zone_name}'")
+      area = validate_optional(area, model, -1)
+      multiplier = model.sqlFile().get().execAndReturnFirstDouble("SELECT Value FROM TabularDataWithStrings WHERE ReportName='InputVerificationandResultsSummary' AND ReportForString='Entire Facility' AND TableName='Zone Summary' AND ColumnName='Multipliers' AND RowName='#{zone_name}'")
+      multiplier = validate_optional(multiplier, model, -1)
+      area_per_person = model.sqlFile().get().execAndReturnFirstDouble("SELECT Value FROM TabularDataWithStrings WHERE ReportName='InputVerificationandResultsSummary' AND ReportForString='Entire Facility' AND TableName='Zone Summary' AND ColumnName='People' AND RowName='#{zone_name}'")
+      area_per_person = validate_optional(area_per_person, model, -1)
+      next if area_per_person == 0
+      puts "area: #{area}  multiplier: #{multiplier}   area_per_person: #{area_per_person}"
+      total_nominal_capacity += area*multiplier/area_per_person
+    end
   end
   return total_nominal_capacity
 end

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

@@ -834,9 +834,9 @@ module BTAP
           if construction.isFenestration
             construction.layers.each do |layer|
               #check to see if it is a simple glazing. If so use the SHGC method.
-              tvis = tvis * layer.to_SimpleGlazing.get.visibleTransmittance.get unless layer.to_SimpleGlazing.empty?
+              tvis = tvis * layer.to_SimpleGlazing.get.visibleTransmittance.get unless layer.to_SimpleGlazing.empty? || layer.to_SimpleGlazing.get.visibleTransmittance.empty?
               #check to see if it is a standard glazing. If so use the solar transmittance method.
-              tvis = tvis * layer.to_StandardGlazing.get.visibleTransmittanceatNormalIncidence.get unless layer.to_StandardGlazing.empty?
+              tvis = tvis * layer.to_StandardGlazing.get.visibleTransmittanceatNormalIncidence.get unless layer.to_StandardGlazing.empty? || layer.to_StandardGlazing.get.visibleTransmittanceatNormalIncidence.empty?
             end
           end
           return tvis

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

@@ -3109,19 +3109,34 @@ module BTAP
         #    pointing lines or overlapping segments that exactly match one another.
         # 2. Goes through each upward pointing line and finds the closest overlapping downward pointing line segments (if
         #    these downward pointing segments belong together they are re-attached).
-        # 3. Makes quadrilaterals (or triangles as the case may be) out of each upward poinding line and the closest
+        # 3. Makes quadrilaterals (or triangles as the case may be) out of each upward pointing line and the closest
         #    downward pointing line segment.
         if overlap_segs.length > 1
           # Subdivide the overlapping segments found above into either unique overlaps between the upward and downward
           # pointing lines or overlapping segments that exactly match one another.
           overlap_segs = subdivide_overlaps(overlap_segs: overlap_segs)
+          # Remove redundant overlapping segments
+          recheck = true
+          while recheck
+            recheck = false
+            # Go through each overlapping segment and look for duplicate segments
+            overlap_segs.each_with_index do |ind_overlap_seg, seg_index|
+              # Find duplicate overlapping segments
+              redundant_segs = overlap_segs.select { |check_seg| check_seg == ind_overlap_seg}
+              # Remove the first one and then restart the while loop to recompile the seg_index
+              if redundant_segs.size > 1
+                overlap_segs.delete_at(seg_index)
+                recheck = true
+              end
+            end
+          end
           for i in 1..(surf_verts.length - 1)
             # Does the line point up?  No then ignore and go on to the next one.
             if surf_verts[i][:y] > surf_verts[i - 1][:y]
-              # Finds the closest overlapping downward pointing line segments that correspond to this updard pointing
+              # Finds the closest overlapping downward pointing line segments that correspond to this upward pointing
               # line (if some of these downward pointing segments belong together then re-attached them).
               closest_overlaps = get_overlapping_segments(overlap_segs: overlap_segs, index: i, point_a1: surf_verts[i], point_a2: surf_verts[i - 1])
-              closest_overlaps = closest_overlaps.sort_by {|closest_overlap| [closest_overlap[:overlap_y][:overlap_start]]}
+              closest_overlaps = closest_overlaps.sort_by {|closest_overlap| closest_overlap[:overlap_y][:overlap_start]}
               # Create the quadrilaterals out of the downward pointing line segments closest to the current upward
               # pointing line.
               for j in 0..(closest_overlaps.length - 1)
@@ -3129,17 +3144,17 @@ module BTAP
                 z_loc = surf_verts[closest_overlaps[j][:index_a1]][:z]
                 y_loc = closest_overlaps[j][:overlap_y][:overlap_start]
                 x_loc = line_segment_overlap_x_coord(y_check: y_loc, point_b1: surf_verts[closest_overlaps[j][:index_a1]], point_b2: surf_verts[closest_overlaps[j][:index_a2]])
-                new_surf << {x: x_loc, y: y_loc, z: z_loc}
+                new_surf << {x: x_loc.to_f.round(tol), y: y_loc.to_f.round(tol), z: z_loc.to_f.round(tol)}
                 x_loc = line_segment_overlap_x_coord(y_check: y_loc, point_b1: closest_overlaps[j][:point_b1], point_b2: closest_overlaps[j][:point_b2])
                 z_loc = surf_verts[closest_overlaps[j][:index_b2]][:z]
-                new_surf << {x: x_loc, y: y_loc, z: z_loc}
+                new_surf << {x: x_loc.to_f.round(tol), y: y_loc.to_f.round(tol), z: z_loc.to_f.round(tol)}
                 y_loc = closest_overlaps[j][:overlap_y][:overlap_end]
                 x_loc = line_segment_overlap_x_coord(y_check: y_loc, point_b1: closest_overlaps[j][:point_b1], point_b2: closest_overlaps[j][:point_b2])
                 z_loc = surf_verts[closest_overlaps[j][:index_b1]][:z]
-                new_surf << {x: x_loc, y: y_loc, z: z_loc}
+                new_surf << {x: x_loc.to_f.round(tol), y: y_loc.to_f.round(tol), z: z_loc.to_f.round(tol)}
                 x_loc = line_segment_overlap_x_coord(y_check: y_loc, point_b1: surf_verts[closest_overlaps[j][:index_a1]], point_b2: surf_verts[closest_overlaps[j][:index_a2]])
                 z_loc = surf_verts[closest_overlaps[j][:index_a2]][:z]
-                new_surf << {x: x_loc, y: y_loc, z: z_loc}
+                new_surf << {x: x_loc.to_f.round(tol), y: y_loc.to_f.round(tol), z: z_loc.to_f.round(tol)}
                 # Check if this should be a triangle.
                 for k in 0..(new_surf.length - 1)
                   break_now = false
@@ -3214,43 +3229,37 @@ module BTAP
         # This goes through all the line segments and determines which correspond to the current upward pointing line
         # segment(line a).  It also determines the x coordinate distance between the top and bottom of the overlapping
         # portions of the line segments.
-        for j in 0..(overlap_segs.length - 1)
-          if (overlap_segs[j][:index_a1] == index) && (overlap_segs[j][:index_a2] == (index - 1))
-            linea_x_top = line_segment_overlap_x_coord(y_check: overlap_segs[j][:overlap_y][:overlap_start], point_b1: point_a1, point_b2: point_a2)
-            linea_x_bottom = line_segment_overlap_x_coord(y_check: overlap_segs[j][:overlap_y][:overlap_end], point_b1: point_a1, point_b2: point_a2)
-            lineb_x_top = line_segment_overlap_x_coord(y_check: overlap_segs[j][:overlap_y][:overlap_start], point_b1: overlap_segs[j][:point_b1], point_b2: overlap_segs[j][:point_b2])
-            lineb_x_bottom = line_segment_overlap_x_coord(y_check: overlap_segs[j][:overlap_y][:overlap_end], point_b1: overlap_segs[j][:point_b1], point_b2: overlap_segs[j][:point_b2])
-            x_distance_top = linea_x_top - lineb_x_top
-            x_distance_bottom = linea_x_bottom - lineb_x_bottom
-            linea_overlap = {
-                dx_top: x_distance_top,
-                dx_bottom: x_distance_bottom,
-                overlap: overlap_segs[j]
-            }
-            linea_overlaps << linea_overlap
-          end
+        curr_overlap_segs = overlap_segs.select { |seg| (seg[:index_a1] == index) && (seg[:index_a2] == (index - 1)) }
+        curr_overlap_segs.each do |overlap_seg|
+          line_a_x_top = line_segment_overlap_x_coord(y_check: overlap_seg[:overlap_y][:overlap_start], point_b1: point_a1, point_b2: point_a2)
+          line_a_x_bottom = line_segment_overlap_x_coord(y_check: overlap_seg[:overlap_y][:overlap_end], point_b1: point_a1, point_b2: point_a2)
+          line_b_x_top = line_segment_overlap_x_coord(y_check: overlap_seg[:overlap_y][:overlap_start], point_b1: overlap_seg[:point_b1], point_b2: overlap_seg[:point_b2])
+          line_b_x_bottom = line_segment_overlap_x_coord(y_check: overlap_seg[:overlap_y][:overlap_end], point_b1: overlap_seg[:point_b1], point_b2: overlap_seg[:point_b2])
+          x_distance_top = line_a_x_top - line_b_x_top
+          x_distance_bottom = line_a_x_bottom - line_b_x_bottom
+          linea_overlap = {
+            dx_top: x_distance_top,
+            dx_bottom: x_distance_bottom,
+            overlap: overlap_seg
+          }
+          linea_overlaps << linea_overlap
         end
+
         # This sorts through the overlapping downward pointing line segments corresponding to the current upward pointing
         # line a.  The overlapping downward pointing line segments closest to the current upward pointing line segment
         # are kept.  The other are discarded.  Unique overlapping line segments are kept as well.  There should only be
         # unuique overlapping line segments or overlapping line segments that precisely match one another because of
         # the 'subdivide_overlaps' method which this method is supposed to work with.
-        for j in 0..(linea_overlaps.length - 1)
-          overlap_found = false
-          for k in 0..(linea_overlaps.length - 1)
-            if linea_overlaps[j][:overlap] == linea_overlaps[k][:overlap]
-              next
-            elsif (linea_overlaps[j][:overlap][:overlap_y][:overlap_start] == linea_overlaps[k][:overlap][:overlap_y][:overlap_start]) && (linea_overlaps[j][:overlap][:overlap_y][:overlap_end] == linea_overlaps[k][:overlap][:overlap_y][:overlap_end])
-              overlap_found = true
-              if (linea_overlaps[j][:dx_top] < linea_overlaps[k][:dx_top]) && (linea_overlaps[j][:dx_bottom] < linea_overlaps[k][:dx_bottom])
-                closest_overlaps << linea_overlaps[j][:overlap]
-              end
-            end
-          end
-          if overlap_found == false
-            closest_overlaps << linea_overlaps[j][:overlap]
+        linea_overlaps.each do |line_a_overlap|
+          overlaps = linea_overlaps.select { |seg| seg[:overlap][:overlap_y] == line_a_overlap[:overlap][:overlap_y]}
+          if overlaps.size > 1
+            redundant_overlap = closest_overlaps.select { |dup_seg| dup_seg[:overlap_y] == overlaps[0][:overlap][:overlap_y] }
+            closest_overlaps << (overlaps.min_by { |dup_seg| dup_seg[:dx_top] })[:overlap] if redundant_overlap.empty?
+          elsif overlaps.size == 1
+            closest_overlaps << overlaps[0][:overlap]
           end
         end
+
         # This combines the line segments that belong together.  These were broken apart because of the
         # 'subdivide_overlaps' method.
         overlap_exts = [closest_overlaps[0]]
@@ -3316,13 +3325,13 @@ module BTAP
         # lines.
         while restart == true
           restart = false
-          overlap_segs.each do |overlap_seg|
+          overlap_segs.each_with_index do |overlap_seg, curr_seg_index|
             for j in 0..(overlap_segs.length - 1)
               # Skip this y projection if it is the same as that in overlap_seg
               if overlap_seg == overlap_segs[j]
                 next
               end
-              # Check to see if the y projection of line a overlaps with the y prjoection of line b
+              # Check to see if the y projection of line a overlaps with the y projection of line b
               overlap_segs_overlap = line_segment_overlap_y?(point_a1: overlap_seg[:overlap_y][:overlap_start], point_a2: overlap_seg[:overlap_y][:overlap_end], point_b1: overlap_segs[j][:overlap_y][:overlap_end], point_b2: overlap_segs[j][:overlap_y][:overlap_start])
               # If the y projections of the two lines overlap then the components of overlap_segs_overlap should not be
               # nil.
@@ -3368,7 +3377,7 @@ module BTAP
                         overlap_y: overlap_bottom_over
                     }
                     # delete the existing y projection overlaps and replace it with the ones we just made.
-                    overlap_segs.delete(overlap_seg)
+                    overlap_segs.delete_at(curr_seg_index)
                     overlap_segs << overlap_top
                     overlap_segs << overlap_bottom
                   elsif overlap_seg[:overlap_y][:overlap_end] == overlap_segs[j][:overlap_y][:overlap_end]
@@ -3397,7 +3406,7 @@ module BTAP
                         overlap_y: overlap_segs_overlap
                     }
                     # delete the existing y projection overlaps and replace it with the ones we just made.
-                    overlap_segs.delete(overlap_seg)
+                    overlap_segs.delete_at(curr_seg_index)
                     overlap_segs << overlap_top
                     overlap_segs << overlap_bottom
                   elsif (overlap_seg[:overlap_y][:overlap_start] > overlap_segs[j][:overlap_y][:overlap_start]) && (overlap_seg[:overlap_y][:overlap_end] < overlap_segs[j][:overlap_y][:overlap_end])
@@ -3439,7 +3448,7 @@ module BTAP
                         overlap_y: overlap_bottom_over
                     }
                     # delete the existing y projection overlaps and replace it with the ones we just made.
-                    overlap_segs.delete(overlap_seg)
+                    overlap_segs.delete_at(curr_seg_index)
                     overlap_segs << overlap_top
                     overlap_segs << overlap_mid
                     overlap_segs << overlap_bottom
@@ -3480,7 +3489,7 @@ module BTAP
                         overlap_y: overlap_bottom_over
                     }
                     # delete the existing y projection overlaps and replace it with the ones we just made.
-                    overlap_segs.delete(overlap_segs[j])
+                    overlap_segs.delete_at(j)
                     overlap_segs << overlap_top
                     overlap_segs << overlap_bottom
                   elsif overlap_seg[:overlap_y][:overlap_end] == overlap_segs[j][:overlap_y][:overlap_end]
@@ -3509,7 +3518,7 @@ module BTAP
                         overlap_y: overlap_segs_overlap
                     }
                     # delete the existing y projection overlaps and replace it with the ones we just made.
-                    overlap_segs.delete(overlap_segs[j])
+                    overlap_segs.delete_at(j)
                     overlap_segs << overlap_top
                     overlap_segs << overlap_bottom
                   elsif overlap_seg[:overlap_y][:overlap_start] < overlap_segs[j][:overlap_y][:overlap_start] && overlap_seg[:overlap_y][:overlap_end] > overlap_segs[j][:overlap_y][:overlap_end]
@@ -3551,7 +3560,7 @@ module BTAP
                         overlap_y: overlap_bottom_over
                     }
                     # delete the existing y projection overlaps and replace it with the ones we just made.
-                    overlap_segs.delete(overlap_segs[j])
+                    overlap_segs.delete_at(j)
                     overlap_segs << overlap_top
                     overlap_segs << overlap_mid
                     overlap_segs << overlap_bottom
@@ -3560,7 +3569,7 @@ module BTAP
                   break
                   # if overlap_seg covers the top of overlap_segs[j] then break overlap_seg into a top and an overlap portion
                   # ond break overlap_segs[j] into an overlap portion and a bottom portion.
-                elsif (overlap_seg[:overlap_y][:overlap_start] >= overlap_segs[j][:overlap_y][:overlap_start]) && (overlap_seg[:overlap_end] <= overlap_segs[j][:overlap_start]) && (overlap_seg[:overlap_y][:overlap_end] > overlap_segs[j][:overlap_y][:overlap_end])
+                elsif (overlap_seg[:overlap_y][:overlap_start] >= overlap_segs[j][:overlap_y][:overlap_start]) && (overlap_seg[:overlap_y][:overlap_end] <= overlap_segs[j][:overlap_y][:overlap_start]) && (overlap_seg[:overlap_y][:overlap_end] > overlap_segs[j][:overlap_y][:overlap_end])
                   overlap_top_over = {
                       overlap_start: overlap_seg[:overlap_y][:overlap_start],
                       overlap_end: overlap_segs_overlap[:overlap_start]
@@ -3606,8 +3615,13 @@ module BTAP
                       overlap_y: overlap_bottom_over
                   }
                   # delete the existing y projection overlaps and replace it with the ones we just made.
-                  overlap_segs.delete(overlap_seg)
-                  overlap_segs.delete(overlap_segs[j])
+                  if curr_seg_index > j
+                    overlap_segs.delete_at(curr_seg_index)
+                    overlap_segs.delete_at(j)
+                  else
+                    overlap_segs.delete_at(j)
+                    overlap_segs.delete_at(curr_seg_index)
+                  end
                   overlap_segs << overlap_top
                   overlap_segs << overlap_mid_seg
                   overlap_segs << overlap_mid_segs
@@ -3662,8 +3676,13 @@ module BTAP
                       overlap_y: overlap_bottom_over
                   }
                   # delete the existing y projection overlaps and replace it with the ones we just made.
-                  overlap_segs.delete(overlap_seg)
-                  overlap_segs.delete(overlap_seg[j])
+                  if curr_seg_index > j
+                    overlap_segs.delete_at(curr_seg_index)
+                    overlap_segs.delete_at(j)
+                  else
+                    overlap_segs.delete_at(j)
+                    overlap_segs.delete_at(curr_seg_index)
+                  end
                   overlap_segs << overlap_top
                   overlap_segs << overlap_mid_seg
                   overlap_segs << overlap_mid_segs
@@ -3763,6 +3782,34 @@ module BTAP
         new_surf_cent[:z] /= surf.length
         return new_surf_cent
       end
+
+      # This method calculates the surface area of a 2-D polygon from an array of OpenStudio vertices.  It ignores any z
+      # vertices.  This method assumes that the polygon is complete, has no holes, does not cross itself, and that the
+      # vertices are provided in counter-clockwise order.  This method is used in cases when you want to find the area
+      # of something before creating an OpenStudio surface/subsurface.
+      #
+      # Input arguments:
+      # vetices:  Array of openstudio vertices.
+      #
+      # Output:
+      # Area:  Float, area of polygot represented by the vertices.
+      def self.getSurfaceAreafromVertices(vertices:)
+        area = 0.0
+        numberVertices = vertices.size
+
+        # Check that a polygon is actually provided and not just a line or point.  Return 0 if the vertices are a line
+        # or point.
+        return 0.0 if numberVertices < 3
+
+        # Go through the vertices and get the cross product.  This adopted from:
+        # https://web.archive.org/web/20100405070507/http://valis.cs.uiuc.edu/~sariel/research/CG/compgeom/msg00831.html
+        vertices.each_with_index do |vertex, i|
+          j = (i + 1) % numberVertices
+          area += vertex.x.to_f * vertices[j].y.to_f
+          area -= vertex.y.to_f * vertices[j].x.to_f
+        end
+        return area
+      end
     end #Module Surfaces
   end #module Geometry
 end

data/lib/openstudio-standards/btap/utilities/space_type.rb

@@ -0,0 +1,78 @@
+
+require 'minitest/autorun'
+require 'openstudio'
+
+# if running from openstudio-standards.. load local standards
+os_standards_local_lib_path = '../../../lib/openstudio-standards.rb'
+if Dir.exist?(os_standards_local_lib_path)
+  require_relative os_standards_local_lib_path
+else
+  require 'openstudio-standards'
+end
+
+def read_space_types()
+  path = "/home/osdev/openstudio-standards/lib/openstudio-standards/standards/necb/NECB2011/data/geometry/DND*.osm"
+  spacetype_list = []
+  Dir.glob(path) do |osm_file|
+    model = BTAP::FileIO::load_osm(osm_file)
+    standard = NECB2011.new()
+    model.getSpaces.each do |space|
+      unless space.spaceType.empty?
+        name = space.spaceType.get.name.get
+        bt = space.spaceType.get.standardsBuildingType.get unless space.spaceType.get.standardsBuildingType.empty?
+        st = space.spaceType.get.standardsSpaceType.get unless space.spaceType.get.standardsSpaceType.empty?
+        spacetype_list << {'name': name, 'Original-StandardsBuildingType': bt, 'Original-StandardSpaceType': st}
+
+      end
+    end
+
+  end
+  unique_list = spacetype_list.uniq.sort_by { |st| st[:name] }
+
+
+  CSV.open("data.csv", "wb") do |csv|
+    csv << unique_list.first.keys # adds the attributes name on the first line
+    unique_list.each do |hash|
+      csv << hash.values
+    end
+  end
+
+  standard_space_type_list = Standard.build('NECB2011').standards_data['space_types'].map { |space_types| {'building_type': space_types['building_type'],
+                                                                                                           'space_type': space_types['space_type'],
+                                                                                                           "necb_hvac_system_selection_type": space_types['necb_hvac_system_selection_type'],
+                                                                                                           "necb_schedule_type": space_types['necb_schedule_type']
+
+
+  } }
+  standards_space_type_list.s
+
+  CSV.open("spacetypes.csv", "wb") do |csv|
+    csv << standard_space_type_list.first.keys # adds the attributes name on the first line
+    standard_space_type_list.each do |hash|
+      csv << hash.values
+    end
+  end
+end
+
+def map_spacetypes()
+
+  map_list = CSV.open("cold_lake_map.csv", headers: :first_row).map(&:to_h)
+  path = "/home/osdev/openstudio-standards/lib/openstudio-standards/standards/necb/NECB2011/data/geometry/DND*.osm"
+  Dir.glob(path) do |osm_file|
+    model = BTAP::FileIO::load_osm(osm_file)
+    model.getSpaceTypes.each do |st|
+      map_item = map_list.select { |item| item["Original Spacetype Name"] == st.name.get }
+      unless map_item.empty?
+        new_name = map_item.first()['New-StandardsBuildingType'].to_s + '-'+map_item.first()['New-StandardSpaceType'].to_s
+        st.setName(new_name)
+        st.setStandardsBuildingType(map_item.first()["New-StandardsBuildingType"])
+        st.setStandardsSpaceType(map_item.first()["New-StandardSpaceType"])
+        puts st
+      end
+    end
+    BTAP::FileIO::save_osm(model,File.join(__dir__,File.basename(osm_file)))
+  end
+end
+
+
+map_spacetypes()

data/lib/openstudio-standards/hvac_sizing/Siz.AirConditionerVariableRefrigerantFlow.rb

@@ -47,7 +47,7 @@ class OpenStudio::Model::AirConditionerVariableRefrigerantFlow
       self.setEvaporativeCondenserPumpRatedPowerConsumption(evap_cnd_pump_power.get)
     end
     
-    # todo: autosizeWaterCondenserVolumeFlowRate
+    # @todo autosizeWaterCondenserVolumeFlowRate
       #self.setWaterCondenserVolumeFlowRate
 
   end

data/lib/openstudio-standards/hvac_sizing/Siz.HVACComponent.rb

@@ -29,7 +29,7 @@ class OpenStudio::Model::HVACComponent
   # levels that are based on component capacities, flowrates, etc.
   # @param comp_qty [Integer] the number of individual pieces of equipment
   # represented by this HVAC component
-  # @return [Bool] true if successful, false if not
+  # @return [Bool] returns true if successful, false if not
   def set_component_quantity(comp_qty)
     return self.additionalProperties.setFeature('component_quantity', comp_qty)
   end

data/lib/openstudio-standards/hvac_sizing/Siz.HeatingCoolingFuels.rb

@@ -11,7 +11,7 @@
 class OpenStudio::Model::Model
   
   # Get the heating fuel type of a plant loop
-  # @Todo: If no heating equipment is found, check if there's a heat exchanger,
+  # @todo If no heating equipment is found, check if there's a heat exchanger,
   # or a WaterHeater:Mixed or stratified that is connected to a heating source on the demand side
   def plant_loop_heating_fuels(plant_loop)
     fuels = []
@@ -46,7 +46,8 @@ class OpenStudio::Model::Model
         if component.heaterMaximumCapacity.empty? || component.heaterMaximumCapacity.get != 0
           # If it does, we add the heater Fuel Type
           fuels << component.heaterFuelType
-        end  # @Todo: not sure about whether it should be an elsif or not
+        end
+        # @todo not sure about whether it should be an elsif or not
         # Check the plant loop connection on the source side
         if component.secondaryPlantLoop.is_initialized
           fuels += self.plant_loop_heating_fuels(component.secondaryPlantLoop.get)
@@ -58,7 +59,8 @@ class OpenStudio::Model::Model
         if component.heaterMaximumCapacity.empty? || component.heaterMaximumCapacity.get != 0
           # If it does, we add the heater Fuel Type
           fuels << component.heaterFuelType
-        end # @Todo: not sure about whether it should be an elsif or not
+        end
+        # @todo not sure about whether it should be an elsif or not
         # Check the plant loop connection on the source side
         if component.secondaryPlantLoop.is_initialized
           fuels += self.plant_loop_heating_fuels(component.secondaryPlantLoop.get)
@@ -268,7 +270,7 @@ class OpenStudio::Model::Model
         equipment = equipment.to_AirTerminalSingleDuctConstantVolumeReheat.get
         fuels += self.coil_heating_fuels(equipment.reheatCoil)  
       when 'OS_AirTerminal_SingleDuct_InletSideMixer'
-        # TODO
+        # @todo complete method
       when 'OS_AirTerminal_SingleDuct_ParallelPIUReheat'
         equipment = equipment.to_AirTerminalSingleDuctParallelPIUReheat.get
         fuels += self.coil_heating_fuels(equipment.reheatCoil) 
@@ -295,7 +297,13 @@ class OpenStudio::Model::Model
         fuels += self.coil_heating_fuels(equipment.heatingCoil) 
       when 'OS_ZoneHVAC_LowTemperatureRadiant_VariableFlow'
         equipment = equipment.to_ZoneHVACLowTempRadiantVarFlow.get
-        fuels += self.coil_heating_fuels(equipment.heatingCoil) 
+        if equipment.model.version < OpenStudio::VersionString.new('3.2.0')
+          fuels += self.coil_heating_fuels(equipment.heatingCoil)
+        else
+          if equipment.heatingCoil.is_initialized
+            fuels += self.coil_heating_fuels(equipment.heatingCoil.get)
+          end
+        end
       when 'OS_ZoneHVAC_UnitHeater'
         equipment = equipment.to_ZoneHVACUnitHeater.get
         fuels += self.coil_heating_fuels(equipment.heatingCoil) 
@@ -359,7 +367,13 @@ class OpenStudio::Model::Model
         fuels += self.coil_cooling_fuels(equipment.coolingCoil)
       when 'OS_ZoneHVAC_LowTemperatureRadiant_VariableFlow'
         equipment = equipment.to_ZoneHVACLowTempRadiantVarFlow.get
-        fuels += self.coil_cooling_fuels(equipment.coolingCoil)
+        if equipment.model.version < OpenStudio::VersionString.new('3.2.0')
+          fuels += self.coil_cooling_fuels(equipment.coolingCoil)
+        else
+          if equipment.coolingCoil.is_initialized
+            fuels += self.coil_cooling_fuels(equipment.coolingCoil.get)
+          end
+        end
       when 'OS_Refrigeration_AirChiller'
         fuels << 'Electricity'
       when 'OS_ZoneHVAC_IdealLoadsAirSystem'

data/lib/openstudio-standards/hvac_sizing/Siz.Model.rb

@@ -74,7 +74,7 @@ class OpenStudio::Model::Model
       return false
     end
 
-    # TODO Sizing methods for these types of equipment are
+    # @todo Sizing methods for these types of equipment are
     # currently only stubs that need to be filled in.
     self.getAirConditionerVariableRefrigerantFlows.sort.each {|obj| obj.applySizingValues}
     self.getAirLoopHVACUnitaryHeatCoolVAVChangeoverBypasss.sort.each {|obj| obj.applySizingValues}
@@ -176,7 +176,7 @@ class OpenStudio::Model::Model
   # Changes all hard-sized HVAC values to Autosized
   def autosize
   
-    # TODO Sizing methods for these types of equipment are
+    # @todo Sizing methods for these types of equipment are
     # currently only stubs that need to be filled in.
     self.getAirConditionerVariableRefrigerantFlows.sort.each {|obj| obj.autosize}
     self.getAirLoopHVACUnitaryHeatCoolVAVChangeoverBypasss.sort.each {|obj| obj.autosize}
@@ -310,7 +310,7 @@ class OpenStudio::Model::Model
       if val.is_initialized
         result = OpenStudio::OptionalDouble.new(val.get)
       else
-        # TODO: comment following line (debugging new HVACsizing objects right now)
+        # @todo comment following line (debugging new HVACsizing objects right now)
         # OpenStudio::logFree(OpenStudio::Warn, "openstudio.model.Model", "QUERY ERROR: Data not found for query: #{query}")
       end
     else
@@ -346,7 +346,7 @@ class OpenStudio::Model::Model
       if val.is_initialized
         result = OpenStudio::OptionalDouble.new(val.get)
       else
-        # TODO: comment following line (debugging new HVACsizing objects right now)
+        # @todo comment following line (debugging new HVACsizing objects right now)
         # OpenStudio::logFree(OpenStudio::Warn, "openstudio.model.Model", "QUERY ERROR: Data not found for query: #{query}")
       end
     else
@@ -360,8 +360,8 @@ class OpenStudio::Model::Model
   # Helper function to output the fan power for each fan in the model
   # @param [String] csv_path: if given, will output a csv file
   # @return [Array of Hash] each row is a fan, with its name, type, rated watts per cfm, and the airloop or hvac component or zonehvac component it serves
-  # Todo: output actual bhp and allowable bhp for systems 3-4 and 5-8
-  # Todo: remove maybe later?
+  # @todo output actual bhp and allowable bhp for systems 3-4 and 5-8
+  # @todo remove maybe later?
   def output_fan_report(csv_path = nil)
 
     table = []

data/lib/openstudio-standards/hvac_sizing/Siz.WaterHeaterMixed.rb

@@ -1,13 +1,13 @@
 
 # open the class to add methods to return sizing values
-# @Todo: currently OpenStudio is missing the WaterHeater:Sizing object, so unlikely to need it right now...
+# @todo currently OpenStudio is missing the WaterHeater:Sizing object, so unlikely to need it right now...
 class OpenStudio::Model::WaterHeaterMixed
 
 
   # returns the autosized Heater Maximum Capacity as an optional double
   def autosizedHeaterMaximumCapacity
 
-    # @Todo: check the correct syntax here
+    # @todo check the correct syntax here
     return self.model.getAutosizedValue(self, 'Design Size Nominal Capacity', 'W')
 
   end