openstudio-standards 0.2.14 → 0.2.15.pre.rc1

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

@@ -1,5 +1,4 @@
 class NECB2011
-
   # Creates thermal zones to contain each space, as defined for each building in the
   # system_to_space_map inside the Prototype.building_name
   # e.g. (Prototype.secondary_school.rb) file.
@@ -63,7 +62,6 @@ class NECB2011
       @standards_data['space_types'] = Standard.build(template).standards_data['space_types']
     end
 
-
     # The first thing we need to do is get a sizing run to determine the heating loads of all the spaces. The default
     # btap geometry has a one to one relationship of zones to spaces.. So we simply create the thermal zones for all the spaces.
     # to do this we need to create thermals zone for each space.
@@ -78,25 +76,26 @@ class NECB2011
     end
 
     # collect sizing information on each space.
-    self.store_space_sizing_loads(model)
+    store_space_sizing_loads(model)
     # Remove any Thermal zones assigned again to start fresh.
     model.getThermalZones.each(&:remove)
-    self.auto_zone_dwelling_units(model)
-    self.auto_zone_wet_spaces(model: model, lights_type: lights_type, lights_scale: lights_scale)
-    self.auto_zone_all_other_spaces(model)
-    self.auto_zone_wild_spaces(model: model, lights_type: lights_type, lights_scale: lights_scale)
-    #THis will color the spaces and zones.
+    auto_zone_dwelling_units(model)
+    auto_zone_wet_spaces(model: model, lights_type: lights_type, lights_scale: lights_scale)
+    auto_zone_all_other_spaces(model)
+    auto_zone_wild_spaces(model: model, lights_type: lights_type, lights_scale: lights_scale)
+    # This will color the spaces and zones.
     random = Random.new(1234)
-    #Set ideal hvac in case we want to not implement the hvac yet and still run osm right after this function.
-    #model.getThermalZones.each { |zone| zone.setUseIdealAirLoads(true) }
-    model.getThermalZones.sort.each {|item| item.setRenderingColor(self.set_random_rendering_color(item, random))}
-    model.getSpaceTypes.sort.each {|item| item.setRenderingColor(self.set_random_rendering_color(item, random))}
+    # Set ideal hvac in case we want to not implement the hvac yet and still run osm right after this function.
+    # model.getThermalZones.each { |zone| zone.setUseIdealAirLoads(true) }
+    model.getThermalZones.sort.each { |item| item.setRenderingColor(set_random_rendering_color(item, random)) }
+    model.getSpaceTypes.sort.each { |item| item.setRenderingColor(set_random_rendering_color(item, random)) }
   end
 
   # Organizes Zones and assigns them to appropriate systems according to NECB 2011-17 systems spacetype rules in Sec 8.
   # requires requires fuel type to be assigned for each system aspect. Defaults to gas hydronic.
   def apply_systems(model:, primary_heating_fuel:, sizing_run_dir:)
     raise('validation of model failed.') unless validate_initial_model(model)
+
     # Check to see if model is using another vintage of spacetypes. If so overwrite the @standards for the object with the
     # other spacetype data. This is required for correct system mapping.
     template = determine_spacetype_vintage(model)
@@ -106,23 +105,22 @@ class NECB2011
     end
 
     # do a sizing run.
-    if model_run_sizing_run(model, "#{sizing_run_dir}/autozone") == false
+    if model_run_sizing_run(model, "#{sizing_run_dir}/autozone_systems") == false
       raise('autorun sizing run failed!')
     end
 
     # collect sizing information on each space.
-    self.store_space_sizing_loads(model)
+    store_space_sizing_loads(model)
 
     # Set the primary fuel set to default to to specific fuel type.
     if primary_heating_fuel == 'DefaultFuel'
       epw = BTAP::Environment::WeatherFile.new(model.weatherFile.get.path.get)
-      primary_heating_fuel = @standards_data['regional_fuel_use'].detect {|fuel_sources| fuel_sources['state_province_regions'].include?(epw.state_province_region)}['fueltype_set']
+      primary_heating_fuel = @standards_data['regional_fuel_use'].detect { |fuel_sources| fuel_sources['state_province_regions'].include?(epw.state_province_region) }['fueltype_set']
     end
     # Get fuelset.
-    system_fuel_defaults = @standards_data['fuel_type_sets'].detect {|fuel_type_set| fuel_type_set['name'] == primary_heating_fuel}
+    system_fuel_defaults = @standards_data['fuel_type_sets'].detect { |fuel_type_set| fuel_type_set['name'] == primary_heating_fuel }
     raise("fuel_type_sets named #{primary_heating_fuel} not found in fuel_type_sets table.") if system_fuel_defaults.nil?
 
-
     # Assign fuel sources.
     boiler_fueltype = system_fuel_defaults['boiler_fueltype']
     baseboard_type = system_fuel_defaults['baseboard_type']
@@ -135,13 +133,13 @@ class NECB2011
     heating_coil_type_sys6 = system_fuel_defaults['heating_coil_type_sys6']
     fan_type = system_fuel_defaults['fan_type']
 
-    #remove idealair from zones if any.
+    # remove idealair from zones if any.
     model.getZoneHVACIdealLoadsAirSystems.each(&:remove)
     @hw_loop = create_hw_loop_if_required(baseboard_type,
                                           boiler_fueltype,
                                           mau_heating_coil_type,
                                           model)
-    #Rule that all dwelling units have their own zone and system.
+    # Rule that all dwelling units have their own zone and system.
     auto_system_dwelling_units(model: model,
                                baseboard_type: baseboard_type,
                                boiler_fueltype: boiler_fueltype,
@@ -153,24 +151,21 @@ class NECB2011
                                heating_coil_type_sys6: heating_coil_type_sys6,
                                mau_cooling_type: mau_cooling_type,
                                mau_heating_coil_type: mau_heating_coil_type,
-                               mau_type: mau_type
-    )
+                               mau_type: mau_type)
 
-    #Assign a single system 4 for all wet spaces.. and assign the control zone to the one with the largest load.
+    # Assign a single system 4 for all wet spaces.. and assign the control zone to the one with the largest load.
     auto_system_wet_spaces(baseboard_type: baseboard_type,
                            boiler_fueltype: boiler_fueltype,
                            heating_coil_type_sys4: heating_coil_type_sys4,
                            model: model)
 
-
-    #Assign a single system 4 for all storage spaces.. and assign the control zone to the one with the largest load.
+    # Assign a single system 4 for all storage spaces.. and assign the control zone to the one with the largest load.
     auto_system_storage_spaces(baseboard_type: baseboard_type,
                                boiler_fueltype: boiler_fueltype,
                                heating_coil_type_sys4: heating_coil_type_sys4,
                                model: model)
 
-
-    #Assign the wild spaces to a single system 4 system with a control zone with the largest load.
+    # Assign the wild spaces to a single system 4 system with a control zone with the largest load.
     auto_system_wild_spaces(baseboard_type: baseboard_type,
                             heating_coil_type_sys4: heating_coil_type_sys4,
                             model: model)
@@ -186,14 +181,12 @@ class NECB2011
                                  heating_coil_type_sys6: heating_coil_type_sys6,
                                  mau_cooling_type: mau_cooling_type,
                                  mau_heating_coil_type: mau_heating_coil_type,
-                                 mau_type: mau_type
-    )
+                                 mau_type: mau_type)
     model_add_swh(model: model, swh_fueltype: system_fuel_defaults['swh_fueltype'])
     model_apply_sizing_parameters(model)
     # set a larger tolerance for unmet hours from default 0.2 to 1.0C
     model.getOutputControlReportingTolerances.setToleranceforTimeHeatingSetpointNotMet(1.0)
     model.getOutputControlReportingTolerances.setToleranceforTimeCoolingSetpointNotMet(1.0)
-
   end
 
   # Method to store space sizing loads. This is needed because later when the zones are destroyed this information will be lost.
@@ -201,7 +194,6 @@ class NECB2011
     @stored_space_heating_sizing_loads = {}
     @stored_space_cooling_sizing_loads = {}
     model.getSpaces.sort.each do |space|
-
       space_type = space.spaceType.get.standardsSpaceType.get
       @stored_space_heating_sizing_loads[space] = space_type == '- undefined -' ? 0.0 : space.thermalZone.get.heatingDesignLoad.get
       @stored_space_cooling_sizing_loads[space] = space_type == '- undefined -' ? 0.0 : space.thermalZone.get.coolingDesignLoad.get
