openstudio-standards 0.2.14 → 0.2.15.pre.rc1

data/lib/openstudio-standards/standards/necb/NECB2011/beps_compliance_path.rb

@@ -1,5 +1,4 @@
 class NECB2011
-
   def add_all_spacetypes_to_model(model)
     # Get the space Type data from @standards data
     spacetype_data = nil
@@ -10,26 +9,24 @@ class NECB2011
     end
     spacetype_data.each do |spacedata|
       space_type = OpenStudio::Model::SpaceType.new(model)
-      space_type.setStandardsSpaceType(spacedata["space_type"])
-      space_type.setStandardsBuildingType(spacedata["building_type"])
+      space_type.setStandardsSpaceType(spacedata['space_type'])
+      space_type.setStandardsBuildingType(spacedata['building_type'])
       space_type.setName("#{spacedata['building_type']} #{spacedata['space_type']}")
       # Loads
-      self.space_type_apply_internal_loads(space_type: space_type)
+      space_type_apply_internal_loads(space_type: space_type)
 
       # Schedules
-      self.space_type_apply_internal_load_schedules(space_type,
-                                                    true,
-                                                    true,
-                                                    true,
-                                                    true,
-                                                    true,
-                                                    true,
-                                                    true)
-
+      space_type_apply_internal_load_schedules(space_type,
+                                               true,
+                                               true,
+                                               true,
+                                               true,
+                                               true,
+                                               true,
+                                               true)
     end
   end
 
-
   # Sets the selected internal loads to standards-based or typical values.
   # For each category that is selected get all load instances. Remove all
   # but the first instance if multiple instances.  Add a new instance/definition
@@ -104,6 +101,7 @@ class NECB2011
       elsif instances.size > 1
         instances.each_with_index do |inst, i|
           next if i.zero?
+
           OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.SpaceType', "Removed #{inst.name} from #{space_type.name}.")
           inst.remove
         end
@@ -194,6 +192,7 @@ class NECB2011
       elsif instances.size > 1
         instances.each_with_index do |inst, i|
           next if i.zero?
+
           OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.SpaceType', "Removed #{inst.name} from #{space_type.name}.")
           inst.remove
         end
@@ -242,6 +241,7 @@ class NECB2011
       elsif instances.size > 1
         instances.each_with_index do |inst, i|
           next if i.zero?
+
           OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.SpaceType', "Removed #{inst.name} from #{space_type.name}.")
           inst.remove
         end
@@ -300,7 +300,7 @@ class NECB2011
         # For BTAP we often use an occupancy per area rate for ventilation which is different from the one used for
         # everything else.  The mod_ventilation_per_person rate adjusts the per person ventilation rate so that the
         # proper ventilation rate is calculated when using the general occupant per area rate.
-        mod_ventilation_per_person = ventilation_per_person*ventilation_occupancy_per_area/occupancy_per_area
+        mod_ventilation_per_person = ventilation_per_person * ventilation_occupancy_per_area / occupancy_per_area
         ventilation.setOutdoorAirFlowperPerson(OpenStudio.convert(mod_ventilation_per_person.to_f, 'ft^3/min*person', 'm^3/s*person').get)
         OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.SpaceType', "#{space_type.name} set ventilation per person to #{mod_ventilation_per_person} cfm/person.")
       end
@@ -329,38 +329,38 @@ class NECB2011
       infiltration_have_info = true
     end
 
-    if set_infiltration && infiltration_have_info
-
-      # Remove all but the first instance
-      instances = space_type.spaceInfiltrationDesignFlowRates.sort
-      if instances.size.zero?
-        instance = OpenStudio::Model::SpaceInfiltrationDesignFlowRate.new(space_type.model)
-        instance.setName("#{space_type.name} Infiltration")
-        instance.setSpaceType(space_type)
-        OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.SpaceType', "#{space_type.name} had no infiltration objects, one has been created.")
-        instances << instance
-      elsif instances.size > 1
-        instances.each_with_index do |inst, i|
-          next if i.zero?
-          OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.SpaceType', "Removed #{inst.name} from #{space_type.name}.")
-          inst.remove
-        end
+    return unless set_infiltration && infiltration_have_info
+
+    # Remove all but the first instance
+    instances = space_type.spaceInfiltrationDesignFlowRates.sort
+    if instances.size.zero?
+      instance = OpenStudio::Model::SpaceInfiltrationDesignFlowRate.new(space_type.model)
+      instance.setName("#{space_type.name} Infiltration")
+      instance.setSpaceType(space_type)
+      OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.SpaceType', "#{space_type.name} had no infiltration objects, one has been created.")
+      instances << instance
+    elsif instances.size > 1
+      instances.each_with_index do |inst, i|
+        next if i.zero?
+
+        OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.SpaceType', "Removed #{inst.name} from #{space_type.name}.")
+        inst.remove
       end
