openstudio-standards 0.8.3 → 0.8.5.rc1

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

@@ -69,11 +69,9 @@ class NECB2011
     # Remove any Thermal zones assigned before
     model.getThermalZones.each(&:remove)
     # create new thermal zones one to one with spaces.
-    model_create_thermal_zones(model)
+    model_create_thermal_zones(model, space_multiplier_map)
     # do a sizing run.
-    if model_run_sizing_run(model, "#{sizing_run_dir}/autozone") == false
-      raise('autorun sizing run failed!')
-    end
+    try_sizing_run(model: model, sizing_run_dir: sizing_run_dir, sizing_run_subdir: 'autozone')
 
     # collect sizing information on each space.
     store_space_sizing_loads(model)
@@ -94,11 +92,17 @@ class NECB2011
   # 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:,
+                    hvac_system_primary:,
+                    hvac_system_dwelling_units:,
+                    hvac_system_washrooms:,
+                    hvac_system_corridor:,
+                    hvac_system_storage:,
                     sizing_run_dir:,
                     shw_scale:,
                     baseline_system_zones_map_option:)
     raise('validation of model failed.') unless validate_initial_model(model)
-
+    # Store fuel type information in case hvac_system_primary requires a reset
+    init_fuel_type = get_fuel_type_information()
     # 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)
@@ -108,23 +112,33 @@ class NECB2011
     end
 
     # do a sizing run.
-    if model_run_sizing_run(model, "#{sizing_run_dir}/autozone_systems") == false
-      raise('autorun sizing run failed!')
-    end
+    try_sizing_run(model: model, sizing_run_dir: sizing_run_dir, sizing_run_subdir: 'autozone_systems')
 
     # collect sizing information on each space.
     store_space_sizing_loads(model)
 
-
     # remove idealair from zones if any.
     model.getZoneHVACIdealLoadsAirSystems.each(&:remove)
-    @hw_loop = create_hw_loop_if_required(self.fuel_type_set.baseboard_type,
-                                          self.fuel_type_set.boiler_fueltype,
-                                          self.fuel_type_set.backup_boiler_fueltype,
-                                          self.fuel_type_set.mau_heating_coil_type,
-                                          model)
+    @hw_loop = create_hw_loop_if_required(baseboard_type: self.fuel_type_set.baseboard_type,
+                                          boiler_fueltype: self.fuel_type_set.boiler_fueltype,
+                                          backup_boiler_fueltype: self.fuel_type_set.backup_boiler_fueltype,
+                                          mau_heating_coil_type: self.fuel_type_set.mau_heating_coil_type,
+                                          heating_coil_type_sys2: self.fuel_type_set.heating_coil_type_sys2,
+                                          heating_coil_type_sys3: self.fuel_type_set.heating_coil_type_sys3,
+                                          heating_coil_type_sys4: self.fuel_type_set.heating_coil_type_sys4,
+                                          heating_coil_type_sys6: self.fuel_type_set.heating_coil_type_sys6,
+                                          model: model,
+                                          hvac_system_primary: hvac_system_primary,
+                                          hvac_system_dwelling_units: hvac_system_dwelling_units,
+                                          hvac_system_washrooms: hvac_system_washrooms,
+                                          hvac_system_corridor: hvac_system_corridor,
+                                          hvac_system_storage: hvac_system_storage
+                                          )
+    # Determine if dwelling units, wet spaces, storage spaces, and wild spaces should have their own space or be part of common spaces
+    common_system_spaces = spaces_to_add_to_common_system(model: model, hvac_system_dwelling_units: hvac_system_dwelling_units, hvac_system_washrooms: hvac_system_washrooms, hvac_system_corridor: hvac_system_corridor, hvac_system_storage: hvac_system_storage)
     # Rule that all dwelling units have their own zone and system.
     auto_system_dwelling_units(model: model,
+                               hvac_system_dwelling_units: hvac_system_dwelling_units,
                                necb_reference_hp: self.fuel_type_set.necb_reference_hp,
                                necb_reference_hp_supp_fuel: self.fuel_type_set.necb_reference_hp_supp_fuel,
                                baseboard_type: self.fuel_type_set.baseboard_type,
@@ -138,45 +152,56 @@ class NECB2011
                                mau_cooling_type: self.fuel_type_set.mau_cooling_type,
                                mau_heating_coil_type: self.fuel_type_set.mau_heating_coil_type,
                                mau_type: self.fuel_type_set.mau_type,
-                               baseline_system_zones_map_option: baseline_system_zones_map_option)
+                               baseline_system_zones_map_option: baseline_system_zones_map_option,
+                               init_fuel_type: init_fuel_type)
 
     # 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: self.fuel_type_set.baseboard_type,
+    auto_system_wet_spaces(hvac_system_washrooms: hvac_system_washrooms,
+                           baseboard_type: self.fuel_type_set.baseboard_type,
                            necb_reference_hp: self.fuel_type_set.necb_reference_hp,
                            necb_reference_hp_supp_fuel: self.fuel_type_set.necb_reference_hp_supp_fuel,
                            boiler_fueltype: self.fuel_type_set.boiler_fueltype,
                            heating_coil_type_sys4: self.fuel_type_set.heating_coil_type_sys4,
-                           model: model)
+                           model: model,
+                           init_fuel_type: init_fuel_type)
 
     # 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: self.fuel_type_set.baseboard_type,
+    auto_system_storage_spaces(hvac_system_storage: hvac_system_storage,
+                               baseboard_type: self.fuel_type_set.baseboard_type,
                                necb_reference_hp: self.fuel_type_set.necb_reference_hp,
                                necb_reference_hp_supp_fuel: self.fuel_type_set.necb_reference_hp_supp_fuel,
                                boiler_fueltype: self.fuel_type_set.boiler_fueltype,
                                heating_coil_type_sys4: self.fuel_type_set.heating_coil_type_sys4,
-                               model: model)
+                               model: model,
+                               init_fuel_type: init_fuel_type)
 
     # Assign the wild spaces to a single system 4 system with a control zone with the largest load.
-    auto_system_wild_spaces(baseboard_type: self.fuel_type_set.baseboard_type,
+    auto_system_wild_spaces(hvac_system_corridor: hvac_system_corridor,
+                            baseboard_type: self.fuel_type_set.baseboard_type,
                             necb_reference_hp: self.fuel_type_set.necb_reference_hp,
                             necb_reference_hp_supp_fuel: self.fuel_type_set.necb_reference_hp_supp_fuel,
                             heating_coil_type_sys4: self.fuel_type_set.heating_coil_type_sys4,
-                            model: model)
+                            model: model,
+                            init_fuel_type: init_fuel_type)
     # do the regular assignment for the rest and group where possible.
     auto_system_all_other_spaces(model: model,
+                                 hvac_system_primary: hvac_system_primary,
                                  necb_reference_hp: self.fuel_type_set.necb_reference_hp,
                                  necb_reference_hp_supp_fuel: self.fuel_type_set.necb_reference_hp_supp_fuel,
                                  baseboard_type: self.fuel_type_set.baseboard_type,
                                  boiler_fueltype: self.fuel_type_set.boiler_fueltype,
                                  chiller_type: self.fuel_type_set.chiller_type,
                                  fan_type: self.fuel_type_set.fan_type,
+                                 heating_coil_type_sys2: self.fuel_type_set.heating_coil_type_sys2,
                                  heating_coil_type_sys3: self.fuel_type_set.heating_coil_type_sys3,
                                  heating_coil_type_sys4: self.fuel_type_set.heating_coil_type_sys4,
                                  hw_loop: @hw_loop,
                                  heating_coil_type_sys6: self.fuel_type_set.heating_coil_type_sys6,
                                  mau_cooling_type: self.fuel_type_set.mau_cooling_type,
                                  mau_heating_coil_type: self.fuel_type_set.mau_heating_coil_type,
-                                 mau_type: self.fuel_type_set.mau_type
+                                 mau_type: self.fuel_type_set.mau_type,
+                                 common_system_spaces: common_system_spaces,
+                                 init_fuel_type: init_fuel_type
     )
     model_add_swh(model: model,
                   shw_scale: shw_scale)