@@ -212,9 +204,10 @@ class NECB2011
   def stored_space_heating_load(space)
     if @stored_space_heating_sizing_loads.nil?
       # do a sizing run.
-      raise("autorun sizing run failed!") if model_run_sizing_run(space.model, "#{Dir.pwd}/autozone") == false
-      #collect sizing information on each space.
-      self.store_space_sizing_loads(space.model)
+      raise('autorun sizing run failed!') if model_run_sizing_run(space.model, "#{Dir.pwd}/autozone") == false
+
+      # collect sizing information on each space.
+      store_space_sizing_loads(space.model)
     end
     @stored_space_heating_sizing_loads[space]
   end
@@ -223,9 +216,10 @@ class NECB2011
   def stored_space_cooling_load(space)
     if @stored_space_cooling_sizing_loads.nil?
       # do a sizing run.
-      raise("autorun sizing run failed!") if model_run_sizing_run(space.model, "#{Dir.pwd}/autozone") == false
-      #collect sizing information on each space.
-      self.store_space_sizing_loads(space.model)
+      raise('autorun sizing run failed!') if model_run_sizing_run(space.model, "#{Dir.pwd}/autozone") == false
+
+      # collect sizing information on each space.
+      store_space_sizing_loads(space.model)
     end
     @stored_space_cooling_sizing_loads[space]
   end
@@ -255,9 +249,9 @@ class NECB2011
   def auto_zone_dwelling_units(model)
     dwelling_tz_array = []
     # ----Dwelling units----------- will always have their own system per unit, so they should have their own thermal zone.
-    model.getSpaces.select {|space| is_a_necb_dwelling_unit?(space)}.each do |space|
+    model.getSpaces.select { |space| is_a_necb_dwelling_unit?(space) }.each do |space|
       zone = OpenStudio::Model::ThermalZone.new(model)
-      zone.setName("DU_BT=#{space.spaceType.get.standardsBuildingType.get}_ST=#{space.spaceType.get.standardsSpaceType.get}_FL=#{space.buildingStory().get.name}_SCH#{ determine_dominant_schedule([space])}")
+      zone.setName("DU_BT=#{space.spaceType.get.standardsBuildingType.get}_ST=#{space.spaceType.get.standardsSpaceType.get}_FL=#{space.buildingStory.get.name}_SCH#{determine_dominant_schedule([space])}")
       unless space_multiplier_map[space.name.to_s].nil? || (space_multiplier_map[space.name.to_s] == 1)
         zone.setMultiplier(space_multiplier_map[space.name.to_s])
       end
@@ -286,27 +280,28 @@ class NECB2011
   # their own single system 4 system. These will be set to the dominant floor schedule.
 
   def auto_zone_wet_spaces(model:, lights_type: 'NECB_Default', lights_scale: 1.0)
-    wet_zone_array = Array.new
-    model.getSpaces.select {|space| is_an_necb_wet_space?(space)}.each do |space|
-      #if this space was already assigned to something skip it.
+    wet_zone_array = []
+    model.getSpaces.select { |space| is_an_necb_wet_space?(space) }.each do |space|
+      # if this space was already assigned to something skip it.
       next unless space.thermalZone.empty?
+
       # get space to dominant schedule
       dominant_schedule = determine_dominant_schedule(space.model.getSpaces)
-      #create new TZ and set space to the zone.
+      # create new TZ and set space to the zone.
       zone = OpenStudio::Model::ThermalZone.new(model)
       space.setThermalZone(zone)
-      tz_name = "WET_ST=#{space.spaceType.get.standardsSpaceType.get}_FL=#{space.buildingStory().get.name}_SCH#{dominant_schedule}"
+      tz_name = "WET_ST=#{space.spaceType.get.standardsSpaceType.get}_FL=#{space.buildingStory.get.name}_SCH#{dominant_schedule}"
       zone.setName(tz_name)
-      #Set multiplier from the original tz multiplier.
+      # Set multiplier from the original tz multiplier.
       unless space_multiplier_map[space.name.to_s].nil? || (space_multiplier_map[space.name.to_s] == 1)
         zone.setMultiplier(space_multiplier_map[space.name.to_s])
       end
 
-      #this method will determine if the right schedule was used for this wet & wild space if not.. it will reset the space
+      # this method will determine if the right schedule was used for this wet & wild space if not.. it will reset the space
       # to use the correct schedule version of the wet and wild space type.
       adjust_wildcard_spacetype_schedule(space: space, schedule: dominant_schedule, lights_type: lights_type, lights_scale: lights_scale)
 
-      #Find spacetype thermostat and assign it to the zone.
+      # Find spacetype thermostat and assign it to the zone.
       thermostat_name = space.spaceType.get.name.get + ' Thermostat'
       thermostat = model.getThermostatSetpointDualSetpointByName(thermostat_name)
       if thermostat.empty?
@@ -320,10 +315,10 @@ class NECB2011
         ideal_loads.addToThermalZone(zone)
       end
       # Go through other spaces to see if there are similar spaces with similar loads on the same floor that can be grouped.
-      model.getSpaces.select {|s| is_an_necb_wet_space?(s)}.each do |space_target|
+      model.getSpaces.select { |s| is_an_necb_wet_space?(s) }.each do |space_target|
         if space_target.thermalZone.empty?
-          if are_space_loads_similar?(space_1: space, space_2: space_target) && space.buildingStory().get == space_target.buildingStory().get # added since chris needs zones to not span floors for costing.
-            adjust_wildcard_spacetype_schedule(space_target, dominant_schedule, lights_type, lights_scale, space_height)
+          if are_space_loads_similar?(space_1: space, space_2: space_target) && space.buildingStory.get == space_target.buildingStory.get # added since chris needs zones to not span floors for costing.
+            adjust_wildcard_spacetype_schedule(space: space_target, schedule: dominant_schedule, lights_type: lights_type, lights_scale: lights_scale)
             space_target.setThermalZone(zone)
           end
         end
@@ -337,20 +332,21 @@ class NECB2011
   # if the spaces are similar based on exposure and load and blend those spaces into the same zone.  It will not merge spaces
   # from different floors, since this will impact Chris Kirneys costing algorithms.
   def auto_zone_all_other_spaces(model)
-    other_tz_array = Array.new
-    #iterate through all non wildcard spaces.
-    model.getSpaces.select {|space| not is_a_necb_dwelling_unit?(space) and not is_an_necb_wildcard_space?(space)}.each do |space|
-      #skip if already assigned to a thermal zone.
+    other_tz_array = []
+    # iterate through all non wildcard spaces.
+    model.getSpaces.select { |space| !is_a_necb_dwelling_unit?(space) && !is_an_necb_wildcard_space?(space) }.each do |space|
+      # skip if already assigned to a thermal zone.
       next unless space.thermalZone.empty?
-      #create new zone for this space based on the space name.
+
+      # create new zone for this space based on the space name.
       zone = OpenStudio::Model::ThermalZone.new(model)
-      tz_name = "ALL_ST=#{space.spaceType.get.standardsSpaceType.get}_FL=#{space.buildingStory().get.name}_SCH=#{ determine_dominant_schedule([space])}"
+      tz_name = "ALL_ST=#{space.spaceType.get.standardsSpaceType.get}_FL=#{space.buildingStory.get.name}_SCH=#{determine_dominant_schedule([space])}"
       zone.setName(tz_name)
-      #sets space mulitplier unless it is nil or 1.
+      # sets space mulitplier unless it is nil or 1.
       unless space_multiplier_map[space.name.to_s].nil? || (space_multiplier_map[space.name.to_s] == 1)
         zone.setMultiplier(space_multiplier_map[space.name.to_s])
       end
-      #Assign space to the new zone.
+      # Assign space to the new zone.
       space.setThermalZone(zone)
 
       # Add a thermostat
@@ -368,9 +364,9 @@ class NECB2011
         ideal_loads.addToThermalZone(zone)
       end
       # Go through other spaces and if you find something with similar loads on the same floor, add it to the zone.
-      model.getSpaces.select {|space| not is_a_necb_dwelling_unit?(space) and not is_an_necb_wildcard_space?(space)}.each do |space_target|
+      model.getSpaces.select { |curr_space| !is_a_necb_dwelling_unit?(curr_space) && !is_an_necb_wildcard_space?(curr_space) }.each do |space_target|
         if space_target.thermalZone.empty?