+    end
 
-      # Modify each instance
-      space_type.spaceInfiltrationDesignFlowRates.sort.each do |inst|
-        unless infiltration_per_area_ext.zero?
-          inst.setFlowperExteriorSurfaceArea(OpenStudio.convert(infiltration_per_area_ext.to_f, 'ft^3/min*ft^2', 'm^3/s*m^2').get)
-          OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.SpaceType', "#{space_type.name} set infiltration to #{ventilation_ach} per ft^2 exterior surface area.")
-        end
-        unless infiltration_per_area_ext_wall.zero?
-          inst.setFlowperExteriorWallArea(OpenStudio.convert(infiltration_per_area_ext_wall.to_f, 'ft^3/min*ft^2', 'm^3/s*m^2').get)
-          OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.SpaceType', "#{space_type.name} set infiltration to #{infiltration_per_area_ext_wall} per ft^2 exterior wall area.")
-        end
-        unless infiltration_ach.zero?
-          inst.setAirChangesperHour(infiltration_ach)
-          OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.SpaceType', "#{space_type.name} set infiltration to #{ventilation_ach} ACH.")
-        end
+    # Modify each instance
+    space_type.spaceInfiltrationDesignFlowRates.sort.each do |inst|
+      unless infiltration_per_area_ext.zero?
+        inst.setFlowperExteriorSurfaceArea(OpenStudio.convert(infiltration_per_area_ext.to_f, 'ft^3/min*ft^2', 'm^3/s*m^2').get)
+        OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.SpaceType', "#{space_type.name} set infiltration to #{ventilation_ach} per ft^2 exterior surface area.")
+      end
+      unless infiltration_per_area_ext_wall.zero?
+        inst.setFlowperExteriorWallArea(OpenStudio.convert(infiltration_per_area_ext_wall.to_f, 'ft^3/min*ft^2', 'm^3/s*m^2').get)
+        OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.SpaceType', "#{space_type.name} set infiltration to #{infiltration_per_area_ext_wall} per ft^2 exterior wall area.")
+      end
+      unless infiltration_ach.zero?
+        inst.setAirChangesperHour(infiltration_ach)
+        OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.SpaceType', "#{space_type.name} set infiltration to #{ventilation_ach} ACH.")
       end
     end
   end

data/lib/openstudio-standards/standards/necb/NECB2011/building_envelope.rb

@@ -1,10 +1,9 @@
 class NECB2011
-
   # Reduces the WWR to the values specified by the NECB
   # NECB 3.2.1.4
   def apply_standard_window_to_wall_ratio(model:, fdwr_set: -1.0)
     # NECB FDWR limit
-    hdd = self.get_necb_hdd18(model)
+    hdd = get_necb_hdd18(model)
 
     # Get the maximum NECB fdwr
     # fdwr_set settings:
@@ -12,27 +11,15 @@ class NECB2011
     # -1:  Remove all windows and add windows to match max fdwr from NECB
     # -2:  Do not apply any fdwr changes, leave windows alone (also works for fdwr > 1)
     # -3:  Use old method which reduces existing window size (if necessary) to meet maximum NECB fdwr limit
-    # <-3.1:  Remove all the windows
+    # <-3.1:  Remove all windows and doors
     # > 1:  Do nothing
 