@@ -207,7 +232,7 @@ 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
+      try_sizing_run(model: space.model, sizing_run_dir: "#{Dir.pwd}", sizing_run_subdir: 'autozone')
 
       # collect sizing information on each space.
       store_space_sizing_loads(space.model)
@@ -219,7 +244,7 @@ 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
+      try_sizing_run(model: space.model, sizing_run_dir: "#{Dir.pwd}", sizing_run_subdir: 'autozone')
 
       # collect sizing information on each space.
       store_space_sizing_loads(space.model)
@@ -317,15 +342,6 @@ class NECB2011
         ideal_loads = OpenStudio::Model::ZoneHVACIdealLoadsAirSystem.new(model)
         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|
-        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: space_target, schedule: dominant_schedule, lights_type: lights_type, lights_scale: lights_scale)
-            space_target.setThermalZone(zone)
-          end
-        end
-      end
       wet_zone_array << zone
     end
     return wet_zone_array
@@ -366,14 +382,6 @@ class NECB2011
         ideal_loads = OpenStudio::Model::ZoneHVACIdealLoadsAirSystem.new(model)
         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 { |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) && space.buildingStory.get == space_target.buildingStory.get # added since chris needs zones to not span floors for costing.
-            space_target.setThermalZone(zone)
-          end
-        end
-      end
       other_tz_array << zone
     end
     return other_tz_array
@@ -421,15 +429,6 @@ class NECB2011
         ideal_loads = OpenStudio::Model::ZoneHVACIdealLoadsAirSystem.new(model)
         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 { |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) &&
-             (space.buildingStory.get == space_target.buildingStory.get) # added since chris needs zones to not span floors for costing.
-            space_target.setThermalZone(zone)
-          end
-        end
-      end
       other_tz_array << zone
     end
     return other_tz_array
@@ -504,16 +503,6 @@ class NECB2011
         ideal_loads = OpenStudio::Model::ZoneHVACIdealLoadsAirSystem.new(model)
         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) && !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: space_target, schedule: dominant_floor_schedule, lights_type: @lights_type, lights_scale: @lights_scale)
-            space_target.setThermalZone(zone)
-          end
-        end
-      end
       wild_zone_array << zone
     end
     return wild_zone_array
@@ -636,6 +625,8 @@ class NECB2011
 
   # 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)