-          if are_space_loads_similar?(space_1: space, space_2: space_target) and space.buildingStory().get == space_target.buildingStory().get # added since chris needs zones to not span floors for costing.
+          if are_space_loads_similar?(space_1: space, space_2: space_target) && space.buildingStory.get == space_target.buildingStory.get # added since chris needs zones to not span floors for costing.
             space_target.setThermalZone(zone)
           end
         end
@@ -383,20 +379,21 @@ class NECB2011
   # This will take all the wildcard spaces and merge them to be supported by a system 4. The control zone will be the
   # zone that has the largest heating load per area.
   def auto_zone_wild_spaces(model:, lights_type: 'NECB_Default', lights_scale: 1.0)
-    other_tz_array = Array.new
-    #iterate through wildcard spaces.
-    model.getSpaces.select {|space| is_an_necb_wildcard_space?(space) and not is_an_necb_wet_space?(space)}.each do |space|
-      #skip if already assigned to a thermal zone.
+    other_tz_array = []
+    # iterate through wildcard spaces.
+    model.getSpaces.select { |space| is_an_necb_wildcard_space?(space) && !is_an_necb_wet_space?(space) }.each do |space|
+      # skip if already assigned to a thermal zone.
       next unless space.thermalZone.empty?
-      #create new zone for this space based on the space name.
+
+      # create new zone for this space based on the space name.
       zone = OpenStudio::Model::ThermalZone.new(model)
-      tz_name = "WILD_ST=#{space.spaceType.get.standardsSpaceType.get}_FL=#{space.buildingStory().get.name}_SCH=#{determine_dominant_schedule(space.model.getSpaces)}"
+      tz_name = "WILD_ST=#{space.spaceType.get.standardsSpaceType.get}_FL=#{space.buildingStory.get.name}_SCH=#{determine_dominant_schedule(space.model.getSpaces)}"
       zone.setName(tz_name)
-      #sets space mulitplier unless it is nil or 1.
+      # sets space mulitplier unless it is nil or 1.
       unless space_multiplier_map[space.name.to_s].nil? || (space_multiplier_map[space.name.to_s] == 1)
         zone.setMultiplier(space_multiplier_map[space.name.to_s])
       end
-      #Assign space to the new zone.
+      # Assign space to the new zone.
       space.setThermalZone(zone)
 
       # lets keep the wild schedules to be the same as what dominate the floor.
@@ -422,10 +419,10 @@ class NECB2011
         ideal_loads.addToThermalZone(zone)
       end
       # Go through other spaces and if you find something with similar loads on the same floor, add it to the zone.
-      model.getSpaces.select {|space| is_an_necb_wildcard_space?(space) and not is_an_necb_wet_space?(space)}.each do |space_target|
+      model.getSpaces.select { |curr_space| is_an_necb_wildcard_space?(curr_space) && !is_an_necb_wet_space?(curr_space) }.each do |space_target|
         if space_target.thermalZone.empty?
-          if are_space_loads_similar?(space_1: space, space_2: space_target) and
-              space.buildingStory().get == space_target.buildingStory().get # added since chris needs zones to not span floors for costing.
+          if are_space_loads_similar?(space_1: space, space_2: space_target) &&
+             (space.buildingStory.get == space_target.buildingStory.get) # added since chris needs zones to not span floors for costing.
             space_target.setThermalZone(zone)
           end
         end
@@ -435,62 +432,63 @@ class NECB2011
     return other_tz_array
 
     wild_zone_array = []
-    #Get a list of all the wild spaces.
-    model.getSpaces.select {|space| is_an_necb_wildcard_space?(space) and not is_an_necb_wet_space?(space)}.each do |space|
-      #if this space was already assigned to something skip it.
+    # Get a list of all the wild spaces.
+    model.getSpaces.select { |space| is_an_necb_wildcard_space?(space) && !is_an_necb_wet_space?(space) }.each do |space|
+      # if this space was already assigned to something skip it.
       next unless space.thermalZone.empty?
-      #find adjacent spaces to the current space.
+
+      # find adjacent spaces to the current space.
       adj_spaces = space_get_adjacent_spaces_with_shared_wall_areas(space, true)
-      adj_spaces = adj_spaces.map {|key, value| key}
+      adj_spaces = adj_spaces.map { |key, value| key }
 
       # find unassigned adjacent wild spaces that have not been assigned that have the same multiplier these will be
       # lumped together in the same zone.
-      wild_adjacent_spaces = adj_spaces.select {|adj_space|
-        is_an_necb_wildcard_space?(adj_space) and
-            not is_an_necb_wet_space?(adj_space) and
-            adj_space.thermalZone.empty? and
-            space_multiplier_map[space.name.to_s] == space_multiplier_map[adj_space.name.to_s]
-      }
-      #put them all together.
+      wild_adjacent_spaces = adj_spaces.select do |adj_space|
+        is_an_necb_wildcard_space?(adj_space) &&
+          !is_an_necb_wet_space?(adj_space) &&
+          adj_space.thermalZone.empty? &&
+          (space_multiplier_map[space.name.to_s] == space_multiplier_map[adj_space.name.to_s])
+      end
+      # put them all together.
       wild_adjacent_spaces << space
 
       # Get adjacent candidate foster zones. Must not be a wildcard space and must not be linked to another space incase
       # it is part of a mirrored space.
       other_adjacent_spaces = adj_spaces.select do |adj_space|
-        is_an_necb_wildcard_space?(adj_space) == false and
-            adj_space.thermalZone.get.spaces.size == 1 and
-            space_multiplier_map[space.name.to_s] == space_multiplier_map[adj_space.name.to_s]
+        (is_an_necb_wildcard_space?(adj_space) == false) &&
+          (adj_space.thermalZone.get.spaces.size == 1) &&
+          (space_multiplier_map[space.name.to_s] == space_multiplier_map[adj_space.name.to_s])
       end
 
-      #If there are adjacent spaces that fit the above criteria.
+      # If there are adjacent spaces that fit the above criteria.
       # We will need to set each space to the dominant floor schedule by setting the spaces spacetypes to that
       # schedule version and eventually set it to a system 4
       unless other_adjacent_spaces.empty?
-        #assign the space(s) to the adjacent thermal zone.
+        # assign the space(s) to the adjacent thermal zone.
         schedule_type = determine_dominant_schedule(space.buildingStory.get.spaces)
         zone = other_adjacent_spaces.first.thermalZone.get
-        wild_adjacent_spaces.each do |space|
-          adjust_wildcard_spacetype_schedule(space, schedule_type, @lights_type, @lights_scale, @space_height)
-          space.setThermalZone(zone)
+        wild_adjacent_spaces.each do |curr_space|
+          adjust_wildcard_spacetype_schedule(curr_space, schedule_type, @lights_type, @lights_scale, @space_height)
+          curr_space.setThermalZone(zone)
         end
       end
 
-      #create new TZ and set space to the zone.
+      # create new TZ and set space to the zone.
       zone = OpenStudio::Model::ThermalZone.new(model)
       space.setThermalZone(zone)
-      zone.setName("Wild-ZN:BT=#{space.spaceType.get.standardsBuildingType.get}:ST=#{space.spaceType.get.standardsSpaceType.get}:FL=#{space.buildingStory().get.name}:")
-      #Set multiplier from the original tz multiplier.
+      zone.setName("Wild-ZN:BT=#{space.spaceType.get.standardsBuildingType.get}:ST=#{space.spaceType.get.standardsSpaceType.get}:FL=#{space.buildingStory.get.name}:")
+      # Set multiplier from the original tz multiplier.
       unless space_multiplier_map[space.name.to_s].nil? || (space_multiplier_map[space.name.to_s] == 1)
         zone.setMultiplier(space_multiplier_map[space.name.to_s])
       end
 
       # Set space to dominant
 
-      dominant_floor_schedule = determine_dominant_schedule(space.buildingStory().get.spaces)
-      #this method will determine if the right schedule was used for this wet & wild space if not.. it will reset the space
+      dominant_floor_schedule = determine_dominant_schedule(space.buildingStory.get.spaces)
+      # this method will determine if the right schedule was used for this wet & wild space if not.. it will reset the space
       # to use the correct schedule version of the wet and wild space type.