-    if fdwr_set.to_f > 1.0
-      return
-    elsif fdwr_set.to_f >= 0.0 and fdwr_set <= 1.0
-      apply_max_fdwr_nrcan(model: model, fdwr_lim: fdwr_set.to_f)
-      return
-    elsif fdwr_set.to_f >= -1.1 and fdwr_set <= -0.9
-      fdwr_lim = (max_fwdr(hdd)).round(3)
-      apply_max_fdwr_nrcan(model: model, fdwr_lim: fdwr_lim.to_f)
-      return
-    elsif fdwr_set.to_f >= -2.1 and fdwr_set <= -1.9
-      return
-    elsif fdwr_set.to_f >= -3.1 and fdwr_set <= -2.9
-      fdwr_lim = (max_fwdr(hdd) * 100.0).round(1)
-      return apply_limit_fdwr(model: model, fdwr_lim: fdwr_lim.to_f)
-    elsif fdwr_set < -3.1
-      apply_max_fdwr_nrcan(model: model, fdwr_lim: fdwr_set.to_f)
-      return
-    end
+    return if fdwr_set.to_f > 1.0
+    return apply_max_fdwr_nrcan(model: model, fdwr_lim: fdwr_set.to_f) if fdwr_set.to_f >= 0.0 && fdwr_set.to_f <= 1.0
+    return apply_max_fdwr_nrcan(model: model, fdwr_lim: max_fwdr(hdd).round(3)) if fdwr_set.to_f >= -1.1 && fdwr_set.to_f <= -0.9
+    return if fdwr_set.to_f >= -2.1 && fdwr_set.to_f <= -1.9
+    return apply_limit_fdwr(model: model, fdwr_lim: (max_fwdr(hdd) * 100.0).round(1)) if fdwr_set.to_f >= -3.1 && fdwr_set.to_f <= -2.9
+    return apply_max_fdwr_nrcan(model: model, fdwr_lim: fdwr_set.to_f) if fdwr_set.to_f < -3.1
   end
 
   def apply_limit_fdwr(model:, fdwr_lim:)
@@ -59,6 +46,7 @@ class NECB2011
         next unless surface.outsideBoundaryCondition == 'Outdoors'
         # Skip non-walls
         next unless surface.surfaceType.casecmp('wall').zero?
+
         # This wall's gross area (including window area)
         wall_area_m2 += surface.grossArea * space.multiplier
         # Subsurfaces in this surface
@@ -146,6 +134,7 @@ class NECB2011
     # puts "Current subsurf area is #{total_subsurface_m2} and gross surface area is #{total_wall_m2}"
     # Stop here unless windows / doors need reducing
     return true unless fdwr > fdwr_lim
+
     OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.Model', "Reducing the size of all windows (by raising sill height) to reduce window area down to the limit of #{wwr_lim.round}%.")
     # Determine the factors by which to reduce the window / door area
     mult = fdwr_lim / fdwr
@@ -157,6 +146,7 @@ class NECB2011
         next unless surface.outsideBoundaryCondition == 'Outdoors'
         # Skip non-walls
         next unless surface.surfaceType == 'Wall'
+
         # Subsurfaces in this surface
         surface.subSurfaces.sort.each do |ss|
           # Reduce the size of the window
@@ -172,7 +162,6 @@ class NECB2011
   # will be done by shrinking vertices toward the centroid.
   #
   def apply_standard_skylight_to_roof_ratio(model:, srr_set: -1.0)
-
     # If srr_set is between 1.0 and 1.2 set it to the maximum allowed by the NECB.  If srr_set is between 0.0 and 1.0
     # apply whatever was passed.  If srr_set >= 1.2 then set the existing srr of the building to be the necb maximum
     # only if the the srr exceeds this maximum (otherwise leave it to be whatever was modeled).
@@ -182,33 +171,19 @@ class NECB2011
     # -1:  Remove all skylights and add skylights to match max srr from NECB
     # -2:  Do not apply any srr changes, leave skylights alone (also works for srr > 1)
     # -3:  Use old method which reduces existing skylight size (if necessary) to meet maximum NECB skylight limit
-    # <-3.1:  Remove all the skylights
+    # <-3.1:  Remove all skylights
     # > 1:  Do nothing
 
-    if srr_set.to_f > 1.0
-      return
-    elsif srr_set.to_f >= 0.0 && srr_set <= 1.0
-      apply_max_srr_nrcan(model: model, srr_lim: srr_set.to_f)
-      return
-    elsif srr_set.to_f >= -1.1 && srr_set <= -0.9
-      # Get the maximum NECB srr
-      srr_lim = self.get_standards_constant('skylight_to_roof_ratio_max_value')
-      apply_max_srr_nrcan(model: model, srr_lim: srr_lim.to_f)
-      return
-    elsif srr_set.to_f >= -2.1 && srr_set <= -1.9
-      return
-    elsif srr_set.to_f >= -3.1 && srr_set <= -2.9
-      # Continue with the rest of this method, use old method which reduces existing skylight size (if necessary) to
-      # meet maximum srr limit
-    elsif srr_set < -3.1
-      apply_max_srr_nrcan(model: model, srr_lim: srr_set.to_f)
-      return
-    else
-      return
-    end
+    return if srr_set.to_f > 1.0
+    return apply_max_srr_nrcan(model: model, srr_lim: srr_set.to_f) if srr_set.to_f >= 0.0 && srr_set.to_f <= 1.0
+    # Get the maximum NECB srr
+    return apply_max_srr_nrcan(model: model, srr_lim: get_standards_constant('skylight_to_roof_ratio_max_value').to_f) if srr_set.to_f >= -1.1 && srr_set.to_f <= -0.9
+    return if srr_set.to_f >= -2.1 && srr_set.to_f <= -1.9
+    return apply_max_srr_nrcan(model: model, srr_lim: srr_set.to_f) if srr_set.to_f < -3.1
+    return unless srr_set.to_f >= -3.1 && srr_set.to_f <= -2.9
 
     # SRR limit