+    # Avoid including washrooms and locker rooms as both wildcard and wet spaces
+    return nil if space.spaceType.get.standardsSpaceType.get.include?('Locker room') || space.spaceType.get.standardsSpaceType.get.include?('Washroom')
     space_type_table = @standards_data['space_types']
     space_type_data = model_find_object(space_type_table,
                                         'template' => self.class.name,
@@ -748,7 +739,8 @@ class NECB2011
         new_spacetype.setStandardsSpaceType(new_spacetype_name)
         new_spacetype.setName("#{space.spaceType.get.standardsBuildingType.get} #{new_spacetype_name}")
         space_type_apply_internal_loads(space_type: new_spacetype, lights_type: lights_type, lights_scale: lights_scale)
-        space_type_apply_internal_load_schedules(new_spacetype, true, true, true, true, true, true)
+        space_type_apply_internal_load_schedules(new_spacetype)
+        space_type_apply_thermostat_schedules(new_spacetype)
       end
       space.setSpaceType(new_spacetype)
       # sanity check.
@@ -822,35 +814,92 @@ class NECB2011
   ################################################# NECB Systems
 
   # 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, backup_boiler_fueltype, mau_heating_coil_type, model)
+  def create_hw_loop_if_required(baseboard_type:, boiler_fueltype:, backup_boiler_fueltype:, mau_heating_coil_type:, model:, hvac_system_primary: nil, hvac_system_dwelling_units: nil, hvac_system_washrooms: nil, hvac_system_corridor: nil, hvac_system_storage: nil, heating_coil_type_sys2:, heating_coil_type_sys3:, heating_coil_type_sys4:, heating_coil_type_sys6:)
     # 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.
     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') || (baseboard_type == 'Hot Water')
-          hw_loop_needed = true
-        end
-      when '3', '4'
-        if (mau_heating_coil_type == 'Hot Water') || (baseboard_type == 'Hot Water')
-          hw_loop_needed = true if baseboard_type == 'Hot Water'
-        end
+
+    # Create a boiler if the air loop will use fancoils for heating
+    hw_loop_needed = true if self.fuel_type_set.force_airloop_hot_water
+
+    # Create a boiler if one is forced by the user
+    hw_loop_needed = true if self.fuel_type_set.force_boiler
+
+    # Find Dwelling Units and determine if a HW loop is needed
+    dwelling_units = model.getSpaces.select { |space| is_a_necb_dwelling_unit?(space) }
+    unless dwelling_units.empty?
+      # If no dwelling unit hvac system is defined then check if a HW loop is needed based on the system type.
+      if hvac_system_dwelling_units.nil? || hvac_system_dwelling_units.to_s.downcase == 'necb_default'
+        hw_loop_needed = hw_loop_required_from_spaces(spaces: dwelling_units, mau_heating_coil_type: mau_heating_coil_type, baseboard_type: baseboard_type, heating_coil_type_sys2: heating_coil_type_sys2, heating_coil_type_sys3: heating_coil_type_sys3, heating_coil_type_sys4: heating_coil_type_sys4, heating_coil_type_sys6: heating_coil_type_sys6) unless hw_loop_needed
+      else
+        # If a dwelling unit hvac system is defined then find it in the hvac_types array and check if it requires a HW loop based on the 'needs_boiler' item.
+        hvac_system_data = self.standards_data['hvac_types'].find { |system| system['description'] == hvac_system_dwelling_units }
+        hw_loop_needed = true if hvac_system_data["needs_boiler"].to_bool unless hw_loop_needed
+        hw_loop_needed = boiler_required_from_heating_coils(sys_type: hvac_system_data["system"].to_s, mau_heating_coil_type: mau_heating_coil_type, heating_coil_type_sys2: heating_coil_type_sys2, heating_coil_type_sys3: heating_coil_type_sys3, heating_coil_type_sys4: heating_coil_type_sys4, heating_coil_type_sys6: heating_coil_type_sys6) unless hw_loop_needed
       end
-      if hw_loop_needed
-        # just need one true condition to need a boiler.
-        break
+    end
+
+    # Find washrooms and determine if a HW loop is needed
+    washroom_spaces = model.getSpaces.select { |space| is_an_necb_wet_space?(space) }
+    unless washroom_spaces.empty?
+      # If no washroom hvac system is defined then check if a HW loop is needed based on the system type.
+      if hvac_system_washrooms.nil? || hvac_system_washrooms.to_s.downcase == 'necb_default'
+        hw_loop_needed = hw_loop_required_from_spaces(spaces: washroom_spaces, mau_heating_coil_type: mau_heating_coil_type, baseboard_type: baseboard_type, heating_coil_type_sys2: heating_coil_type_sys2, heating_coil_type_sys3: heating_coil_type_sys3, heating_coil_type_sys4: heating_coil_type_sys4, heating_coil_type_sys6: heating_coil_type_sys6) unless hw_loop_needed
+      else
+        # If a washroom hvac system is defined then find it in the hvac_types array and check if it requires a HW loop based on the 'needs_boiler' item.
+        hvac_system_data = self.standards_data['hvac_types'].find { |system| system['description'] == hvac_system_washrooms }
+        hw_loop_needed = true if hvac_system_data["needs_boiler"].to_bool unless hw_loop_needed
+        hw_loop_needed = boiler_required_from_heating_coils(sys_type: hvac_system_data["system"].to_s, mau_heating_coil_type: mau_heating_coil_type, heating_coil_type_sys2: heating_coil_type_sys2, heating_coil_type_sys3: heating_coil_type_sys3, heating_coil_type_sys4: heating_coil_type_sys4, heating_coil_type_sys6: heating_coil_type_sys6) unless hw_loop_needed
       end
-      # each
     end
+
+    # Find corridors and determine if a HW loop is needed
+    corridor_spaces = model.getSpaces.select { |space| is_an_necb_wildcard_space?(space) }
+    unless corridor_spaces.empty?
+      # If no corridor hvac system is defined then check if a HW loop is needed based on the system type.
+      if hvac_system_corridor.nil? || hvac_system_corridor.to_s.downcase == 'necb_default'
+        hw_loop_needed = hw_loop_required_from_spaces(spaces: corridor_spaces, mau_heating_coil_type: mau_heating_coil_type, baseboard_type: baseboard_type, heating_coil_type_sys2: heating_coil_type_sys2, heating_coil_type_sys3: heating_coil_type_sys3, heating_coil_type_sys4: heating_coil_type_sys4, heating_coil_type_sys6: heating_coil_type_sys6) unless hw_loop_needed
+      else
+        # If a corridor hvac system is defined then find it in the hvac_types array and check if it requires a HW loop based on the 'needs_boiler' item.
+        hvac_system_data = self.standards_data['hvac_types'].find { |system| system['description'] == hvac_system_corridor }
+        hw_loop_needed = true if hvac_system_data["needs_boiler"].to_bool unless hw_loop_needed
+        hw_loop_needed = boiler_required_from_heating_coils(sys_type: hvac_system_data["system"].to_s, mau_heating_coil_type: mau_heating_coil_type, heating_coil_type_sys2: heating_coil_type_sys2, heating_coil_type_sys3: heating_coil_type_sys3, heating_coil_type_sys4: heating_coil_type_sys4, heating_coil_type_sys6: heating_coil_type_sys6) unless hw_loop_needed
+      end
+    end
+
+    # Find storage spaces and determine if a HW loop is needed
+    storage_spaces = model.getSpaces.select { |space| is_an_necb_storage_space?(space) }
+    unless storage_spaces.empty?
+      # If no storage space hvac system is defined then check if a HW loop is needed based on the system type.
+      if hvac_system_storage.nil? || hvac_system_storage.to_s.downcase == 'necb_default'
+        hw_loop_needed = hw_loop_required_from_spaces(spaces: storage_spaces, mau_heating_coil_type: mau_heating_coil_type, baseboard_type: baseboard_type, heating_coil_type_sys2: heating_coil_type_sys2, heating_coil_type_sys3: heating_coil_type_sys3, heating_coil_type_sys4: heating_coil_type_sys4, heating_coil_type_sys6: heating_coil_type_sys6) unless hw_loop_needed
+      else
+        # If a storage space hvac system is defined then find it in the hvac_types array and check if it requires a HW loop based on the 'needs_boiler' item.
+        hvac_system_data = self.standards_data['hvac_types'].find { |system| system['description'] == hvac_system_storage }
+        hw_loop_needed = true if hvac_system_data["needs_boiler"].to_bool unless hw_loop_needed
+        hw_loop_needed = boiler_required_from_heating_coils(sys_type: hvac_system_data["system"].to_s, mau_heating_coil_type: mau_heating_coil_type, heating_coil_type_sys2: heating_coil_type_sys2, heating_coil_type_sys3: heating_coil_type_sys3, heating_coil_type_sys4: heating_coil_type_sys4, heating_coil_type_sys6: heating_coil_type_sys6) unless hw_loop_needed
+      end
+    end
+
+    # Find if a HW loop is needed for the remaining spaces
+    other_spaces = model.getSpaces.select do |space|
+      !is_an_necb_wet_space?(space) &&
+      !is_a_necb_dwelling_unit?(space) &&
+      !is_an_necb_wildcard_space?(space) &&
+      !is_an_necb_storage_space?(space)
+    end
+    unless other_spaces.empty?
+      # If a hvac system is defined for the remaining spaces then check if a HW loop is needed based on the system type
+      if hvac_system_primary.nil? || hvac_system_primary.to_s.downcase == 'necb_default'
+        hw_loop_needed = hw_loop_required_from_spaces(spaces: other_spaces, mau_heating_coil_type: mau_heating_coil_type, baseboard_type: baseboard_type, heating_coil_type_sys2: heating_coil_type_sys2, heating_coil_type_sys3: heating_coil_type_sys3, heating_coil_type_sys4: heating_coil_type_sys4, heating_coil_type_sys6: heating_coil_type_sys6) unless hw_loop_needed
+      else
+        # If an hvac system is defined for the remaining spaces then find it in the hvac_types array and check if it requires a HW loop based on the 'needs_boiler' item.
+        hvac_system_data = self.standards_data['hvac_types'].find { |system| system['description'] == hvac_system_primary }
+        hw_loop_needed = true if hvac_system_data["needs_boiler"].to_bool unless hw_loop_needed
+        hw_loop_needed = boiler_required_from_heating_coils(sys_type: hvac_system_data["system"].to_s, mau_heating_coil_type: mau_heating_coil_type, heating_coil_type_sys2: heating_coil_type_sys2, heating_coil_type_sys3: heating_coil_type_sys3, heating_coil_type_sys4: heating_coil_type_sys4, heating_coil_type_sys6: heating_coil_type_sys6) unless hw_loop_needed
+      end
+    end
+
     # create hw_loop as needed.. Assuming one loop per model.
     if hw_loop_needed
       @hw_loop = OpenStudio::Model::PlantLoop.new(model)
@@ -863,14 +912,16 @@ class NECB2011
   # Default method to create a necb system and assign array of zones to be supported by it. It will try to bring zones with
   # similar loads on the same airloops and set control zones where possible for single zone systems and will create monolithic
   # system 6 multizones where possible.
-  def create_necb_system(baseboard_type:,
+  def create_necb_system(hvac_system_primary: 'NECB_Default',
+                         baseboard_type:,
                          boiler_fueltype:,
                          chiller_type:,
                          fan_type:,
+                         hw_loop:,
+                         heating_coil_type_sys2:,
                          heating_coil_type_sys3:,
                          heating_coil_type_sys4:,
                          heating_coil_type_sys6:,
-                         hw_loop:,
                          mau_cooling_type:,
                          mau_heating_coil_type:,
                          mau_type:,
@@ -880,9 +931,28 @@ class NECB2011
                          necb_reference_hp_supp_fuel:'DefaultFuel')
     # The goal is to minimize the number of system when possible.
     system_zones_hash = {}
+    system_selection = nil
     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
+      # Define the system type based on the space type data or use the custom one (hvac_system_primary) if is defined.
+      if hvac_system_primary.nil? || hvac_system_primary.to_s.downcase == 'necb_default'
+        system_selection = get_necb_thermal_zone_system_selection(zone)
+      else
+        zone_space_count = 0
+        null_space_count = 0
+        zone.spaces.sort.each do |space|
+          zone_space_count += 1
+          null_space_count += 1 if space.spaceType.get.name.to_s.downcase.include?("undefined")
+        end
+        system_data = @standards_data['hvac_types']
+        selected_systems = system_data.select { |ind_system| ind_system["description"].to_s.downcase == hvac_system_primary.to_s.downcase }
+        raise ("Could not find the provided HVAC system name in the HVAC system library. Please check the spelling of HVAC system name you defined. Provided HVAC system name: #{hvac_system_primary}") if selected_systems.empty?
+        raise ("More than one HVAC systems match the provided HVAC system name.  Please check the spelling of the provided HVAC system name. Provided HVAC system name: #{hvac_system_primary}") if selected_systems.size > 1
+        system_selection = selected_systems[0]["system"][4].to_i
+        # Do not inculde zones exclusively containing undefined spaces
+        system_selection = nil if null_space_count > 0 && zone_space_count == null_space_count
+      end
+      system_zones_hash[system_selection] = [] if system_zones_hash[system_selection].nil?
+      system_zones_hash[system_selection] << zone
     end
     # puts JSON.pretty_generate(system_zones_hash)
     # go through each system and zones pairs to
@@ -892,86 +962,141 @@ class NECB2011
         # Do nothing no system assigned to zone. Used for Unconditioned spaces
       when 1
         group_similar_zones_together(sys_zones).each do |curr_zones|
-          mau_air_loop = add_sys1_unitary_ac_baseboard_heating(model: model,
-                                                               necb_reference_hp: necb_reference_hp,
-                                                               necb_reference_hp_supp_fuel: necb_reference_hp_supp_fuel,
-                                                               zones: curr_zones,
-                                                               mau_type: mau_type,
-                                                               mau_heating_coil_type: mau_heating_coil_type,
-                                                               baseboard_type: baseboard_type,
-                                                               hw_loop: @hw_loop,
-                                                               multispeed: false)
+          if hvac_system_primary == 'NECB_Default' or hvac_system_primary.nil?
+            mau_air_loop = add_sys1_unitary_ac_baseboard_heating(model: model,
+                                                                necb_reference_hp: necb_reference_hp,
+                                                                necb_reference_hp_supp_fuel: necb_reference_hp_supp_fuel,
+                                                                zones: curr_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_hvac_by_name( model: model,
+                                 hvac_system_name: hvac_system_primary,
+                                 hw_loop: @hw_loop,
+                                 zones: curr_zones
+            )
+          end
         end
+
       when 2
         group_similar_zones_together(sys_zones).each do |curr_zones|
-          add_sys2_FPFC_sys5_TPFC(model: model,
-                                  zones: curr_zones,
-                                  chiller_type: chiller_type,
-                                  mau_cooling_type: mau_cooling_type,
-                                  fan_coil_type: 'FPFC',
-                                  hw_loop: @hw_loop)
+          if hvac_system_primary == 'NECB_Default' or hvac_system_primary.nil?
+            add_sys2_FPFC_sys5_TPFC(model: model,
+                                    zones: curr_zones,
+                                    chiller_type: chiller_type,
+                                    mau_cooling_type: mau_cooling_type,
+                                    fan_coil_type: 'FPFC',
+                                    hw_loop: @hw_loop)
+          else
+            create_hvac_by_name( model: model,
+                                 hvac_system_name: hvac_system_primary,
+                                 hw_loop: @hw_loop,
+                                 zones: curr_zones
+            )
+          end
         end
       when 3
         group_similar_zones_together(sys_zones).each do |curr_zones|
-          add_sys3and8_single_zone_packaged_rooftop_unit_with_baseboard_heating(model: model,
-                                                                                necb_reference_hp: necb_reference_hp,
-                                                                                necb_reference_hp_supp_fuel: necb_reference_hp_supp_fuel,
-                                                                                zones: curr_zones,
-                                                                                heating_coil_type: heating_coil_type_sys3,
-                                                                                baseboard_type: baseboard_type,
-                                                                                hw_loop: @hw_loop,
-                                                                                multispeed: false)
+          if hvac_system_primary == 'NECB_Default' or hvac_system_primary.nil?
+            add_sys3and8_single_zone_packaged_rooftop_unit_with_baseboard_heating(model: model,
+                                                                                  necb_reference_hp: necb_reference_hp,
+                                                                                  necb_reference_hp_supp_fuel: necb_reference_hp_supp_fuel,
+                                                                                  zones: curr_zones,
+                                                                                  heating_coil_type: heating_coil_type_sys3,
+                                                                                  baseboard_type: baseboard_type,
+                                                                                  hw_loop: @hw_loop,
+                                                                                  multispeed: false)
+          else
+            create_hvac_by_name( model: model,
+                                 hvac_system_name: hvac_system_primary,
+                                 hw_loop: @hw_loop,
+                                 zones: curr_zones
+            )
+          end
         end
+
       when 4
         group_similar_zones_together(sys_zones).each do |curr_zones|
-          add_sys4_single_zone_make_up_air_unit_with_baseboard_heating(model: model,
-                                                                       necb_reference_hp: necb_reference_hp,
-                                                                       necb_reference_hp_supp_fuel: necb_reference_hp_supp_fuel,
-                                                                       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)
+          if hvac_system_primary == 'NECB_Default' or hvac_system_primary.nil?
+            add_sys4_single_zone_make_up_air_unit_with_baseboard_heating(model: model,
+                                                                        necb_reference_hp: necb_reference_hp,
+                                                                        necb_reference_hp_supp_fuel: necb_reference_hp_supp_fuel,
+                                                                        zones: curr_zones,
+                                                                        heating_coil_type: heating_coil_type_sys4,
+                                                                        baseboard_type: baseboard_type,
+                                                                        hw_loop: @hw_loop)
+          else
+            create_hvac_by_name( model: model,
+                                 hvac_system_name: hvac_system_primary,
+                                 hw_loop: @hw_loop,
+                                 zones: curr_zones
+            )
+          end
         end
+
       when 5
         group_similar_zones_together(sys_zones).each do |curr_zones|
-          add_sys2_FPFC_sys5_TPFC(model: model,
-                                  zones: curr_zones,
-                                  chiller_type: chiller_type,
-                                  mau_cooling_type: mau_cooling_type,
-                                  fan_coil_type: 'TPFC',
-                                  hw_loop: @hw_loop)
+          if hvac_system_primary == 'NECB_Default' or hvac_system_primary.nil?
+            add_sys2_FPFC_sys5_TPFC(model: model,
+                                    zones: curr_zones,
+                                    chiller_type: chiller_type,
+                                    mau_cooling_type: mau_cooling_type,
+                                    fan_coil_type: 'TPFC',
+                                    hw_loop: @hw_loop)
+          else
+            create_hvac_by_name( model: model,
+                                 hvac_system_name: hvac_system_primary,
+                                 hw_loop: @hw_loop,
+                                 zones: curr_zones
+            )
+          end
         end
+
       when 6
-        if necb_reference_hp
-          add_sys6_multi_zone_reference_hp_with_baseboard_heating(model: model,
-                                                                  zones: sys_zones,
-                                                                  heating_coil_type: heating_coil_type_sys6,
-                                                                  baseboard_type: baseboard_type,
-                                                                  hw_loop:@hw_loop,
-                                                                  necb_reference_hp_supp_fuel: necb_reference_hp_supp_fuel)
-        else
-          add_sys6_multi_zone_built_up_system_with_baseboard_heating(model: model,
+        if hvac_system_primary == 'NECB_Default' or hvac_system_primary.nil?
+          if necb_reference_hp
+            add_sys6_multi_zone_reference_hp_with_baseboard_heating(model: model,
                                                                     zones: sys_zones,
                                                                     heating_coil_type: heating_coil_type_sys6,
                                                                     baseboard_type: baseboard_type,
-                                                                    chiller_type: chiller_type,
-                                                                    fan_type: fan_type,
-                                                                    hw_loop: @hw_loop)
+                                                                    hw_loop:@hw_loop,
+                                                                    necb_reference_hp_supp_fuel: necb_reference_hp_supp_fuel)
+          else
+            add_sys6_multi_zone_built_up_system_with_baseboard_heating(model: model,
+                                                                      zones: sys_zones,
+                                                                      heating_coil_type: heating_coil_type_sys6,
+                                                                      baseboard_type: baseboard_type,
+                                                                      chiller_type: chiller_type,
+                                                                      fan_type: fan_type,
+                                                                      hw_loop: @hw_loop)
+          end
+        else
+          create_hvac_by_name( model: model,
+                               hvac_system_name: hvac_system_primary,
+                               hw_loop: @hw_loop,
+                               zones: sys_zones
+          )
         end
+
       when 7
         group_similar_zones_together(sys_zones).each do |curr_zones|
-          add_sys2_FPFC_sys5_TPFC(model: model,
-                                  zones: curr_zones,
-                                  chiller_type: chiller_type,
-                                  fan_coil_type: 'FPFC',
-                                  mau_cooling_type: mau_cooling_type,
-                                  hw_loop: @hw_loop)
+          if hvac_system_primary == 'NECB_Default' or hvac_system_primary.nil?
+            add_sys2_FPFC_sys5_TPFC(model: model,
+                                    zones: curr_zones,
+                                    chiller_type: chiller_type,
+                                    fan_coil_type: 'FPFC',
+                                    mau_cooling_type: mau_cooling_type,
+                                    hw_loop: @hw_loop)
+          else
+            create_hvac_by_name( model: model,
+                                 hvac_system_name: hvac_system_primary,
+                                 hw_loop: @hw_loop,
+                                 zones: curr_zones
+            )
+          end
         end
       end
     end
@@ -979,11 +1104,13 @@ class NECB2011
 
   # This method will deal with all non wet, non-wild, and non-dwelling units thermal zones.
   def auto_system_all_other_spaces(baseboard_type:,
-                                   necb_reference_hp:false,
-                                   necb_reference_hp_supp_fuel:'DefaultFuel',
+                                   hvac_system_primary:,
+                                   necb_reference_hp: false,
+                                   necb_reference_hp_supp_fuel: 'DefaultFuel',
                                    boiler_fueltype:,
                                    chiller_type:,
                                    fan_type:,
+                                   heating_coil_type_sys2:,
                                    heating_coil_type_sys3:,
                                    heating_coil_type_sys4:,
                                    heating_coil_type_sys6:,
@@ -991,24 +1118,43 @@ class NECB2011
                                    mau_cooling_type:,
                                    mau_heating_coil_type:,
                                    mau_type:,
-                                   model:)
-
+                                   model:,
+                                   common_system_spaces: [],
+                                   init_fuel_type:)
+    # Reset fuel type set to those defined by the user
+    fuel_type_set.reset_default_fuel_info(init_fuel_type: init_fuel_type)
+    # Set fuel type info based on hvac_system_primary (if set)
+    unless hvac_system_primary.nil? || hvac_system_primary.to_s.downcase == 'necb_default'
+      fuel_type_set.set_fuel_to_hvac_system_primary(hvac_system_primary: hvac_system_primary, standards_data: @standards_data)
+      mau_type = fuel_type_set.mau_type unless fuel_type_set.mau_type.nil?
+      mau_heating_coil_type = fuel_type_set.mau_heating_coil_type unless fuel_type_set.mau_heating_coil_type.nil? || fuel_type_set.force_airloop_hot_water
+      necb_reference_hp = fuel_type_set.necb_reference_hp unless fuel_type_set.necb_reference_hp.nil?
+      necb_reference_hp_supp_fuel = fuel_type_set.necb_reference_hp_supp_fuel unless fuel_type_set.necb_reference_hp_supp_fuel.nil? || fuel_type_set.force_airloop_hot_water
+      heating_coil_type_sys4 = fuel_type_set.heating_coil_type_sys4 unless fuel_type_set.heating_coil_type_sys4.nil? || fuel_type_set.force_airloop_hot_water
+    end
     zones = []
     other_spaces = model.getSpaces.select do |space|
+      !is_an_necb_wet_space?(space) &&
       !is_a_necb_dwelling_unit?(space) &&
         !is_an_necb_wildcard_space?(space) &&
         !is_an_necb_storage_space?(space)
     end
+    # Add any dwelling units, washrooms, cooridors, or storage spaces to the list of other spaces if a non-default system type was assigned to them
+    unless common_system_spaces.empty? || common_system_spaces.nil?
+      other_spaces = other_spaces + common_system_spaces
+    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.
-    create_necb_system(baseboard_type: baseboard_type,
+    create_necb_system(hvac_system_primary: hvac_system_primary,
+                       baseboard_type: baseboard_type,
                        boiler_fueltype: boiler_fueltype,
                        chiller_type: chiller_type,
                        fan_type: fan_type,
+                       heating_coil_type_sys2: heating_coil_type_sys2,
                        heating_coil_type_sys3: heating_coil_type_sys3,
                        heating_coil_type_sys4: heating_coil_type_sys4,
                        heating_coil_type_sys6: heating_coil_type_sys6,
@@ -1020,12 +1166,16 @@ class NECB2011
                        zones: zones,
                        necb_reference_hp: necb_reference_hp,
                        necb_reference_hp_supp_fuel: necb_reference_hp_supp_fuel)
+    # Reset fuel type set back to those defined by the user
+    fuel_type_set.reset_default_fuel_info(init_fuel_type: init_fuel_type)
   end
 
   # This method will ensure that all dwelling units are assigned to a system 1 or 3.
   # There is an option to have a shared AHU or not.
 
-  def auto_system_dwelling_units(baseboard_type:,
+  def auto_system_dwelling_units(
+                                 hvac_system_dwelling_units:,
+                                 baseboard_type:,
                                  necb_reference_hp:false,
                                  necb_reference_hp_supp_fuel:'DefaultFuel',
                                  boiler_fueltype:,
@@ -1039,7 +1189,10 @@ class NECB2011
                                  mau_heating_coil_type:,
                                  mau_type:,
                                  model:,
-                                 baseline_system_zones_map_option:)
+                                 baseline_system_zones_map_option:,
+                                 init_fuel_type:)
+    # Reset fuel type set to those defined by the user
+    fuel_type_set.reset_default_fuel_info(init_fuel_type: init_fuel_type)
     system_zones_hash = {}
     # Determine if dwelling units have a shared AHU.  If user entered building stories > 4 then set to true.
     if baseline_system_zones_map_option == 'one_sys_per_dwelling_unit'
@@ -1054,75 +1207,100 @@ class NECB2011
     end
     zones.uniq!
 
-    # 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
+    if hvac_system_dwelling_units.to_s.downcase == 'necb_default' || hvac_system_dwelling_units.nil?
 
-    # go through each system and zones pairs to
-    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,
-                                                necb_reference_hp: necb_reference_hp,
-                                                necb_reference_hp_supp_fuel: necb_reference_hp_supp_fuel,
-                                                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.
-          sys_zones.each do |zone|
+      # 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 # zone
+
+      # go through each system and zones pairs to
+      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,
                                                   necb_reference_hp: necb_reference_hp,
                                                   necb_reference_hp_supp_fuel: necb_reference_hp_supp_fuel,
-                                                  zones: [zone],
+                                                  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)
-          end
-        end
-
-      when 3
-        if dwelling_shared_ahu
-          add_sys3and8_single_zone_packaged_rooftop_unit_with_baseboard_heating(model: model,
-                                                                                necb_reference_hp: necb_reference_hp,
-                                                                                necb_reference_hp_supp_fuel: necb_reference_hp_supp_fuel,
-                                                                                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.
-          sys_zones.each do |zone|
+          else
+            # Create a separate air loop for each unit.
+            sys_zones.each do |zone|
+              add_sys1_unitary_ac_baseboard_heating(model: model,
+                                                    necb_reference_hp: necb_reference_hp,
+                                                    necb_reference_hp_supp_fuel: necb_reference_hp_supp_fuel,
+                                                    zones: [zone],
+                                                    mau_type: mau_type,
+                                                    mau_heating_coil_type: mau_heating_coil_type,
+                                                    baseboard_type: baseboard_type,
+                                                    hw_loop: @hw_loop,
+                                                    multispeed: false)
+            end # if
+          end # when 1
+
+        when 3
+          if dwelling_shared_ahu
             add_sys3and8_single_zone_packaged_rooftop_unit_with_baseboard_heating(model: model,
                                                                                   necb_reference_hp: necb_reference_hp,
                                                                                   necb_reference_hp_supp_fuel: necb_reference_hp_supp_fuel,
-                                                                                  zones: [zone],
+                                                                                  zones: sys_zones,
                                                                                   heating_coil_type: heating_coil_type_sys3,
                                                                                   baseboard_type: baseboard_type,
                                                                                   hw_loop: @hw_loop,
                                                                                   multispeed: false)
-          end
-        end
-      end
-    end
+          else
+
+            # 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,
+                                                                                    necb_reference_hp: necb_reference_hp,
+                                                                                    necb_reference_hp_supp_fuel: necb_reference_hp_supp_fuel,
+                                                                                    zones: [zone],
+                                                                                    heating_coil_type: heating_coil_type_sys3,
+                                                                                    baseboard_type: baseboard_type,
+                                                                                    hw_loop: @hw_loop,
+                                                                                    multispeed: false)
+            end # end zone
+          end # end if
+        end # end when 3
+      end # Sys_zone loop
+#    else # New HVAC system
+#      system_zones_hash.each_pair do |system, sys_zones|
+#        if dwelling_shared_ahu
+#          create_hvac_by_name( model: model,
+#                                      hvac_system_name: hvac_system_dwelling_units,
+#                                      zones: sys_zones,
+#                                      hw_loop: @hw_loop) # Add this method to create the system.
+#        else
+#          # Create a separate air loop for each unit.
+#          sys_zones.each do |zone|
+#            create_hvac_by_name( model: model,
+#                                 hvac_system_name: hvac_system_dwelling_units,
+#                                 zones: [zone],
+#                                 hw_loop: @hw_loop) # Add this method to create the system.
+#          end # zone
+#        end # if
+#      end # Sys_zone loop
+    end # if new HVAC system
   end
 
   # All wet spaces will be on their own system 4 AHU.
-  def auto_system_wet_spaces(baseboard_type:,
+  def auto_system_wet_spaces(hvac_system_washrooms: 'NECB_Default',
+                             baseboard_type:,
                              necb_reference_hp:false,
                              necb_reference_hp_supp_fuel:'DefaultFuel',
                              boiler_fueltype:,
                              heating_coil_type_sys4:,
-                             model:)
+                             model:,
+                             init_fuel_type:)
+    # Reset fuel type set to those defined by the user
+    fuel_type_set.reset_default_fuel_info(init_fuel_type: init_fuel_type)
     # Determine what zones are wet zones.
     wet_tz = []
     wet_spaces = model.getSpaces.select { |space| is_an_necb_wet_space?(space) }
@@ -1130,29 +1308,33 @@ class NECB2011
     wet_tz.uniq!
     # 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,
-                                                                 necb_reference_hp: necb_reference_hp,
-                                                                 necb_reference_hp_supp_fuel: necb_reference_hp_supp_fuel,
-                                                                 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)
+    if hvac_system_washrooms.to_s.downcase == 'necb_default' || hvac_system_washrooms.nil?
+      add_sys4_single_zone_make_up_air_unit_with_baseboard_heating(model: model,
+                                                                  necb_reference_hp: necb_reference_hp,
+                                                                  necb_reference_hp_supp_fuel: necb_reference_hp_supp_fuel,
+                                                                  zones: wet_tz,
+                                                                  heating_coil_type: heating_coil_type_sys4,
+                                                                  baseboard_type: baseboard_type,
+                                                                  hw_loop: @hw_loop)
+    #else
+    #  create_hvac_by_name( model: model,
+    #                              hvac_system_name: hvac_system_washrooms,
+    #                              zones: wet_tz,
+    #                              hw_loop: @hw_loop) # Add this method to create the system.
+    end
   end
 
   # All wet spaces will be on their own system 4 AHU.
-  def auto_system_storage_spaces(baseboard_type:,
+  def auto_system_storage_spaces(hvac_system_storage: 'NECB_Default',
+                                 baseboard_type:,
                                  necb_reference_hp:false,
                                  necb_reference_hp_supp_fuel:'DefaultFuel',
                                  boiler_fueltype:,
                                  heating_coil_type_sys4:,
-                                 model:)
+                                 model:,
+                                 init_fuel_type:)
+    # Reset fuel type set to those defined by the user
+    fuel_type_set.reset_default_fuel_info(init_fuel_type: init_fuel_type)
     # Determine what zones are storage zones.
     tz = []
     storage_spaces = model.getSpaces.select { |space| is_an_necb_storage_space?(space) }
@@ -1160,29 +1342,34 @@ class NECB2011
     tz.uniq!
 
     return if tz.empty?
+    if hvac_system_storage.to_s.downcase == 'necb_default' || hvac_system_storage.nil?
+      # create a system 4 for the  zones.
+      add_sys4_single_zone_make_up_air_unit_with_baseboard_heating(model: model,
+                                                                  necb_reference_hp: necb_reference_hp,
+                                                                  necb_reference_hp_supp_fuel: necb_reference_hp_supp_fuel,
+                                                                  zones: tz,
+                                                                  heating_coil_type: heating_coil_type_sys4,
+                                                                  baseboard_type: baseboard_type,
+                                                                  hw_loop: @hw_loop)
+    #else
+    #  create_hvac_by_name(model: model,
+    #                      hvac_system_name: hvac_system_storage,
+    #                      zones: tz,
+    #                      hw_loop: @hw_loop) # Add this method to create the system.
+    end
 
-    # create a system 4 for the  zones.
-    add_sys4_single_zone_make_up_air_unit_with_baseboard_heating(model: model,
-                                                                 necb_reference_hp: necb_reference_hp,
-                                                                 necb_reference_hp_supp_fuel: necb_reference_hp_supp_fuel,
-                                                                 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:,
-                              necb_reference_hp:false,
-                              necb_reference_hp_supp_fuel:'Defaultfuel',
+  def auto_system_wild_spaces(hvac_system_corridor: 'NECB_Default',
+                              baseboard_type:,
+                              necb_reference_hp: false,
+                              necb_reference_hp_supp_fuel: 'Defaultfuel',
                               heating_coil_type_sys4:,
-                              model:)
+                              model:,
+                              init_fuel_type:)
+    # Reset fuel type set to those defined by the user
+    fuel_type_set.reset_default_fuel_info(init_fuel_type: init_fuel_type)
 
     zones = []
     wild_spaces = model.getSpaces.select { |space| !is_an_necb_wet_space?(space) && is_an_necb_wildcard_space?(space) }
@@ -1191,20 +1378,21 @@ class NECB2011
 
     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,
-                                                                 necb_reference_hp: necb_reference_hp,
-                                                                 necb_reference_hp_supp_fuel: necb_reference_hp_supp_fuel,
-                                                                 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)
+    if hvac_system_corridor.to_s.downcase == 'necb_default' || hvac_system_corridor.nil?
+      # create a system 4 for the wild zones.
+      add_sys4_single_zone_make_up_air_unit_with_baseboard_heating(model: model,
+                                                                  necb_reference_hp: necb_reference_hp,
+                                                                  necb_reference_hp_supp_fuel: necb_reference_hp_supp_fuel,
+                                                                  zones: zones,
+                                                                  heating_coil_type: heating_coil_type_sys4,
+                                                                  baseboard_type: baseboard_type,
+                                                                  hw_loop: @hw_loop)
+    #else
+    #  create_hvac_by_name( model: model,
+    #                              hvac_system_name: hvac_system_corridor,
+    #                              zones: zones,
+    #                              hw_loop: @hw_loop) # Add this method to create the system.
+    end
   end
 
   # This method will determine the control zone from the last sizing run space loads.