-      adjust_wildcard_spacetype_schedule(space, dominant_floor_schedule, @lights_type, @lights_scale, @space_height)
-      #Find spacetype thermostat and assign it to the zone.
+      adjust_wildcard_spacetype_schedule(space: space, schedule: dominant_floor_schedule, lights_type: @lights_type, lights_scale: @lights_scale)
+      # Find spacetype thermostat and assign it to the zone.
       thermostat_name = space.spaceType.get.name.get + ' Thermostat'
       thermostat = model.getThermostatSetpointDualSetpointByName(thermostat_name)
       if thermostat.empty?
@@ -504,11 +502,11 @@ class NECB2011
         ideal_loads.addToThermalZone(zone)
       end
       # Go through other spaces to see if there are similar spaces with similar loads on the same floor that can be grouped.
-      model.getSpaces.select {|s| is_an_necb_wildcard_space?(s) and not is_an_necb_wet_space?(s)}.each do |space_target|
+      model.getSpaces.select { |s| is_an_necb_wildcard_space?(s) && !is_an_necb_wet_space?(s) }.each do |space_target|
         if space_target.thermalZone.empty?
           if are_space_loads_similar?(space_1: space, space_2: space_target) &&
-              space.buildingStory().get == space_target.buildingStory().get # added since chris needs zones to not span floors for costing.
-            adjust_wildcard_spacetype_schedule(space_target, dominant_floor_schedule, @lights_type, @lights_scale, @space_height)
+             space.buildingStory.get == space_target.buildingStory.get # added since chris needs zones to not span floors for costing.
+            adjust_wildcard_spacetype_schedule(space: space_target, schedule: dominant_floor_schedule, lights_type: @lights_type, lights_scale: @lights_scale)
             space_target.setThermalZone(zone)
           end
         end
@@ -520,9 +518,10 @@ class NECB2011
 
   # This method will determine if the loads on a zone are similar. (Exposure, space type, space loads, and schedules, etc)
   def are_zone_loads_similar?(zone_1:, zone_2:)
-    #make sure they have the same number of spaces.
+    # make sure they have the same number of spaces.
     truthes = []
     return false if zone_1.spaces.size != zone_2.spaces.size
+
     zone_1.spaces.each do |space_1|
       zone_2.spaces.each do |space_2|
         if are_space_loads_similar?(space_1: space_1, space_2: space_2)
@@ -530,7 +529,7 @@ class NECB2011
         end
       end
     end
-    #truthes sizes should be the same as the # of spaces if all spaces are similar.
+    # truthes sizes should be the same as the # of spaces if all spaces are similar.
     return truthes.size == zone_1.spaces.size
   end
 
@@ -547,129 +546,130 @@ class NECB2011
     return false if space_2.spaceType.empty?
     # ensure that they have the same spacetype.
     return false unless space_1.spaceType.get == space_2.spaceType.get
+
     # Perform surface comparision. If ranges are within percent_difference_tolerance.. they can be considered the same.
     space_1_floor_area = space_1.floorArea
     space_2_floor_area = space_2.floorArea
     space_1_surface_report = space_surface_report(space_1)
     space_2_surface_report = space_surface_report(space_2)
-    #Spaces should have the same number of surface orientations.
+    # Spaces should have the same number of surface orientations.
     return false unless space_1_surface_report.size == space_2_surface_report.size
-    #spaces should have similar loads
-    return false unless self.percentage_difference(stored_space_heating_load(space_1), stored_space_heating_load(space_2)) <= heating_load_percent_difference_tolerance
-    #Each surface should match
+    # spaces should have similar loads
+    return false unless percentage_difference(stored_space_heating_load(space_1), stored_space_heating_load(space_2)) <= heating_load_percent_difference_tolerance
+
+    # Each surface should match
     space_1_surface_report.each do |space_1_surface|
       surface_match = space_2_surface_report.detect do |space_2_surface|
         space_1_surface[:surface_type] == space_2_surface[:surface_type] &&
-            space_1_surface[:boundary_condition] == space_2_surface[:boundary_condition] &&
-            self.percentage_difference(space_1_surface[:tilt], space_2_surface[:tilt]) <= angular_percent_difference_tolerance &&
-            self.percentage_difference(space_1_surface[:azimuth], space_2_surface[:azimuth]) <= angular_percent_difference_tolerance &&
-            self.percentage_difference(space_1_surface[:surface_area_to_floor_ratio],
-                                       space_2_surface[:surface_area_to_floor_ratio]) <= surface_percent_difference_tolerance &&
-            self.percentage_difference(space_1_surface[:glazed_subsurface_area_to_floor_ratio],
-                                       space_2_surface[:glazed_subsurface_area_to_floor_ratio]) <= surface_percent_difference_tolerance &&
-            self.percentage_difference(space_1_surface[:opaque_subsurface_area_to_floor_ratio],
-                                       space_2_surface[:opaque_subsurface_area_to_floor_ratio]) <= surface_percent_difference_tolerance
-
+          space_1_surface[:boundary_condition] == space_2_surface[:boundary_condition] &&
+          percentage_difference(space_1_surface[:tilt], space_2_surface[:tilt]) <= angular_percent_difference_tolerance &&
+          percentage_difference(space_1_surface[:azimuth], space_2_surface[:azimuth]) <= angular_percent_difference_tolerance &&
+          percentage_difference(space_1_surface[:surface_area_to_floor_ratio],
+                                space_2_surface[:surface_area_to_floor_ratio]) <= surface_percent_difference_tolerance &&
+          percentage_difference(space_1_surface[:glazed_subsurface_area_to_floor_ratio],
+                                space_2_surface[:glazed_subsurface_area_to_floor_ratio]) <= surface_percent_difference_tolerance &&
+          percentage_difference(space_1_surface[:opaque_subsurface_area_to_floor_ratio],
+                                space_2_surface[:opaque_subsurface_area_to_floor_ratio]) <= surface_percent_difference_tolerance
       end
       return false if surface_match.nil?
     end
     return true
   end
 
-  #This method gathers the surface information for the space to determine if spaces are the same.
+  # This method gathers the surface information for the space to determine if spaces are the same.
   def space_surface_report(space)
     surface_report = []
     space_floor_area = space.floorArea
     ['Outdoors', 'Ground'].each do |bc|
       surfaces = BTAP::Geometry::Surfaces.filter_by_boundary_condition(space.surfaces, [bc]).each do |surface|
-        #sum wall area and subsurface area by direction. This is the old way so excluding top and bottom surfaces.
-        #new way
-        glazings = BTAP::Geometry::Surfaces::filter_subsurfaces_by_types(surface.subSurfaces, ["FixedWindow",
-                                                                                               "OperableWindow",
-                                                                                               "GlassDoor",
-                                                                                               "Skylight",
-                                                                                               "TubularDaylightDiffuser",
-                                                                                               "TubularDaylightDome"])
-        doors = BTAP::Geometry::Surfaces::filter_subsurfaces_by_types(surface.subSurfaces, ["Door",
-                                                                                            "OverheadDoor"])
+        # sum wall area and subsurface area by direction. This is the old way so excluding top and bottom surfaces.
+        # new way
+        glazings = BTAP::Geometry::Surfaces.filter_subsurfaces_by_types(surface.subSurfaces, ['FixedWindow',
+                                                                                              'OperableWindow',
+                                                                                              'GlassDoor',
+                                                                                              'Skylight',
+                                                                                              'TubularDaylightDiffuser',
+                                                                                              'TubularDaylightDome'])
+        doors = BTAP::Geometry::Surfaces.filter_subsurfaces_by_types(surface.subSurfaces, ['Door',
+                                                                                           'OverheadDoor'])
         azimuth = (surface.azimuth() * 180.0 / Math::PI)
         tilt = (surface.tilt() * 180.0 / Math::PI)