-    srr_lim = self.get_standards_constant('skylight_to_roof_ratio_max_value') * 100.0
+    srr_lim = get_standards_constant('skylight_to_roof_ratio_max_value') * 100.0
 
     # Loop through all spaces in the model, and
     # per the PNNL PRM Reference Manual, find the areas
@@ -231,6 +206,7 @@ class NECB2011
         next unless surface.outsideBoundaryCondition == 'Outdoors'
         # Skip non-walls
         next unless surface.surfaceType == 'RoofCeiling'
+
         # This wall's gross area (including skylight area)
         wall_area_m2 += surface.grossArea * space.multiplier
         # Subsurfaces in this surface
@@ -278,6 +254,7 @@ class NECB2011
 
     # Stop here unless windows need reducing
     return true unless srr > srr_lim
+
     OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.Model', "Reducing the size of all windows (by raising sill height) to reduce window area down to the limit of #{srr_lim.round}%.")
     # Determine the factors by which to reduce the window / door area
     mult = srr_lim / srr
@@ -290,6 +267,7 @@ class NECB2011
         next unless surface.outsideBoundaryCondition == 'Outdoors'
         # Skip non-walls
         next unless surface.surfaceType == 'RoofCeiling'
+
         # Subsurfaces in this surface
         surface.subSurfaces.sort.each do |ss|
           # Reduce the size of the subsurface
@@ -365,66 +343,62 @@ class NECB2011
         return false
       end
 
+      # hdd required in scope for eval function.
+      hdd = get_necb_hdd18(model)
       # Lambdas are preferred over methods in methods for small utility methods.
       correct_cond = lambda do |conductivity, surface_type|
-        # hdd required in scope for eval function.
-        hdd = get_necb_hdd18(model)
-        return conductivity.nil? || conductivity.to_f <= 0.0 || conductivity =="NECB_Default"  ? eval(model_find_objects(@standards_data['surface_thermal_transmittance'], surface_type)[0]['formula']) : conductivity.to_f
+        return conductivity.nil? || conductivity.to_f <= 0.0 || conductivity == 'NECB_Default' ? eval(model_find_objects(@standards_data['surface_thermal_transmittance'], surface_type)[0]['formula']) : conductivity.to_f
       end
 
       # Converts trans and vis to nil if requesting default.. or casts the string to a float.
       correct_vis_trans = lambda do |value|