@@ -1265,4 +1453,204 @@ class NECB2011
     rendering_color.setRenderingBlueValue(random.rand(255))
     return rendering_color
   end
+
+  def create_hvac_by_name(model:, hvac_system_name:, zones:, hw_loop: nil)
+    # Get the HVAC system properties
+    # Get the HVAC system properties from  lib/openstudio-standards/standards/necb/NECB2011/data/systems.json from description field.
+    hvac_system_data = self.standards_data['hvac_types'].find { |system| system['description'] == hvac_system_name }
+    raise("Could not find hvac_system_data for #{hvac_system_name}") if hvac_system_data.nil?
+    necb_reference_hp_supp_fuel = hvac_system_data['necb_reference_hp_supp_fuel']
+    necb_reference_hp_supp_fuel = 'Hot Water' if self.fuel_type_set.force_airloop_hot_water
+    mau_heating_coil_type = hvac_system_data['mau_heating_type']
+    baseboard_type = hvac_system_data['baseboard_type']
+    baseboard_type = self.fuel_type_set.baseboard_type if self.fuel_type_set.force_boiler
+    heating_coil_type = hvac_system_data['heating_coil_type']
+
+    case hvac_system_data['system']
+    when 'sys_1'
+      mau_heating_coil_type = self.fuel_type_set.mau_heating_coil_type if self.fuel_type_set.force_airloop_hot_water && mau_heating_coil_type != 'DX'
+      add_sys1_unitary_ac_baseboard_heating_single_speed(
+            model: model,
+            necb_reference_hp: hvac_system_data['necb_reference_hp'],
+            necb_reference_hp_supp_fuel: necb_reference_hp_supp_fuel,
+            zones: zones,
+            mau_type: hvac_system_data['mau_type'],
+            mau_heating_coil_type: mau_heating_coil_type,
+            baseboard_type: baseboard_type,
+            hw_loop: hw_loop
+            )
+    when 'sys_2'
+      add_sys2_FPFC_sys5_TPFC( model: model,
+                                            zones:zones,
+                                            chiller_type: hvac_system_data['chiller_type'],
+                                            fan_coil_type: hvac_system_data['fan_coil_type'],
+                                            mau_cooling_type: hvac_system_data['mau_cooling_type'],
+                                            hw_loop: hw_loop)
+    when 'sys_3'
+      heating_coil_type = self.fuel_type_set.heating_coil_type_sys3 if self.fuel_type_set.force_airloop_hot_water && heating_coil_type != 'DX'
+      add_sys3and8_single_zone_packaged_rooftop_unit_with_baseboard_heating_single_speed(
+              model: model,
+              necb_reference_hp: hvac_system_data['necb_reference_hp'],
+              necb_reference_hp_supp_fuel: necb_reference_hp_supp_fuel,
+              zones: zones,
+              heating_coil_type: heating_coil_type,
+              baseboard_type: baseboard_type,
+              hw_loop: hw_loop,
+              new_auto_zoner: true)
+    when 'sys_4'
+      heating_coil_type = self.fuel_type_set.heating_coil_type_sys4 if self.fuel_type_set.force_airloop_hot_water && heating_coil_type != 'DX'
+      add_sys4_single_zone_make_up_air_unit_with_baseboard_heating(model: model,
+                                                                   necb_reference_hp: hvac_system_data['necb_reference_hp'],
+                                                                   necb_reference_hp_supp_fuel: necb_reference_hp_supp_fuel,
+                                                                   zones: zones,
+                                                                   heating_coil_type: heating_coil_type,
+                                                                   baseboard_type: baseboard_type,
+                                                                   hw_loop: hw_loop)
+    when 'sys_5'
+      add_sys2_FPFC_sys5_TPFC( model: model,
+                                                zones:zones,
+                                                chiller_type: hvac_system_data['chiller_type'],
+                                                fan_coil_type: hvac_system_data['fan_coil_type'],
+                                                mau_cooling_type: hvac_system_data['mau_cooling_type'],
+                                                hw_loop: hw_loop)
+    when 'sys_6'
+      heating_coil_type = self.fuel_type_set.heating_coil_type_sys6 if self.fuel_type_set.force_airloop_hot_water && heating_coil_type != 'DX'
+      if heating_coil_type == 'DX'
+        add_sys6_multi_zone_reference_hp_with_baseboard_heating(model: model,
+                                                              zones: zones,
+                                                              heating_coil_type: heating_coil_type,
+                                                              baseboard_type: baseboard_type,
+                                                              hw_loop: hw_loop,
+                                                              necb_reference_hp_supp_fuel: necb_reference_hp_supp_fuel)
+      else
+        add_sys6_multi_zone_built_up_system_with_baseboard_heating(
+          model:model,
+          zones:zones,
+          heating_coil_type: heating_coil_type,
+          baseboard_type: baseboard_type,
+          chiller_type: hvac_system_data['chiller_type'],
+          fan_type: hvac_system_data['fan_type'],
+          hw_loop: hw_loop
+          )
+      end
+    end
+
+  end
+
+  # Method will check if the spaces passed to it will require a hot water loop based on their associated system type.
+  def hw_loop_required_from_spaces(spaces:, mau_heating_coil_type:, baseboard_type:, heating_coil_type_sys2:, heating_coil_type_sys3:, heating_coil_type_sys4:, heating_coil_type_sys6:)
+    hw_loop_needed = false
+    systems_used = []
+
+    # Find the space type for each space and get the system type associated with each space type
+    spaces.sort.each do |space|
+      space_system = get_necb_spacetype_system_selection(space)
+      space_system = 4 if space_system.nil? && (is_an_necb_storage_space?(space) || is_an_necb_wet_space?(space) || is_an_necb_wildcard_space?(space))
+      systems_used << space_system
+      systems_used.uniq!
+    end
+
+    # See if we need to create a hot water loop based on fueltype and systems used.
+    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') || (baseboard_type == 'Hot Water') || (mau_heating_coil_type == 'HotWater') || baseboard_type == 'HotWater' || (heating_coil_type_sys6 == 'HotWater') || (heating_coil_type_sys6 == 'Hot Water')
+          hw_loop_needed = true
+        end
+      when '3', '4'
+        if (mau_heating_coil_type == 'Hot Water') || (baseboard_type == 'Hot Water') || (mau_heating_coil_type == 'HotWater') || baseboard_type == 'HotWater' || (heating_coil_type_sys4 == 'HotWater') || (heating_coil_type_sys4 == 'Hot Water') || (heating_coil_type_sys3 == 'HotWater') || (heating_coil_type_sys3 == 'Hot Water')
+          hw_loop_needed = true if baseboard_type == 'Hot Water'
+          hw_loop_needed = true if (mau_heating_coil_type == 'Hot Water') || (mau_heating_coil_type == 'HotWater') || (heating_coil_type_sys4 == 'HotWater') || (heating_coil_type_sys4 == 'Hot Water') || (heating_coil_type_sys3 == 'HotWater') || (heating_coil_type_sys3 == 'Hot Water')
+        end
+      end
+      if hw_loop_needed
+        # just need one true condition to need a boiler.
+        break
+      end
+      # each
+    end
+    return hw_loop_needed
+  end
+
+  # Method to determine if dwelling_units, washrooms, corridors, or storage spaces should be added to the common HVAC system.
+  def spaces_to_add_to_common_system(model:, hvac_system_dwelling_units: nil, hvac_system_washrooms: nil, hvac_system_corridor: nil, hvac_system_storage: nil)
+    common_spaces = []
+    # Find Dwelling Units and determine if they should be added
+    dwelling_units = model.getSpaces.select { |space| is_a_necb_dwelling_unit?(space) }
+    unless dwelling_units.empty? || hvac_system_dwelling_units.nil? || hvac_system_dwelling_units.to_s.downcase == 'necb_default'
+      # If a dwelling unit hvac system is defined and dwelling units are present then add them to them to the common_spaces
+      common_spaces = common_spaces + dwelling_units
+    end
+
+    # Find washrooms and determine if they should be added
+    washroom_spaces = model.getSpaces.select { |space| is_an_necb_wet_space?(space) }
+    unless washroom_spaces.empty? || hvac_system_washrooms.nil? || hvac_system_washrooms.to_s.downcase == 'necb_default'
+      # If a washroom hvac system is defined and washrooms/wet spaces are present then add them to the common_spaces
+      common_spaces = common_spaces + washroom_spaces
+    end
+
+    # Find corridors and determine if they should be added
+    corridor_spaces = model.getSpaces.select { |space| is_an_necb_wildcard_space?(space) }
+    unless corridor_spaces.empty? || hvac_system_corridor.nil? || hvac_system_corridor.to_s.downcase == 'necb_default'
+      # If a corridor hvac system is defined and corridors are present then add them to the common spaces
+      common_spaces = common_spaces + corridor_spaces
+    end
+
+    # Find storage spaces and determine if they should be added
+    storage_spaces = model.getSpaces.select { |space| is_an_necb_storage_space?(space) }
+    unless storage_spaces.empty? || hvac_system_storage.nil? || hvac_system_storage.to_s.downcase == 'necb_default'
+      # If a storage space hvac system is defined and storage spaces are present then add them to the common spaces
+      common_spaces = common_spaces + storage_spaces
+    end
+    return common_spaces
+  end
+
+  def get_fuel_type_information()
+    init_fuel_type = {
+      name: fuel_type_set.name,
+      boiler_fueltype: fuel_type_set.boiler_fueltype,
+      backup_boiler_fueltype: fuel_type_set.backup_boiler_fueltype,
+      primary_boiler_cap_frac: fuel_type_set.primary_boiler_cap_frac,
+      secondary_boiler_cap_frac: fuel_type_set.secondary_boiler_cap_frac,
+      baseboard_type: fuel_type_set.baseboard_type,
+      mau_type: fuel_type_set.mau_type,
+      mau_heating_coil_type: fuel_type_set.mau_heating_coil_type,
+      mau_cooling_type: fuel_type_set.mau_cooling_type,
+      chiller_type: fuel_type_set.chiller_type,
+      heating_coil_type_sys2: fuel_type_set.heating_coil_type_sys2,
+      heating_coil_type_sys3: fuel_type_set.heating_coil_type_sys3,
+      heating_coil_type_sys4: fuel_type_set.heating_coil_type_sys4,
+      heating_coil_type_sys6: fuel_type_set.heating_coil_type_sys6,
+      necb_reference_hp: fuel_type_set.necb_reference_hp,
+      necb_reference_hp_supp_fuel: fuel_type_set.necb_reference_hp_supp_fuel,
+      fan_type: fuel_type_set.fan_type,
+      ecm_fueltype: fuel_type_set.ecm_fueltype,
+      swh_fueltype: fuel_type_set.swh_fueltype,
+      force_boiler: fuel_type_set.force_boiler,
+      force_airloop_hot_water: fuel_type_set.force_airloop_hot_water
+    }
+    return init_fuel_type
+  end
+
+  def boiler_required_from_heating_coils(sys_type:, mau_heating_coil_type:, heating_coil_type_sys2:, heating_coil_type_sys3:, heating_coil_type_sys4:, heating_coil_type_sys6:)
+    requires_boiler = false
+    case sys_type.to_s
+    when 'sys_1'
+      requires_boiler = true if mau_heating_coil_type.to_s == "Hot Water" || mau_heating_coil_type.to_s == "HotWater"
+    when 'sys_2'
+      requires_boiler = true if heating_coil_type_sys2.to_s == "Hot Water" || heating_coil_type_sys2.to_s == "HotWater"
+    when 'sys_3'
+      requires_boiler = true if heating_coil_type_sys3.to_s == "Hot Water" || heating_coil_type_sys3.to_s == "HotWater"
+    when 'sys_4'
+      requires_boiler = true if heating_coil_type_sys4.to_s == "Hot Water" || heating_coil_type_sys4.to_s == "HotWater"
+    when 'sys_6'
+      requires_boiler = true if heating_coil_type_sys6.to_s == "Hot Water" || heating_coil_type_sys6.to_s == "HotWater"
+    else
+      requires_boiler = false
+    end
+    return requires_boiler
+  end
+
 end