-        surface_data = surface_report.detect do |surface_data|
-          surface_data[:surface_type] == surface.surfaceType &&
-              surface_data[:azimuth] == azimuth &&
-              surface_data[:tilt] == tilt &&
-              surface_data[:boundary_condition] == bc
+        surface_data = surface_report.detect do |curr_surface_data|
+          curr_surface_data[:surface_type] == surface.surfaceType &&
+            curr_surface_data[:azimuth] == azimuth &&
+            curr_surface_data[:tilt] == tilt &&
+            curr_surface_data[:boundary_condition] == bc
         end
 
         if surface_data.nil?
           surface_data = {
-              surface_type: surface.surfaceType,
-              azimuth: azimuth,
-              tilt: tilt,
-              boundary_condition: bc,
-              surface_area: 0,
-              surface_area_to_floor_ratio: 0,
-              glazed_subsurface_area: 0,
-              glazed_subsurface_area_to_floor_ratio: 0,
-              opaque_subsurface_area: 0,
-              opaque_subsurface_area_to_floor_ratio: 0
+            surface_type: surface.surfaceType,
+            azimuth: azimuth,
+            tilt: tilt,
+            boundary_condition: bc,
+            surface_area: 0,
+            surface_area_to_floor_ratio: 0,
+            glazed_subsurface_area: 0,
+            glazed_subsurface_area_to_floor_ratio: 0,
+            opaque_subsurface_area: 0,
+            opaque_subsurface_area_to_floor_ratio: 0
           }
           surface_report << surface_data
         end
         surface_data[:surface_area] += surface.grossArea.to_i
         surface_data[:surface_area_to_floor_ratio] += surface.grossArea / space.floorArea
 
-        surface_data[:glazed_subsurface_area] += glazings.map {|subsurface| subsurface.grossArea * subsurface.multiplier}.inject(0) {|sum, x| sum + x}.to_i
-        surface_data[:glazed_subsurface_area_to_floor_ratio] += glazings.map {|subsurface| subsurface.grossArea * subsurface.multiplier}.inject(0) {|sum, x| sum + x} / space.floorArea
+        surface_data[:glazed_subsurface_area] += glazings.map { |subsurface| subsurface.grossArea * subsurface.multiplier }.inject(0) { |sum, x| sum + x }.to_i
+        surface_data[:glazed_subsurface_area_to_floor_ratio] += glazings.map { |subsurface| subsurface.grossArea * subsurface.multiplier }.inject(0) { |sum, x| sum + x } / space.floorArea
 
-        surface_data[:surface_area] += doors.map {|subsurface| subsurface.grossArea * subsurface.multiplier}.inject(0) {|sum, x| sum + x}.to_i
-        surface_data[:surface_area_to_floor_ratio] += doors.map {|subsurface| subsurface.grossArea * subsurface.multiplier}.inject(0) {|sum, x| sum + x} / space.floorArea
+        surface_data[:surface_area] += doors.map { |subsurface| subsurface.grossArea * subsurface.multiplier }.inject(0) { |sum, x| sum + x }.to_i
+        surface_data[:surface_area_to_floor_ratio] += doors.map { |subsurface| subsurface.grossArea * subsurface.multiplier }.inject(0) { |sum, x| sum + x } / space.floorArea
       end
     end
-    surface_report.sort! {|a, b| [a[:surface_type], a[:azimuth], a[:tilt], a[:boundary_condition]] <=> [b[:surface_type], b[:azimuth], b[:tilt], b[:boundary_condition]]}
+    surface_report.sort! { |a, b| [a[:surface_type], a[:azimuth], a[:tilt], a[:boundary_condition]] <=> [b[:surface_type], b[:azimuth], b[:tilt], b[:boundary_condition]] }
 
     return surface_report
   end
 
-  #Check to see if this is a wildcard space that the NECB does not have a specified schedule or system for.
+  # Check to see if this is a wildcard space that the NECB does not have a specified schedule or system for.
   def is_an_necb_wildcard_space?(space)
     space_type_table = @standards_data['space_types']
     space_type_data = model_find_object(space_type_table,
-                                        {'template' => self.class.name,
-                                         'space_type' => space.spaceType.get.standardsSpaceType.get,
-                                         'building_type' => space.spaceType.get.standardsBuildingType.get})
-    raise("#{space}") if space_type_data.nil?
-    return space_type_data["necb_hvac_system_selection_type"] == "Wildcard"
+                                        'template' => self.class.name,
+                                        'space_type' => space.spaceType.get.standardsSpaceType.get,
+                                        'building_type' => space.spaceType.get.standardsBuildingType.get)
+    raise(space.to_s) if space_type_data.nil?
+
+    return space_type_data['necb_hvac_system_selection_type'] == 'Wildcard'
   end
 
   # Check to see if this is a wet space that the NECB does not have a specified schedule or system for. Currently hardcoded to
   # Locker room and washroom.
   def is_an_necb_wet_space?(space)
-    #Hack! Should replace this with a proper table lookup.
+    # Hack! Should replace this with a proper table lookup.
     return space.spaceType.get.standardsSpaceType.get.include?('Locker room') || space.spaceType.get.standardsSpaceType.get.include?('Washroom')
   end
 
   # Check to see if this is a wet space that the NECB does not have a specified schedule or system for. Currently hardcoded to
   # Locker room and washroom.
   def is_an_necb_storage_space?(space)
-    #Hack! Should replace this with a proper table lookup.
+    # Hack! Should replace this with a proper table lookup.
     return space.spaceType.get.standardsSpaceType.get.include?('Storage')
   end
 
-
   # Check if the space spactype is a dwelling unit as per NECB.
   def is_a_necb_dwelling_unit?(space)
     space_type_table = @standards_data['space_types']
     space_type_data = model_find_object(space_type_table,
-                                        {'template' => self.class.name,
-                                         'space_type' => space.spaceType.get.standardsSpaceType.get,
-                                         'building_type' => space.spaceType.get.standardsBuildingType.get})
+                                        'template' => self.class.name,
+                                        'space_type' => space.spaceType.get.standardsSpaceType.get,
+                                        'building_type' => space.spaceType.get.standardsBuildingType.get)
 
     necb_hvac_system_selection_table = @standards_data['necb_hvac_system_selection_type']
-    necb_hvac_system_select = necb_hvac_system_selection_table.detect do |necb_hvac_system_select|
-      necb_hvac_system_select['necb_hvac_system_selection_type'] == space_type_data['necb_hvac_system_selection_type'] &&
-          necb_hvac_system_select['min_stories'] <= space.model.getBuilding.standardsNumberOfAboveGroundStories.get &&
-          necb_hvac_system_select['max_stories'] >= space.model.getBuilding.standardsNumberOfAboveGroundStories.get
+    necb_hvac_system_select = necb_hvac_system_selection_table.detect do |curr_necb_hvac_system_select|
+      curr_necb_hvac_system_select['necb_hvac_system_selection_type'] == space_type_data['necb_hvac_system_selection_type'] &&
+        curr_necb_hvac_system_select['min_stories'] <= space.model.getBuilding.standardsNumberOfAboveGroundStories.get &&
+        curr_necb_hvac_system_select['max_stories'] >= space.model.getBuilding.standardsNumberOfAboveGroundStories.get
     end
     return necb_hvac_system_select['dwelling'] == true
   end
@@ -677,21 +677,24 @@ class NECB2011
   # Determines what system index number is required for the space's spacetype by NECB rules.
   def get_necb_spacetype_system_selection(space)
     space_type_table = @standards_data['space_types']
-    space_type_data = model_find_object(space_type_table, {'space_type' => space.spaceType.get.standardsSpaceType.get,
-                                                           'building_type' => space.spaceType.get.standardsBuildingType.get})
-    raise("Could not find space_type_data for #{{'space_type' => space.spaceType.get.standardsSpaceType.get,
-                                                 'building_type' => space.spaceType.get.standardsBuildingType.get}} ")if space_type_data.nil?
+    space_type_data = model_find_object(space_type_table, 'space_type' => space.spaceType.get.standardsSpaceType.get,
+                                                          'building_type' => space.spaceType.get.standardsBuildingType.get)
+    if space_type_data.nil?
+      raise("Could not find space_type_data for #{{ 'space_type' => space.spaceType.get.standardsSpaceType.get,
+                                                    'building_type' => space.spaceType.get.standardsBuildingType.get }} ")
+    end
 
     # identify space-system_index and assign the right NECB system type 1-7.
     necb_hvac_system_selection_table = @standards_data['necb_hvac_system_selection_type']