-        return value.nil? || value.to_f <= 0.0 || value =="NECB_Default"  ? nil : value.to_f
+        return value.nil? || value.to_f <= 0.0 || value == 'NECB_Default' ? nil : value.to_f
       end
 
       BTAP::Resources::Envelope::ConstructionSets.customize_default_surface_construction_set!(model: model,
                                                                                               name: "#{default_surface_construction_set.name.get} at hdd = #{get_necb_hdd18(model)}",
                                                                                               default_surface_construction_set: default_surface_construction_set,
                                                                                               # ext surfaces
-                                                                                              ext_wall_cond: correct_cond.call(ext_wall_cond, {'boundary_condition' => 'Outdoors', 'surface' => 'Wall'}),
-                                                                                              ext_floor_cond: correct_cond.call(ext_floor_cond, {'boundary_condition' => 'Outdoors', 'surface' => 'Floor'}),
-                                                                                              ext_roof_cond: correct_cond.call(ext_roof_cond, {'boundary_condition' => 'Outdoors', 'surface' => 'RoofCeiling'}),
+                                                                                              ext_wall_cond: correct_cond.call(ext_wall_cond, 'boundary_condition' => 'Outdoors', 'surface' => 'Wall'),
+                                                                                              ext_floor_cond: correct_cond.call(ext_floor_cond, 'boundary_condition' => 'Outdoors', 'surface' => 'Floor'),
+                                                                                              ext_roof_cond: correct_cond.call(ext_roof_cond, 'boundary_condition' => 'Outdoors', 'surface' => 'RoofCeiling'),
                                                                                               # ground surfaces
-                                                                                              ground_wall_cond: correct_cond.call(ground_wall_cond, {'boundary_condition' => 'Ground', 'surface' => 'Wall'}),
-                                                                                              ground_floor_cond: correct_cond.call(ground_floor_cond, {'boundary_condition' => 'Ground', 'surface' => 'Floor'}),
-                                                                                              ground_roof_cond: correct_cond.call(ground_roof_cond, {'boundary_condition' => 'Ground', 'surface' => 'RoofCeiling'}),
+                                                                                              ground_wall_cond: correct_cond.call(ground_wall_cond, 'boundary_condition' => 'Ground', 'surface' => 'Wall'),
+                                                                                              ground_floor_cond: correct_cond.call(ground_floor_cond, 'boundary_condition' => 'Ground', 'surface' => 'Floor'),
+                                                                                              ground_roof_cond: correct_cond.call(ground_roof_cond, 'boundary_condition' => 'Ground', 'surface' => 'RoofCeiling'),
                                                                                               # fixed Windows
-                                                                                              fixed_window_cond: correct_cond.call(fixed_window_cond, {'boundary_condition' => 'Outdoors', 'surface' => 'Window'}),
+                                                                                              fixed_window_cond: correct_cond.call(fixed_window_cond, 'boundary_condition' => 'Outdoors', 'surface' => 'Window'),
                                                                                               fixed_wind_solar_trans: correct_vis_trans.call(fixed_wind_solar_trans),
                                                                                               fixed_wind_vis_trans: correct_vis_trans.call(fixed_wind_vis_trans),
                                                                                               # operable windows
                                                                                               operable_wind_solar_trans: correct_vis_trans.call(operable_wind_solar_trans),
-                                                                                              operable_window_cond: correct_cond.call(fixed_window_cond, {'boundary_condition' => 'Outdoors', 'surface' => 'Window'}),
+                                                                                              operable_window_cond: correct_cond.call(fixed_window_cond, 'boundary_condition' => 'Outdoors', 'surface' => 'Window'),
                                                                                               operable_wind_vis_trans: correct_vis_trans.call(operable_wind_vis_trans),
                                                                                               # glass doors
-                                                                                              glass_door_cond: correct_cond.call(glass_door_cond, {'boundary_condition' => 'Outdoors', 'surface' => 'Window'}),
+                                                                                              glass_door_cond: correct_cond.call(glass_door_cond, 'boundary_condition' => 'Outdoors', 'surface' => 'Window'),
                                                                                               glass_door_solar_trans: correct_vis_trans.call(glass_door_solar_trans),
                                                                                               glass_door_vis_trans: correct_vis_trans.call(glass_door_vis_trans),
                                                                                               # opaque doors
-                                                                                              door_construction_cond: correct_cond.call(door_construction_cond, {'boundary_condition' => 'Outdoors', 'surface' => 'Door'}),
-                                                                                              overhead_door_cond: correct_cond.call(overhead_door_cond, {'boundary_condition' => 'Outdoors', 'surface' => 'Door'}),
+                                                                                              door_construction_cond: correct_cond.call(door_construction_cond, 'boundary_condition' => 'Outdoors', 'surface' => 'Door'),
+                                                                                              overhead_door_cond: correct_cond.call(overhead_door_cond, 'boundary_condition' => 'Outdoors', 'surface' => 'Door'),
                                                                                               # skylights
-                                                                                              skylight_cond: correct_cond.call(skylight_cond, {'boundary_condition' => 'Outdoors', 'surface' => 'Window'}),
+                                                                                              skylight_cond: correct_cond.call(skylight_cond, 'boundary_condition' => 'Outdoors', 'surface' => 'Window'),
                                                                                               skylight_solar_trans: correct_vis_trans.call(skylight_solar_trans),
                                                                                               skylight_vis_trans: correct_vis_trans.call(skylight_vis_trans),
                                                                                               # tubular daylight dome
-                                                                                              tubular_daylight_dome_cond: correct_cond.call(skylight_cond, {'boundary_condition' => 'Outdoors', 'surface' => 'Window'}),
+                                                                                              tubular_daylight_dome_cond: correct_cond.call(skylight_cond, 'boundary_condition' => 'Outdoors', 'surface' => 'Window'),
                                                                                               tubular_daylight_dome_solar_trans: correct_vis_trans.call(tubular_daylight_dome_solar_trans),
                                                                                               tubular_daylight_dome_vis_trans: correct_vis_trans.call(tubular_daylight_dome_vis_trans),
                                                                                               # tubular daylight diffuser
-                                                                                              tubular_daylight_diffuser_cond: correct_cond.call(skylight_cond, {'boundary_condition' => 'Outdoors', 'surface' => 'Window'}),
+                                                                                              tubular_daylight_diffuser_cond: correct_cond.call(skylight_cond, 'boundary_condition' => 'Outdoors', 'surface' => 'Window'),
                                                                                               tubular_daylight_diffuser_solar_trans: correct_vis_trans.call(tubular_daylight_diffuser_solar_trans),
-                                                                                              tubular_daylight_diffuser_vis_trans: correct_vis_trans.call(tubular_daylight_diffuser_vis_trans)
-      )
-
-
+                                                                                              tubular_daylight_diffuser_vis_trans: correct_vis_trans.call(tubular_daylight_diffuser_vis_trans))
     end
     # sets all surfaces to use default constructions sets except adiabatic, where it does a hard assignment of the interior wall construction type.
     model.getPlanarSurfaces.sort.each(&:resetConstruction)
     # if the default construction set is defined..try to assign the interior wall to the adiabatic surfaces
     BTAP::Resources::Envelope.assign_interior_surface_construction_to_adiabatic_surfaces(model, nil)
     BTAP.runner_register('Info', ' apply_standard_construction_properties was sucessful.', runner)
-
   end
 
   # Set all external surface conductances to NECB values.
@@ -436,7 +410,6 @@ class NECB2011
   # @return [String] surface as RSI
   def set_necb_external_surface_conductance(surface, hdd, is_radiant = false, scaling_factor = 1.0)
     conductance_value = 0
-
     if surface.outsideBoundaryCondition.casecmp('outdoors').zero?
 
       case surface.surfaceType.downcase
@@ -453,20 +426,20 @@ class NECB2011
       return BTAP::Geometry::Surfaces.set_surfaces_construction_conductance([surface], conductance_value)
     end
 
-    if surface.outsideBoundaryCondition.downcase =~ /ground/
-      case surface.surfaceType.downcase
-      when 'wall'
-        conductance_value = @standards_data['conductances']['GroundWall'].find { |i| i['hdd'] > hdd }['thermal_transmittance'] * scaling_factor
-      when 'floor'
-        conductance_value = @standards_data['conductances']['GroundFloor'].find { |i| i['hdd'] > hdd }['thermal_transmittance'] * scaling_factor
-      when 'roofceiling'
-        conductance_value = @standards_data['conductances']['GroundRoof'].find { |i| i['hdd'] > hdd }['thermal_transmittance'] * scaling_factor
-      end
-      if is_radiant
-        conductance_value *= 0.80
-      end
-      return BTAP::Geometry::Surfaces.set_surfaces_construction_conductance([surface], conductance_value)
+    return unless surface.outsideBoundaryCondition.downcase =~ /ground/
+
+    case surface.surfaceType.downcase
+    when 'wall'
+      conductance_value = @standards_data['conductances']['GroundWall'].find { |i| i['hdd'] > hdd }['thermal_transmittance'] * scaling_factor
+    when 'floor'
+      conductance_value = @standards_data['conductances']['GroundFloor'].find { |i| i['hdd'] > hdd }['thermal_transmittance'] * scaling_factor
+    when 'roofceiling'
+      conductance_value = @standards_data['conductances']['GroundRoof'].find { |i| i['hdd'] > hdd }['thermal_transmittance'] * scaling_factor
+    end
+    if is_radiant
+      conductance_value *= 0.80
     end
+    return BTAP::Geometry::Surfaces.set_surfaces_construction_conductance([surface], conductance_value)
   end
 
   # Set all external subsurfaces (doors, windows, skylights) to NECB values.
@@ -475,16 +448,15 @@ class NECB2011
   # @param hdd [Float]
   def set_necb_external_subsurface_conductance(subsurface, hdd)
     conductance_value = 0
+    return unless subsurface.outsideBoundaryCondition.downcase.match('outdoors')
 
-    if subsurface.outsideBoundaryCondition.downcase.match('outdoors')
-      case subsurface.subSurfaceType.downcase
-      when /window/
-        conductance_value = @standards_data['conductances']['Window'].find { |i| i['hdd'] > hdd }['thermal_transmittance'] * scaling_factor
-      when /door/
-        conductance_value = @standards_data['conductances']['Door'].find { |i| i['hdd'] > hdd }['thermal_transmittance'] * scaling_factor
-      end
-      subsurface.setRSI(1 / conductance_value)
+    case subsurface.subSurfaceType.downcase
+    when /window/
+      conductance_value = @standards_data['conductances']['Window'].find { |i| i['hdd'] > hdd }['thermal_transmittance'] * scaling_factor
+    when /door/
+      conductance_value = @standards_data['conductances']['Door'].find { |i| i['hdd'] > hdd }['thermal_transmittance'] * scaling_factor
     end