-    necb_hvac_system_select = necb_hvac_system_selection_table.detect do |necb_hvac_system_select|
-      necb_hvac_system_select['necb_hvac_system_selection_type'] == space_type_data['necb_hvac_system_selection_type'] &&
-          necb_hvac_system_select['min_stories'] <= space.model.getBuilding.standardsNumberOfAboveGroundStories.get &&
-          necb_hvac_system_select['max_stories'] >= space.model.getBuilding.standardsNumberOfAboveGroundStories.get &&
-          necb_hvac_system_select['min_cooling_capacity_kw'] <= self.stored_space_cooling_load(space) &&
-          necb_hvac_system_select['max_cooling_capacity_kw'] >= self.stored_space_cooling_load(space)
+    necb_hvac_system_select = necb_hvac_system_selection_table.detect do |curr_necb_hvac_system_select|
+      curr_necb_hvac_system_select['necb_hvac_system_selection_type'] == space_type_data['necb_hvac_system_selection_type'] &&
+        curr_necb_hvac_system_select['min_stories'] <= space.model.getBuilding.standardsNumberOfAboveGroundStories.get &&
+        curr_necb_hvac_system_select['max_stories'] >= space.model.getBuilding.standardsNumberOfAboveGroundStories.get &&
+        curr_necb_hvac_system_select['min_cooling_capacity_kw'] <= stored_space_cooling_load(space) &&
+        curr_necb_hvac_system_select['max_cooling_capacity_kw'] >= stored_space_cooling_load(space)
     end
-    raise("could not find system for given spacetype") if necb_hvac_system_select.nil?
+    raise('could not find system for given spacetype') if necb_hvac_system_select.nil?
+
     return necb_hvac_system_select['system_type']
   end
 
@@ -703,20 +706,22 @@ class NECB2011
     end
     systems.uniq!
     systems.compact!
-    raise("This thermal zone spaces require different systems.") if systems.size > 1
+    raise('This thermal zone spaces require different systems.') if systems.size > 1
+
     return systems.first
   end
 
   # Math fundtion to determine percent difference.
   def percentage_difference(value_1, value_2)
     return 0.0 if value_1 == value_2
+
     return ((value_1 - value_2).abs / ((value_1 + value_2) / 2) * 100)
   end
 
   # Set wildcard spactype schedule to NECB letter index.
   def adjust_wildcard_spacetype_schedule(space:, schedule:, lights_type: 'NECB_Default', lights_scale: 1.0)
     if space.spaceType.empty?
-      OpenStudio.logFree(OpenStudio::Error, 'Error: No spacetype assigned for #{space.name.get}. This must be assigned. Aborting.')
+      OpenStudio.logFree(OpenStudio::Error, "Error: No spacetype assigned for #{space.name.get}. This must be assigned. Aborting.")
     end
     # Get current spacetype name
     space_type_name = space.spaceType.get.standardsSpaceType.get.to_s
@@ -725,13 +730,13 @@ class NECB2011
     new_spacetype_name = "#{space_type_name.match(regex).captures.first}#{schedule}"
     new_spacetype = nil
 
-    #if the new spacetype does not match the old space type. we gotta update the space with the new spacetype.
+    # if the new spacetype does not match the old space type. we gotta update the space with the new spacetype.
     if space_type_name != new_spacetype_name
       new_spacetype = space.model.getSpaceTypes.detect do |spacetype|
-        (not spacetype.standardsBuildingType.empty?) and #need to do this to prevent an exception.
-            spacetype.standardsBuildingType.get == space.spaceType.get.standardsBuildingType.get and
-            (not spacetype.standardsSpaceType.empty?) and #need to do this to prevent an exception.
-            spacetype.standardsSpaceType.get == new_spacetype_name
+        !spacetype.standardsBuildingType.empty? && # need to do this to prevent an exception.
+          (spacetype.standardsBuildingType.get == space.spaceType.get.standardsBuildingType.get) &&
+          !spacetype.standardsSpaceType.empty? && # need to do this to prevent an exception.
+          (spacetype.standardsSpaceType.get == new_spacetype_name)
       end
       if new_spacetype.nil?
         # Space type is not in model. need to create from scratch.
@@ -743,14 +748,14 @@ class NECB2011
         space_type_apply_internal_load_schedules(new_spacetype, true, true, true, true, true, true, true)
       end
       space.setSpaceType(new_spacetype)
-      #sanity check.
-      raise ("could not reassign space type schedule.") if schedule != space.spaceType.get.name.get.match(regex)[2]
+      # sanity check.
+      raise 'could not reassign space type schedule.' if schedule != space.spaceType.get.name.get.match(regex)[2]
     end
     return space
   end
 
   def set_wildcard_schedules_to_dominant_building_schedule(model, runner = nil)
-    #Get rid of.
+    # Get rid of.
   end
 
   def determine_dominant_schedule(spaces)
@@ -780,15 +785,14 @@ class NECB2011
         'Q', 0
     ]
     # iterate through spaces in building.
-    spaces.select {|space| not is_an_necb_wildcard_space?(space) and not space.spaceType.get.standardsSpaceType.get == '- undefined -'}.each do |space|
-
+    spaces.select { |space| !is_an_necb_wildcard_space?(space) && (space.spaceType.get.standardsSpaceType.get != '- undefined -') }.each do |space|
       # Ensure space floors are multiplied.
       mult = @space_multiplier_map[space.name.to_s].nil? ? 1.0 : @space_multiplier_map[space.name.to_s]
       # puts "this #{determine_necb_schedule_type(space)}"
       schedule_hash[determine_necb_schedule_type(space)] += space.floorArea * mult
     end
     # finds max value and returns NECB schedule letter.
-    #determine dominant letter schedule.
+    # determine dominant letter schedule.
     return schedule_hash.max_by(&:last).first
   end
 
@@ -807,7 +811,8 @@ class NECB2011
     spacetype_data = @standards_data['space_types']
     raise "Spacetype not defined for space #{space.get.name}) if space.spaceType.empty?" if space.spaceType.empty?
     raise "Undefined standardsSpaceType or StandardsBuildingType for space #{space.spaceType.get.name}) if space.spaceType.empty?" if space.spaceType.get.standardsSpaceType.empty? | space.spaceType.get.standardsBuildingType.empty?
-    space_type_properties = spacetype_data.detect {|st| (st['space_type'] == space.spaceType.get.standardsSpaceType.get) && (st['building_type'] == space.spaceType.get.standardsBuildingType.get)}
+
+    space_type_properties = spacetype_data.detect { |st| (st['space_type'] == space.spaceType.get.standardsSpaceType.get) && (st['building_type'] == space.spaceType.get.standardsBuildingType.get) }
     return space_type_properties['necb_schedule_type'].strip
   end
 
@@ -815,34 +820,35 @@ class NECB2011
 
   # Method will create a hot water loop if systems default fuel and medium sources require it.
   def create_hw_loop_if_required(baseboard_type, boiler_fueltype, mau_heating_coil_type, model)
-    #get systems that will be used in the model based on the space types to determine if a hw_loop is required.
+    # get systems that will be used in the model based on the space types to determine if a hw_loop is required.
     systems_used = []
     model.getSpaces.sort.each do |space|
       systems_used << get_necb_spacetype_system_selection(space)
       systems_used.uniq!
     end
 
-    #See if we need to create a hot water loop based on fueltype and systems used.
+    # See if we need to create a hot water loop based on fueltype and systems used.
     hw_loop_needed = false
     systems_used.each do |system|
       case system.to_s
       when '2', '5', '7'
         hw_loop_needed = true
       when '1', '6'
-        if mau_heating_coil_type == 'Hot Water' or baseboard_type == 'Hot Water'
+        if (mau_heating_coil_type == 'Hot Water') || (baseboard_type == 'Hot Water')
           hw_loop_needed = true
         end
       when '3', '4'
-        if mau_heating_coil_type == 'Hot Water' or baseboard_type == 'Hot Water'
-          hw_loop_needed = true if (baseboard_type == 'Hot Water')
+        if (mau_heating_coil_type == 'Hot Water') || (baseboard_type == 'Hot Water')
+          hw_loop_needed = true if baseboard_type == 'Hot Water'
         end
       end
       if hw_loop_needed
         # just need one true condition to need a boiler.
         break
       end
-    end # each
-    #create hw_loop as needed.. Assuming one loop per model.
+      # each
+    end
+    # create hw_loop as needed.. Assuming one loop per model.
     if hw_loop_needed
       @hw_loop = OpenStudio::Model::PlantLoop.new(model)
       always_on = model.alwaysOnDiscreteSchedule
@@ -874,16 +880,16 @@ class NECB2011
       system_zones_hash[get_necb_thermal_zone_system_selection(zone)] = [] if system_zones_hash[get_necb_thermal_zone_system_selection(zone)].nil?
       system_zones_hash[get_necb_thermal_zone_system_selection(zone)] << zone
     end
-    #puts JSON.pretty_generate(system_zones_hash)
+    # puts JSON.pretty_generate(system_zones_hash)
     # go through each system and zones pairs to
-    system_zones_hash.each_pair do |system, zones|
+    system_zones_hash.each_pair do |system, sys_zones|
       case system
       when 0, nil
         # Do nothing no system assigned to zone. Used for Unconditioned spaces
       when 1
-        group_similar_zones_together(zones).each do |zones|
+        group_similar_zones_together(sys_zones).each do |curr_zones|
           mau_air_loop = add_sys1_unitary_ac_baseboard_heating(model: model,
-                                                               zones: zones,
+                                                               zones: curr_zones,
                                                                mau_type: mau_type,
                                                                mau_heating_coil_type: mau_heating_coil_type,
                                                                baseboard_type: baseboard_type,
@@ -891,41 +897,41 @@ class NECB2011
                                                                multispeed: false)
         end
       when 2
-        group_similar_zones_together(zones).each do |zones|
+        group_similar_zones_together(sys_zones).each do |curr_zones|
           add_sys2_FPFC_sys5_TPFC(model: model,
-                                  zones: zones,
+                                  zones: curr_zones,
                                   chiller_type: chiller_type,
                                   mau_cooling_type: mau_cooling_type,
                                   fan_coil_type: 'FPFC',
                                   hw_loop: @hw_loop)
         end
       when 3
-        group_similar_zones_together(zones).each do |zones|
+        group_similar_zones_together(sys_zones).each do |curr_zones|
           add_sys3and8_single_zone_packaged_rooftop_unit_with_baseboard_heating(model: model,
-                                                                                zones: zones,
+                                                                                zones: curr_zones,
                                                                                 heating_coil_type: heating_coil_type_sys3,
                                                                                 baseboard_type: baseboard_type,
                                                                                 hw_loop: @hw_loop,
                                                                                 multispeed: false)
         end
       when 4
-        group_similar_zones_together(zones).each do |zones|
+        group_similar_zones_together(sys_zones).each do |curr_zones|
           add_sys4_single_zone_make_up_air_unit_with_baseboard_heating(model: model,
-                                                                       zones: zones,
+                                                                       zones: curr_zones,
                                                                        heating_coil_type: heating_coil_type_sys4,
                                                                        baseboard_type: baseboard_type,
                                                                        hw_loop: @hw_loop)
-#          add_sys3and8_single_zone_packaged_rooftop_unit_with_baseboard_heating(model: model,
-#                                                                                zones: zones,
-#                                                                                heating_coil_type: heating_coil_type_sys4,
-#                                                                                baseboard_type: baseboard_type,
-#                                                                                hw_loop: @hw_loop,
-#                                                                                multispeed: false)
+          #          add_sys3and8_single_zone_packaged_rooftop_unit_with_baseboard_heating(model: model,
+          #                                                                                zones: zones,
+          #                                                                                heating_coil_type: heating_coil_type_sys4,
+          #                                                                                baseboard_type: baseboard_type,
+          #                                                                                hw_loop: @hw_loop,
+          #                                                                                multispeed: false)
         end
       when 5
-        group_similar_zones_together(zones).each do |zones|
+        group_similar_zones_together(sys_zones).each do |curr_zones|
           add_sys2_FPFC_sys5_TPFC(model: model,
-                                  zones: zones,
+                                  zones: curr_zones,
                                   chiller_type: chiller_type,
                                   mau_cooling_type: mau_cooling_type,
                                   fan_coil_type: 'TPFC',
@@ -933,7 +939,7 @@ class NECB2011
         end
       when 6
         add_sys6_multi_zone_built_up_system_with_baseboard_heating(model: model,
-                                                                   zones: zones,
+                                                                   zones: sys_zones,
                                                                    heating_coil_type: heating_coil_type_sys6,
                                                                    baseboard_type: baseboard_type,
                                                                    chiller_type: chiller_type,
@@ -941,9 +947,9 @@ class NECB2011
                                                                    hw_loop: @hw_loop)
 
       when 7
-        group_similar_zones_together(zones).each do |zones|
+        group_similar_zones_together(sys_zones).each do |curr_zones|
           add_sys2_FPFC_sys5_TPFC(model: model,
-                                  zones: zones,
+                                  zones: curr_zones,
                                   chiller_type: chiller_type,
                                   fan_coil_type: 'FPFC',
                                   mau_cooling_type: mau_cooling_type,
@@ -965,21 +971,20 @@ class NECB2011
                                    mau_cooling_type:,
                                    mau_heating_coil_type:,
                                    mau_type:,
-                                   model:
-  )
+                                   model:)
 
     zones = []
     other_spaces = model.getSpaces.select do |space|
-      (not is_a_necb_dwelling_unit?(space)) and
-          (not is_an_necb_wildcard_space?(space)) and
-          (not is_an_necb_storage_space?(space))
+      !is_a_necb_dwelling_unit?(space) &&
+        !is_an_necb_wildcard_space?(space) &&
+        !is_an_necb_storage_space?(space)
     end
     other_spaces.each do |space|
       zones << space.thermalZone.get
     end
     zones.uniq!
 
-    #since dwelling units are all zoned 1:1 to space:zone we simply add the zone to the appropriate btap system.
+    # since dwelling units are all zoned 1:1 to space:zone we simply add the zone to the appropriate btap system.
     create_necb_system(baseboard_type: baseboard_type,
                        boiler_fueltype: boiler_fueltype,
                        chiller_type: chiller_type,
@@ -1009,40 +1014,39 @@ class NECB2011
                                  mau_cooling_type:,
                                  mau_heating_coil_type:,
                                  mau_type:,
-                                 model:
-  )
+                                 model:)
 
     system_zones_hash = {}
     # Detemine if dwelling units have a shared AHU.  If user entered building stories > 4 then set to true.
     dwelling_shared_ahu = model.getBuilding.standardsNumberOfAboveGroundStories.get > 4
     # store dwelling zones into array
     zones = []
-    model.getSpaces.select {|space| is_a_necb_dwelling_unit?(space)}.each do |space|
+    model.getSpaces.select { |space| is_a_necb_dwelling_unit?(space) }.each do |space|
       zones << space.thermalZone.get
     end
     zones.uniq!
 
-    #sort system 1 or 3 used for each dwelling unit as per T8.4.4.8.A NECB 2011-17
+    # sort system 1 or 3 used for each dwelling unit as per T8.4.4.8.A NECB 2011-17
     zones.each do |zone|
       system_zones_hash[get_necb_thermal_zone_system_selection(zone)] = [] if system_zones_hash[get_necb_thermal_zone_system_selection(zone)].nil?
       system_zones_hash[get_necb_thermal_zone_system_selection(zone)] << zone
     end
 
     # go through each system and zones pairs to
-    system_zones_hash.each_pair do |system, zones|
+    system_zones_hash.each_pair do |system, sys_zones|
       case system
       when 1
         if dwelling_shared_ahu
           add_sys1_unitary_ac_baseboard_heating(model: model,
-                                                zones: zones,
+                                                zones: sys_zones,
                                                 mau_type: mau_type,
                                                 mau_heating_coil_type: mau_heating_coil_type,
                                                 baseboard_type: baseboard_type,
                                                 hw_loop: @hw_loop,
                                                 multispeed: false)
         else
-          #Create a separate air loop for each unit.
-          zones.each do |zone|
+          # Create a separate air loop for each unit.
+          sys_zones.each do |zone|
             add_sys1_unitary_ac_baseboard_heating(model: model,
                                                   zones: [zone],
                                                   mau_type: mau_type,
@@ -1050,21 +1054,20 @@ class NECB2011
                                                   baseboard_type: baseboard_type,
                                                   hw_loop: @hw_loop,
                                                   multispeed: false)
-
           end
         end
 
       when 3
         if dwelling_shared_ahu
           add_sys3and8_single_zone_packaged_rooftop_unit_with_baseboard_heating(model: model,
-                                                                                zones: zones,
+                                                                                zones: sys_zones,
                                                                                 heating_coil_type: heating_coil_type_sys3,
                                                                                 baseboard_type: baseboard_type,
                                                                                 hw_loop: @hw_loop,
                                                                                 multispeed: false)
         else
-          #Create a separate air loop for each unit.
-          zones.each do |zone|
+          # Create a separate air loop for each unit.
+          sys_zones.each do |zone|
             add_sys3and8_single_zone_packaged_rooftop_unit_with_baseboard_heating(model: model,
                                                                                   zones: [zone],
                                                                                   heating_coil_type: heating_coil_type_sys3,
@@ -1082,94 +1085,87 @@ class NECB2011
                              boiler_fueltype:,
                              heating_coil_type_sys4:,
                              model:)