+    subsurface.setRSI(1 / conductance_value)
   end
 
   # Adds code-minimum constructions based on the building type
@@ -512,10 +484,8 @@ class NECB2011
   end
 
   def apply_building_default_constructionset(model)
-
     bldg_def_const_set = model_add_construction_set_from_osm(model: model)
     model.getBuilding.setDefaultConstructionSet(bldg_def_const_set)
-
   end
 
   def apply_default_constructionsets_to_spacetypes(climate_zone, model)
@@ -555,9 +525,9 @@ class NECB2011
                                           construction_set_name: 'BTAP-Mass',
                                           osm_path: File.absolute_path(File.join(__FILE__, '..', '..', 'common/construction_defaults.osm')))
     # load resources model
-    construction_library = BTAP::FileIO::load_osm(osm_path)
+    construction_library = BTAP::FileIO.load_osm(osm_path)
 
-    if not construction_library.getDefaultConstructionSetByName(construction_set_name.to_s).is_initialized
+    if !construction_library.getDefaultConstructionSetByName(construction_set_name.to_s).is_initialized
       runner.registerError('Did not find the expected construction in library.')
       return false
     end
@@ -667,7 +637,7 @@ class NECB2011
     m[2, 2] = 1.0 / z_scale
     m[3, 3] = 1.0
     t = OpenStudio::Transformation.new(m)
-    model.getPlanarSurfaceGroups().each do |planar_surface|
+    model.getPlanarSurfaceGroups.each do |planar_surface|
       planar_surface.changeTransformation(t)
     end
     return model
@@ -683,8 +653,8 @@ class NECB2011
     # spaces.
     exp_surf_info = find_exposed_conditioned_vertical_surfaces(model)
     # If there are none (or very few) then throw a warning.
-    if exp_surf_info["total_exp_wall_area_m2"] < 0.1
-      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.model.Model', "This building has no exposed walls adjacent to heated spaces.")
+    if exp_surf_info['total_exp_wall_area_m2'] < 0.1
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.model.Model', 'This building has no exposed walls adjacent to heated spaces.')
       return false
     end
 
@@ -694,43 +664,43 @@ class NECB2011
     # IF FDWR is greater than 1 then something is wrong raise an error.  If it is less than 0.001 assume all the windows
     # should go.
     if fdwr_lim > 1
-      OpenStudio.logFree(OpenStudio::Error, 'openstudio.model.Model', "This building requires a larger window area than there is wall area.")
+      OpenStudio.logFree(OpenStudio::Error, 'openstudio.model.Model', 'This building requires a larger window area than there is wall area.')
       return false
     elsif fdwr_lim < 0.001
-      exp_surf_info["exp_nonplenum_walls"].sort.each do |exp_surf|
-        remove_All_Subsurfaces(surface: exp_surf)
+      exp_surf_info['exp_nonplenum_walls'].sort.each do |exp_surf|
+        remove_all_subsurfaces(surface: exp_surf)
       end
       return true
     end
     # Get the required window area.
-    win_area = fdwr_lim * exp_surf_info["total_exp_wall_area_m2"]
+    win_area = fdwr_lim * exp_surf_info['total_exp_wall_area_m2']
     # Try to put the windows on non-plenum walls if possible.  So determine if you can fit the required window area
     # on the non-plenum wall area.
-    if win_area <= exp_surf_info["exp_nonplenum_wall_area_m2"]
+    if win_area <= exp_surf_info['exp_nonplenum_wall_area_m2']
       # If you can fit the windows on the non-plenum wall area then recalculate the window ratio so that is is only for
       # the non-plenum walls.
-      nonplenum_fdwr = win_area / exp_surf_info["exp_nonplenum_wall_area_m2"]
-      exp_surf_info["exp_nonplenum_walls"].sort.each do |exp_surf|
+      nonplenum_fdwr = win_area / exp_surf_info['exp_nonplenum_wall_area_m2']
+      exp_surf_info['exp_nonplenum_walls'].sort.each do |exp_surf|
         # Remove any subsurfaces, add the window, set the name to be whatever the surface name is plus the subsurface
         # type (which will be 'fixedwindow')