-    #Determine what zones are wet zones.
+    # Determine what zones are wet zones.
     wet_tz = []
-    model.getSpaces.select {|space|
-      is_an_necb_wet_space?(space)}.each do |space|
-      wet_tz << space.thermalZone.get
-    end
+    wet_spaces = model.getSpaces.select { |space| is_an_necb_wet_space?(space) }
+    wet_spaces.each { |space| wet_tz << space.thermalZone.get }
     wet_tz.uniq!
-    #create a system 4 for the wet zones.
-    unless wet_tz.empty?
-      add_sys4_single_zone_make_up_air_unit_with_baseboard_heating(model: model,
-                                                                   zones: wet_tz,
-                                                                   heating_coil_type: heating_coil_type_sys4,
-                                                                   baseboard_type: baseboard_type,
-                                                                   hw_loop: @hw_loop)
-#      add_sys3and8_single_zone_packaged_rooftop_unit_with_baseboard_heating(model: model,
-#                                                                            zones: wet_tz,
-#                                                                            heating_coil_type: heating_coil_type_sys4,
-#                                                                            baseboard_type: baseboard_type,
-#                                                                            hw_loop: @hw_loop,
-#                                                                            multispeed: false)
-    end
+    # create a system 4 for the wet zones.
+    return if wet_tz.empty?
+
+    add_sys4_single_zone_make_up_air_unit_with_baseboard_heating(model: model,
+                                                                 zones: wet_tz,
+                                                                 heating_coil_type: heating_coil_type_sys4,
+                                                                 baseboard_type: baseboard_type,
+                                                                 hw_loop: @hw_loop)
+    #      add_sys3and8_single_zone_packaged_rooftop_unit_with_baseboard_heating(model: model,
+    #                                                                            zones: wet_tz,
+    #                                                                            heating_coil_type: heating_coil_type_sys4,
+    #                                                                            baseboard_type: baseboard_type,
+    #                                                                            hw_loop: @hw_loop,
+    #                                                                            multispeed: false)
   end
 
-
   # All wet spaces will be on their own system 4 AHU.
   def auto_system_storage_spaces(baseboard_type:,
                                  boiler_fueltype:,
                                  heating_coil_type_sys4:,
                                  model:)
-    #Determine what zones are wet zones.
+    # Determine what zones are storage zones.
     tz = []
-    model.getSpaces.select {|space|
-      is_an_necb_storage_space?(space)}.each do |space|
-      tz << space.thermalZone.get
-    end
+    storage_spaces = model.getSpaces.select { |space| is_an_necb_storage_space?(space) }
+    storage_spaces.each { |space| tz << space.thermalZone.get }
     tz.uniq!
-    #create a system 4 for the  zones.
-    unless tz.empty?
-      add_sys4_single_zone_make_up_air_unit_with_baseboard_heating(model: model,
-                                                                   zones: tz,
-                                                                   heating_coil_type: heating_coil_type_sys4,
-                                                                   baseboard_type: baseboard_type,
-                                                                   hw_loop: @hw_loop)
-#      add_sys3and8_single_zone_packaged_rooftop_unit_with_baseboard_heating(model: model,
-#                                                                            zones: tz,
-#                                                                            heating_coil_type: heating_coil_type_sys4,
-#                                                                            baseboard_type: baseboard_type,
-#                                                                            hw_loop: @hw_loop,
-#                                                                            multispeed: true)
-    end
-  end
 
+    return if tz.empty?
+
+    # create a system 4 for the  zones.
+    add_sys4_single_zone_make_up_air_unit_with_baseboard_heating(model: model,
+                                                                 zones: tz,
+                                                                 heating_coil_type: heating_coil_type_sys4,
+                                                                 baseboard_type: baseboard_type,
+                                                                 hw_loop: @hw_loop)
+    #      add_sys3and8_single_zone_packaged_rooftop_unit_with_baseboard_heating(model: model,
+    #                                                                            zones: tz,
+    #                                                                            heating_coil_type: heating_coil_type_sys4,
+    #                                                                            baseboard_type: baseboard_type,
+    #                                                                            hw_loop: @hw_loop,
+    #                                                                            multispeed: true)
+  end
 
   # All wild spaces will be on a single system 4 ahu with the largests heating load zone being the control zone.
   def auto_system_wild_spaces(baseboard_type:,
                               heating_coil_type_sys4:,
-                              model:
-  )
+                              model:)
 
     zones = []
-    model.getSpaces.select {|space|
-      not is_an_necb_wet_space?(space) and is_an_necb_wildcard_space?(space)}.each do |space|
-      zones << space.thermalZone.get
-    end
+    wild_spaces = model.getSpaces.select { |space| !is_an_necb_wet_space?(space) && is_an_necb_wildcard_space?(space) }
+    wild_spaces.each { |space| zones << space.thermalZone.get }
     zones.uniq!
-    unless zones.empty?
-      #create a system 4 for the wild zones.
-      add_sys4_single_zone_make_up_air_unit_with_baseboard_heating(model: model,
-                                                                   zones: zones,
-                                                                   heating_coil_type: heating_coil_type_sys4,
-                                                                   baseboard_type: baseboard_type,
-                                                                   hw_loop: @hw_loop)
-#      add_sys3and8_single_zone_packaged_rooftop_unit_with_baseboard_heating(model: model,
-#                                                                            zones: zones,
-#                                                                            heating_coil_type: heating_coil_type_sys4,
-#                                                                            baseboard_type: baseboard_type,
-#                                                                            hw_loop: @hw_loop,
-#                                                                            multispeed: true)
-    end
+
+    return if zones.empty?
+
+    # create a system 4 for the wild zones.
+    add_sys4_single_zone_make_up_air_unit_with_baseboard_heating(model: model,
+                                                                 zones: zones,
+                                                                 heating_coil_type: heating_coil_type_sys4,
+                                                                 baseboard_type: baseboard_type,
+                                                                 hw_loop: @hw_loop)
+    #      add_sys3and8_single_zone_packaged_rooftop_unit_with_baseboard_heating(model: model,
+    #                                                                            zones: zones,
+    #                                                                            heating_coil_type: heating_coil_type_sys4,
+    #                                                                            baseboard_type: baseboard_type,
+    #                                                                            hw_loop: @hw_loop,
+    #                                                                            multispeed: true)
   end
 
-  #This method will determine the control zone from the last sizing run space loads.
+  # This method will determine the control zone from the last sizing run space loads.
   def determine_control_zone(zones)
     # In this case the control zone is the load with the largest heating loads. This may cause overheating of some zones.
     # but this is preferred to unmet heating.
-    #Iterate through zones.
+    # Iterate through zones.
     zone_heating_load_hash = {}
-    zones.each {|zone| zone_heating_load_hash[zone] = self.stored_zone_heating_load(zone)}
+    zones.each { |zone| zone_heating_load_hash[zone] = stored_zone_heating_load(zone) }
     return zone_heating_load_hash.max_by(&:last).first
   end
 
@@ -1182,6 +1178,7 @@ class NECB2011
     zones.each do |zone|
       similar_array_of_zones = []
       next if accounted_for.include?(zone.name.to_s)
+
       similar_array_of_zones << zone
       accounted_for << zone.name.to_s
       zones.each do |zone_target|
@@ -1196,17 +1193,18 @@ class NECB2011
       array_of_array_of_zones << similar_array_of_zones
     end
     total_zones_output = 0
-    array_of_array_of_zones.each do |zones|
-      total_zones_output += zones.size
+    array_of_array_of_zones.each do |curr_zones|
+      total_zones_output += curr_zones.size
     end
-    #puts total_zones_output
-    #puts accounted_for.sort
-    #sanity check.
+    # puts total_zones_output
+    # puts accounted_for.sort
+    # sanity check.
     if total_zones_output != total_zones_input
-      #puts JSON.pretty_generate(array_of_array_of_zones)
-      #puts JSON.pretty_generate(accounted_for.sort)
-      raise("#{}")
+      # puts JSON.pretty_generate(array_of_array_of_zones)
+      # puts JSON.pretty_generate(accounted_for.sort)
+      raise('')
     end
+
     return array_of_array_of_zones
   end