-        remove_All_Subsurfaces(surface: exp_surf)
-        set_Window_To_Wall_Ratio_set_name(surface: exp_surf, area_fraction: nonplenum_fdwr, construction: fixed_window_construct_set)
+        remove_all_subsurfaces(surface: exp_surf)
+        set_window_to_wall_ratio_set_name(surface: exp_surf, area_fraction: nonplenum_fdwr, construction: fixed_window_construct_set)
       end
     else
       # There was not enough non-plenum wall area so add the windows to both the plenum and non-plenum walls.  This is
       # done separately because the 'find_exposed_conditioned_vertical_surfaces' method returns the plenum and
       # non-plenum walls separately.
-      exp_surf_info["exp_nonplenum_walls"].sort.each do |exp_surf|
+      exp_surf_info['exp_nonplenum_walls'].sort.each do |exp_surf|
         # Remove any subsurfaces, add the window, set the name to be whatever the surface name is plus the subsurface
         # type (which will be 'fixedwindow')
-        remove_All_Subsurfaces(surface: exp_surf)
-        set_Window_To_Wall_Ratio_set_name(surface: exp_surf, area_fraction: fdwr_lim, construction: fixed_window_construct_set)
+        remove_all_subsurfaces(surface: exp_surf)
+        set_window_to_wall_ratio_set_name(surface: exp_surf, area_fraction: fdwr_lim, construction: fixed_window_construct_set)
       end
-      exp_surf_info["exp_plenum_walls"].sort.each do |exp_surf|
+      exp_surf_info['exp_plenum_walls'].sort.each do |exp_surf|
         # Remove any subsurfaces, add the window, set the name to be whatever the surface name is plus the subsurface
         # type (which will be 'fixedwindow')
-        remove_All_Subsurfaces(surface: exp_surf)
-        set_Window_To_Wall_Ratio_set_name(surface: exp_surf, area_fraction: fdwr_lim, construction: fixed_window_construct_set)
+        remove_all_subsurfaces(surface: exp_surf)
+        set_window_to_wall_ratio_set_name(surface: exp_surf, area_fraction: fdwr_lim, construction: fixed_window_construct_set)
       end
     end
     return true
@@ -745,19 +715,19 @@ class NECB2011
     exp_surf_info = find_exposed_conditioned_roof_surfaces(model)
     # If the non-plenum roof area is very small raise a warning.  It may be perfectly fine but it is probably a good
     # idea to warn the user.
-    if exp_surf_info["exp_nonplenum_roof_area_m2"] < 0.1
-      OpenStudio.logFree(OpenStudio::Info, 'openstudio.model.Model', "This building has no exposed ceilings adjacent to spaces that are not attics or plenums.  No skylights will be added.")
+    if exp_surf_info['exp_nonplenum_roof_area_m2'] < 0.1
+      OpenStudio.logFree(OpenStudio::Info, 'openstudio.model.Model', 'This building has no exposed ceilings adjacent to spaces that are not attics or plenums.  No skylights will be added.')
       return false
     end
 
     # If the SRR is greater than one something is seriously wrong so raise an error.  If it is less than 0.001 assume
     # all the skylights should go.
     if srr_lim > 1
-      OpenStudio.logFree(OpenStudio::Error, 'openstudio.model.Model', "This building requires a larger skylight area than there is roof area.")
+      OpenStudio.logFree(OpenStudio::Error, 'openstudio.model.Model', 'This building requires a larger skylight area than there is roof area.')
       return false
     elsif srr_lim < 0.001
-      exp_surf_info["exp_nonplenum_roofs"].sort.each do |exp_surf|
-        remove_All_Subsurfaces(surface: exp_surf)
+      exp_surf_info['exp_nonplenum_roofs'].sort.each do |exp_surf|
+        remove_all_subsurfaces(surface: exp_surf)
       end
       return true
     end
@@ -770,10 +740,10 @@ class NECB2011
     # determined by the SRR.  The name of the skylight will be the surface name with the subsurface type attached
     # ('skylight' in this case).  Note that this method will only work if the surface does not fold into itself (like an
     # L or a V).
-    exp_surf_info["exp_nonplenum_roofs"].sort.each do |roof|
+    exp_surf_info['exp_nonplenum_roofs'].sort.each do |roof|
       # sub_surface_create_centered_subsurface_from_scaled_surface(roof, srr_lim, model)
-      sub_surface_create_scaled_subsurfaces_from_surface(surface: roof, area_fraction: srr_lim, model: model, consturction: skylight_construct_set)
+      sub_surface_create_scaled_subsurfaces_from_surface(surface: roof, area_fraction: srr_lim, construction: skylight_construct_set)
     end
     return true
   end
-end
+end