openstudio-extension 0.2.0 → 0.2.5

data/lib/openstudio/extension/core/os_lib_model_generation.rb

@@ -35,7 +35,32 @@
 
 module OsLib_ModelGeneration
   # simple list of building types that are valid for get_space_types_from_building_type
-  def get_building_types
+  # for general public use use extended = false
+  def get_building_types(extended = false)
+
+    # get building_types
+    if extended
+      doe = get_doe_building_types(true)
+      deer = get_deer_building_types(true)
+    else
+      doe = get_doe_building_types
+      deer = get_deer_building_types
+    end
+
+    # combine building_types
+    array = OpenStudio::StringVector.new
+    temp_array = doe.to_a + deer.to_a
+    temp_array.each do |i|
+      array << i
+    end
+
+    return array
+  end
+
+  # get_doe_building_types
+  # for general public use use extended = false
+  def get_doe_building_types(extended = false)
+    # DOE Prototypes
     array = OpenStudio::StringVector.new
     array << 'SecondarySchool'
     array << 'PrimarySchool'
@@ -54,25 +79,215 @@ module OsLib_ModelGeneration
     array << 'Hospital'
     array << 'Outpatient'
     array << 'SuperMarket'
+    array << 'Laboratory'
+    array << 'LargeDataCenterLowITE'
+    array << 'LargeDataCenterHighITE'
+    array << 'SmallDataCenterLowITE'
+    array << 'SmallDataCenterHighITE'
+
+    return array
+  end
+
+  # get_deer_building_types
+  # for general public use use extended = false
+  def get_deer_building_types(extended = false)
+    # DOE Prototypes
+    array = OpenStudio::StringVector.new
+    array << 'Asm'
+    array << 'DMo'
+    array << 'ECC'
+    array << 'EPr'
+    array << 'ERC'
+    array << 'ESe'
+    array << 'EUn'
+    array << 'GHs'
+    array << 'Gro'
+    array << 'Hsp'
+    array << 'Htl'
+    array << 'MBT'
+    array << 'MFm'
+    array << 'MLI'
+    array << 'Mtl'
+    array << 'Nrs'
+    array << 'OfL'
+    array << 'OfS'
+    array << 'RFF'
+    array << 'RSD'
+    array << 'Rt3'
+    array << 'RtL'
+    array << 'RtS'
+    array << 'SCn'
+    array << 'SFm'
+    array << 'SUn'
+    array << 'WRf'
 
     return array
   end
 
   # simple list of templates that are valid for get_space_types_from_building_type
-  def get_templates
+  # for general public use use extended = false
+  def get_templates(extended = false)
+
+    # get templates
+    if extended
+      doe = get_doe_templates(true)
+      deer = get_deer_templates(true)
+    else
+      doe = get_doe_templates
+      deer = get_deer_templates
+    end
+
+    # combine templates
+    array = OpenStudio::StringVector.new
+    temp_array = doe.to_a + deer.to_a
+    temp_array.each do |i|
+      array << i
+    end
+
+    return array
+  end
+
+  # get_doe_templates
+  # for general public use use extended = false
+  def get_doe_templates(extended = false)
     array = OpenStudio::StringVector.new
     array << 'DOE Ref Pre-1980'
     array << 'DOE Ref 1980-2004'
     array << '90.1-2004'
     array << '90.1-2007'
-    # array << '189.1-2009' # if turn this on need to update space_type_array for RetailStripmall
     array << '90.1-2010'
     array << '90.1-2013'
-    array << 'NREL ZNE Ready 2017'
+    if extended
+      # array << '189.1-2009' # if turn this on need to update space_type_array for RetailStripmall
+      array << 'NREL ZNE Ready 2017'
+    end
+
+    return array
+  end
+
+  # get_deer_templates
+  # for general public use use extended = false
+  def get_deer_templates(extended = false)
+    array = OpenStudio::StringVector.new
+    array << 'DEER Pre-1975'
+    array << 'DEER 1985'
+    array << 'DEER 1996'
+    array << 'DEER 2003'
+    array << 'DEER 2007'
+    array << 'DEER 2011'
+    array << 'DEER 2014'
+    array << 'DEER 2015'
+    array << 'DEER 2017'
+    array << 'DEER 2020'
+    if extended
+      array << 'DEER 2025'
+      array << 'DEER 2030'
+      array << 'DEER 2035'
+      array << 'DEER 2040'
+      array << 'DEER 2045'
+      array << 'DEER 2050'
+      array << 'DEER 2055'
+      array << 'DEER 2060'
+      array << 'DEER 2065'
+      array << 'DEER 2070'
+      array << 'DEER 2075'
+    end
 
     return array
   end
 
+  # get_climate_zones
+  # for general public use use extended = false
+  def get_climate_zones(extended = false, extra = nil)
+
+    # get climate_zones
+    if extended && extra != nil
+      doe = get_doe_climate_zones(true, extra)
+      deer = get_deer_climate_zones(true, nil)
+    elsif extended
+      doe = get_doe_climate_zones(true, nil)
+      deer = get_deer_climate_zones(true, nil)
+    elsif extra != nil
+      doe = get_doe_climate_zones(false, extra)
+      deer = get_deer_climate_zones(false, nil)
+    else
+      doe = get_doe_climate_zones
+      deer = get_deer_climate_zones
+    end
+
+    # combine climate zones
+    array = OpenStudio::StringVector.new
+    temp_array = doe.to_a + deer.to_a
+    temp_array.each do |i|
+      array << i
+    end
+
+    return array
+  end
+
+  # get_doe_climate_zones
+  # for general public use use extended = false
+  def get_doe_climate_zones(extended = false, extra = nil)
+
+    # Lookup From Model should be added as an option where appropriate in the measure
+    cz_choices = OpenStudio::StringVector.new
+    if extra != nil
+      cz_choices << extra
+    end
+    cz_choices << 'ASHRAE 169-2013-1A'
+    cz_choices << 'ASHRAE 169-2013-1B'
+    cz_choices << 'ASHRAE 169-2013-2A'
+    cz_choices << 'ASHRAE 169-2013-2B'
+    cz_choices << 'ASHRAE 169-2013-3A'
+    cz_choices << 'ASHRAE 169-2013-3B'
+    cz_choices << 'ASHRAE 169-2013-3C'
+    cz_choices << 'ASHRAE 169-2013-4A'
+    cz_choices << 'ASHRAE 169-2013-4B'
+    cz_choices << 'ASHRAE 169-2013-4C'
+    cz_choices << 'ASHRAE 169-2013-5A'
+    cz_choices << 'ASHRAE 169-2013-5B'
+    cz_choices << 'ASHRAE 169-2013-5C'
+    cz_choices << 'ASHRAE 169-2013-6A'
+    cz_choices << 'ASHRAE 169-2013-6B'
+    cz_choices << 'ASHRAE 169-2013-7A'
+    cz_choices << 'ASHRAE 169-2013-8A'
+    if extended
+      cz_choices << 'ASHRAE 169-2013-0A'
+      cz_choices << 'ASHRAE 169-2013-0B'
+    end
+
+    return cz_choices
+  end
+
+  # get_deer_climate_zones
+  # for general public use use extended = false
+  def get_deer_climate_zones(extended = false, extra = nil)
+
+    # Lookup From Model should be added as an option where appropriate in the measure
+    cz_choices = OpenStudio::StringVector.new
+    if extra != nil
+      cz_choices << extra
+    end
+    cz_choices << 'CEC T24-CEC1'
+    cz_choices << 'CEC T24-CEC2'
+    cz_choices << 'CEC T24-CEC3'
+    cz_choices << 'CEC T24-CEC4'
+    cz_choices << 'CEC T24-CEC5'
+    cz_choices << 'CEC T24-CEC6'
+    cz_choices << 'CEC T24-CEC7'
+    cz_choices << 'CEC T24-CEC8'
+    cz_choices << 'CEC T24-CEC9'
+    cz_choices << 'CEC T24-CEC10'
+    cz_choices << 'CEC T24-CEC11'
+    cz_choices << 'CEC T24-CEC12'
+    cz_choices << 'CEC T24-CEC13'
+    cz_choices << 'CEC T24-CEC14'
+    cz_choices << 'CEC T24-CEC15'
+    cz_choices << 'CEC T24-CEC16'
+
+    return cz_choices
+  end
+
   # calculate aspect ratio from area and perimeter
   def calc_aspect_ratio(a, p)
     l = 0.25 * (p + Math.sqrt(p**2 - 16 * a))
@@ -84,74 +299,163 @@ module OsLib_ModelGeneration
 
   # Building Form Defaults from Table 4.2 in Achieving the 30% Goal: Energy and Cost Savings Analysis of ASHRAE Standard 90.1-2010
   # aspect ratio for NA replaced with floor area to perimeter ratio from prototype model
+  # currently no reason to split apart doe and deer inputs here
   def building_form_defaults(building_type)
     hash = {}
 
+    # DOE Prototypes
+
     # calculate aspect ratios not represented on Table 4.2
-    primary_aspet_ratio = calc_aspect_ratio(73958.0, 2060.0)
-    secondary_aspet_ratio = calc_aspect_ratio(128112.0, 2447.0)
-    outpatient_aspet_ratio = calc_aspect_ratio(14782.0, 588.0)
+    primary_footprint = 73958.0
+    primary_p = 619.0 # wrote measure using calculate_perimeter method in os_lib_geometry
+    primary_ns_ew_ratio = 2.829268293 # estimated from ratio of ns/ew total wall area
+    primary_width = Math.sqrt(primary_footprint/primary_ns_ew_ratio)
+    primary_p_min = 2 * (primary_width + primary_width / primary_footprint)
+    primary_p_mult = primary_p / primary_p_min
+
+    secondary_footprint = 210887.0 / 2.0 # floor area divided by area instead of true footprint 128112.0)
+    secondary_p = 708.0 # wrote measure using calculate_perimeter method in os_lib_geometry
+    secondary_ns_ew_ratio = 2.069230769 # estimated from ratio of ns/ew total wall area
+    secondary_width = Math.sqrt(secondary_footprint/secondary_ns_ew_ratio)
+    secondary_p_min = 2 * (secondary_width + secondary_width / secondary_footprint)
+    secondary_p_mult = secondary_p / secondary_p_min
+
+    outpatient_footprint = 40946.0 / 3.0 # floor area divided by area instead of true footprint 17872.0)
+    outpatient_p = 537.0 # wrote measure using calculate_perimeter method in os_lib_geometry
+    outpatient_ns_ew_ratio = 1.56448737 # estimated from ratio of ns/ew total wall area
+    outpatient_width = Math.sqrt(outpatient_footprint/outpatient_ns_ew_ratio)
+    outpatient_p_min = 2 * (outpatient_width + outpatient_footprint/outpatient_width)
+    outpatient_p_mult = outpatient_p / outpatient_p_min
+
+    #primary_aspet_ratio = calc_aspect_ratio(73958.0, 2060.0)
+    #secondary_aspet_ratio = calc_aspect_ratio(128112.0, 2447.0)
+    #outpatient_aspet_ratio = calc_aspect_ratio(14782.0, 588.0)
     supermarket_a = 45001.0
     supermarket_p = 866.0
     supermarket_wwr = 1880.0 / (supermarket_p * 20.0)
-    supermarket_aspet_ratio = calc_aspect_ratio(supermarket_a, supermarket_p)
-
-    hash['SmallOffice'] = { aspect_ratio: 1.5, wwr: 0.15, typical_story: 10.0 }
-    hash['MediumOffice'] = { aspect_ratio: 1.5, wwr: 0.33, typical_story: 13.0 }
-    hash['LargeOffice'] = { aspect_ratio: 1.5, wwr: 0.15, typical_story: 13.0 }
-    hash['RetailStandalone'] = { aspect_ratio: 1.28, wwr: 0.07, typical_story: 20.0 }
-    hash['RetailStripmall'] = { aspect_ratio: 4.0, wwr: 0.11, typical_story: 17.0 }
-    hash['PrimarySchool'] = { aspect_ratio: primary_aspet_ratio.round(1), wwr: 0.35, typical_story: 13.0 }
-    hash['SecondarySchool'] = { aspect_ratio: secondary_aspet_ratio.round(1), wwr: 0.33, typical_story: 13.0 }
-    hash['Outpatient'] = { aspect_ratio: outpatient_aspet_ratio.round(1), wwr: 0.20, typical_story: 10.0 }
-    hash['Hospital'] = { aspect_ratio: 1.33, wwr: 0.16, typical_story: 14.0 }
-    hash['SmallHotel'] = { aspect_ratio: 3.0, wwr: 0.11, typical_story: 9.0, first_story: 11.0 }
-    hash['LargeHotel'] = { aspect_ratio: 5.1, wwr: 0.27, typical_story: 10.0, first_story: 13.0 }
+    supermarket_aspect_ratio = calc_aspect_ratio(supermarket_a, supermarket_p)
+
+    hash['SmallOffice'] = { aspect_ratio: 1.5, wwr: 0.15, typical_story: 10.0, perim_mult: 1.0 }
+    hash['MediumOffice'] = { aspect_ratio: 1.5, wwr: 0.33, typical_story: 13.0, perim_mult: 1.0 }
+    hash['LargeOffice'] = { aspect_ratio: 1.5, wwr: 0.15, typical_story: 13.0, perim_mult: 1.0 }
+    hash['RetailStandalone'] = { aspect_ratio: 1.28, wwr: 0.07, typical_story: 20.0, perim_mult: 1.0 }
+    hash['RetailStripmall'] = { aspect_ratio: 4.0, wwr: 0.11, typical_story: 17.0, perim_mult: 1.0 }
+    hash['PrimarySchool'] = { aspect_ratio: primary_ns_ew_ratio.round(1), wwr: 0.35, typical_story: 13.0, perim_mult: primary_p_mult.round(3) }
+    hash['SecondarySchool'] = { aspect_ratio: secondary_ns_ew_ratio.round(1), wwr: 0.33, typical_story: 13.0, perim_mult: secondary_p_mult.round(3) }
+    hash['Outpatient'] = { aspect_ratio: outpatient_ns_ew_ratio.round(1), wwr: 0.20, typical_story: 10.0, perim_mult: outpatient_p_mult.round(3) }
+    hash['Hospital'] = { aspect_ratio: 1.33, wwr: 0.16, typical_story: 14.0, perim_mult: 1.0 }
+    hash['SmallHotel'] = { aspect_ratio: 3.0, wwr: 0.11, typical_story: 9.0, first_story: 11.0, perim_mult: 1.0 }
+    hash['LargeHotel'] = { aspect_ratio: 5.1, wwr: 0.27, typical_story: 10.0, first_story: 13.0, perim_mult: 1.0 }
 
     # code in get_space_types_from_building_type is used to override building wwr with space type specific wwr
-    hash['Warehouse'] = { aspect_ratio: 2.2, wwr: 0.0, typical_story: 28.0}
+    hash['Warehouse'] = { aspect_ratio: 2.2, wwr: 0.0, typical_story: 28.0, perim_mult: 1.0 }
 
-    hash['QuickServiceRestaurant'] = { aspect_ratio: 1.0, wwr: 0.14, typical_story: 10.0 }
-    hash['FullServiceRestaurant'] = { aspect_ratio: 1.0, wwr: 0.18, typical_story: 10.0 }
-    hash['QuickServiceRestaurant'] = { aspect_ratio: 1.0, wwr: 0.18, typical_story: 10.0 }
-    hash['MidriseApartment'] = { aspect_ratio: 2.75, wwr: 0.15, typical_story: 10.0 }
-    hash['HighriseApartment'] = { aspect_ratio: 2.75, wwr: 0.15, typical_story: 10.0 }
+    hash['QuickServiceRestaurant'] = { aspect_ratio: 1.0, wwr: 0.14, typical_story: 10.0, perim_mult: 1.0 }
+    hash['FullServiceRestaurant'] = { aspect_ratio: 1.0, wwr: 0.18, typical_story: 10.0, perim_mult: 1.0 }
+    hash['QuickServiceRestaurant'] = { aspect_ratio: 1.0, wwr: 0.18, typical_story: 10.0, perim_mult: 1.0 }
+    hash['MidriseApartment'] = { aspect_ratio: 2.75, wwr: 0.15, typical_story: 10.0, perim_mult: 1.0 }
+    hash['HighriseApartment'] = { aspect_ratio: 2.75, wwr: 0.15, typical_story: 10.0, perim_mult: 1.0 }
     # SuperMarket inputs come from prototype model
-    hash['SuperMarket'] = { aspect_ratio: supermarket_aspet_ratio.round(1), wwr: supermarket_wwr.round(2), typical_story: 20.0 }
+    hash['SuperMarket'] = { aspect_ratio: supermarket_aspect_ratio.round(1), wwr: supermarket_wwr.round(2), typical_story: 20.0, perim_mult: 1.0 }
+
+    # Add Laboratory and Data Centers
+    hash['Laboratory'] = { aspect_ratio: 1.33, wwr: 0.12, typical_story: 10.0, perim_mult: 1.0 }
+    hash['LargeDataCenterLowITE'] = { aspect_ratio: 1.67, wwr: 0.0, typical_story: 14.0, perim_mult: 1.0 }
+    hash['LargeDataCenterHighITE'] = { aspect_ratio: 1.67, wwr: 0.0, typical_story: 14.0, perim_mult: 1.0 }
+    hash['SmallDataCenterLowITE'] = { aspect_ratio: 1.5, wwr: 0.0, typical_story: 14.0, perim_mult: 1.0 }
+    hash['SmallDataCenterHighITE'] = { aspect_ratio: 1.5, wwr: 0.0, typical_story: 14.0, perim_mult: 1.0 }
+
+    # DEER Prototypes
+    hash['Asm'] = { aspect_ratio: 1.0, wwr: 0.19, typical_story: 15.0 }
+    hash['ECC'] = { aspect_ratio: 4.0, wwr: 0.25, typical_story: 13.0 }
+    hash['EPr'] = { aspect_ratio: 2.0, wwr: 0.16, typical_story: 12.0 }
+    hash['ERC'] = { aspect_ratio: 1.7, wwr: 0.03, typical_story: 12.0 }
+    hash['ESe'] = { aspect_ratio: 1.0, wwr: 0.15, typical_story: 13.0 }
+    hash['EUn'] = { aspect_ratio: 2.5, wwr: 0.3, typical_story: 14.0 }
+    hash['Gro'] = { aspect_ratio: 1.0, wwr: 0.07, typical_story: 25.0 }
+    hash['Hsp'] = { aspect_ratio: 1.5, wwr: 0.11, typical_story: 13.0 }
+    hash['Htl'] = { aspect_ratio: 3.0, wwr: 0.23, typical_story: 9.5, first_story: 12.0 }
+    hash['MBT'] = { aspect_ratio: 10.7, wwr: 0.12, typical_story: 15.0 }
+    hash['MFm'] = { aspect_ratio: 1.4, wwr: 0.24, typical_story: 9.5 }
+    hash['MLI'] = { aspect_ratio: 1.0, wwr: 0.01, typical_story: 35.0 }
+    hash['Mtl'] = { aspect_ratio: 5.1, wwr: 0.41, typical_story: 9.0 }
+    hash['Nrs'] = { aspect_ratio: 10.3, wwr: 0.2, typical_story: 13.0 }
+    hash['OfL'] = { aspect_ratio: 1.5, wwr: 0.33, typical_story: 12.0 }
+    hash['OfS'] = { aspect_ratio: 1.5, wwr: 0.33, typical_story: 12.0 }
+    hash['RFF'] = { aspect_ratio: 1.0, wwr: 0.25, typical_story: 13.0 }
+    hash['RSD'] = { aspect_ratio: 1.0, wwr: 0.13, typical_story: 13.0 }
+    hash['Rt3'] = { aspect_ratio: 1.0, wwr: 0.02, typical_story: 20.8 }
+    hash['RtL'] = { aspect_ratio: 1.0, wwr: 0.03, typical_story: 20.5 }
+    hash['RtS'] = { aspect_ratio: 1.0, wwr: 0.13, typical_story: 12.0 }
+    hash['SCn'] = { aspect_ratio: 1.0, wwr: 0.01, typical_story: 48.0 }
+    hash['SUn'] = { aspect_ratio: 1.0, wwr: 0.01, typical_story: 48.0 }
+    hash['WRf'] = { aspect_ratio: 1.6, wwr: 0.0, typical_story: 32.0 }
 
     return hash[building_type]
   end
 
   # create hash of space types and generic ratios of building floor area
+  # currently no reason to split apart doe and deer inputs here
   def get_space_types_from_building_type(building_type, template, whole_building = true)
     hash = {}
 
     # TODO: - Confirm that these work for all standards
-
+    # DOE Prototypes
     if building_type == 'SecondarySchool'
-      hash['Auditorium'] = { ratio: 0.0504, space_type_gen: true, default: false }
-      hash['Cafeteria'] = { ratio: 0.0319, space_type_gen: true, default: false }
-      hash['Classroom'] = { ratio: 0.3528, space_type_gen: true, default: true }
-      hash['Corridor'] = { ratio: 0.2144, space_type_gen: true, default: false }
-      hash['Gym'] = { ratio: 0.1646, space_type_gen: true, default: false }
-      hash['Kitchen'] = { ratio: 0.0110, space_type_gen: true, default: false }
-      hash['Library'] = { ratio: 0.0429, space_type_gen: true, default: false } # not in prototype
-      hash['Lobby'] = { ratio: 0.0214, space_type_gen: true, default: false }
-      hash['Mechanical'] = { ratio: 0.0349, space_type_gen: true, default: false }
-      hash['Office'] = { ratio: 0.0543, space_type_gen: true, default: false }
-      hash['Restroom'] = { ratio: 0.0214, space_type_gen: true, default: false }
+      if ['DOE Ref Pre-1980', 'DOE Ref 1980-2004'].include?(template)
+        hash['Auditorium'] = { ratio: 0.0504, space_type_gen: true, default: false, story_height: 26.0 }
+        hash['Cafeteria'] = { ratio: 0.0319, space_type_gen: true, default: false }
+        hash['Classroom'] = { ratio: 0.3528, space_type_gen: true, default: true }
+        hash['Corridor'] = { ratio: 0.2144, space_type_gen: true, default: false, circ: true }
+        hash['Gym'] = { ratio: 0.1009, space_type_gen: true, default: false , story_height: 26.0 }
+        hash['Gym - audience'] = { ratio: 0.0637, space_type_gen: true, default: false , story_height: 26.0 }
+        hash['Kitchen'] = { ratio: 0.0110, space_type_gen: true, default: false }
+        hash['Library'] = { ratio: 0.0429, space_type_gen: true, default: false }
+        hash['Lobby'] = { ratio: 0.0214, space_type_gen: true, default: false }
+        hash['Mechanical'] = { ratio: 0.0349, space_type_gen: true, default: false }
+        hash['Office'] = { ratio: 0.0543, space_type_gen: true, default: false }
+        hash['Restroom'] = { ratio: 0.0214, space_type_gen: true, default: false }
+      else
+        hash['Auditorium'] = { ratio: 0.0504, space_type_gen: true, default: false, story_height: 26.0 }
+        hash['Cafeteria'] = { ratio: 0.0319, space_type_gen: true, default: false }
+        hash['Classroom'] = { ratio: 0.3041, space_type_gen: true, default: true }
+        hash['ComputerRoom'] = { ratio: 0.0487, space_type_gen: true, default: true }
+        hash['Corridor'] = { ratio: 0.2144, space_type_gen: true, default: false, circ: true }
+        hash['Gym'] = { ratio: 0.1646, space_type_gen: true, default: false , story_height: 26.0 }
+        hash['Kitchen'] = { ratio: 0.0110, space_type_gen: true, default: false }
+        hash['Library'] = { ratio: 0.0429, space_type_gen: true, default: false }
+        hash['Lobby'] = { ratio: 0.0214, space_type_gen: true, default: false }
+        hash['Mechanical'] = { ratio: 0.0349, space_type_gen: true, default: false }
+        hash['Office'] = { ratio: 0.0543, space_type_gen: true, default: false }
+        hash['Restroom'] = { ratio: 0.0214, space_type_gen: true, default: false }
+      end
     elsif building_type == 'PrimarySchool'
-      hash['Cafeteria'] = { ratio: 0.0458, space_type_gen: true, default: false }
-      hash['Classroom'] = { ratio: 0.5610, space_type_gen: true, default: true }
-      hash['Corridor'] = { ratio: 0.1633, space_type_gen: true, default: false }
-      hash['Gym'] = { ratio: 0.0520, space_type_gen: true, default: false }
-      hash['Kitchen'] = { ratio: 0.0244, space_type_gen: true, default: false }
-      # TODO: - confirm if Library is 0.0 for all templates
-      hash['Library'] = { ratio: 0.0, space_type_gen: true, default: false }
-      hash['Lobby'] = { ratio: 0.0249, space_type_gen: true, default: false }
-      hash['Mechanical'] = { ratio: 0.0367, space_type_gen: true, default: false }
-      hash['Office'] = { ratio: 0.0642, space_type_gen: true, default: false }
-      hash['Restroom'] = { ratio: 0.0277, space_type_gen: true, default: false }
+      if ['DOE Ref Pre-1980', 'DOE Ref 1980-2004'].include?(template)
+        # updated to 2004 which includes library vs. pre-1980
+        hash['Cafeteria'] = { ratio: 0.0458, space_type_gen: true, default: false }
+        hash['Classroom'] = { ratio: 0.5610, space_type_gen: true, default: true }
+        hash['Corridor'] = { ratio: 0.1633, space_type_gen: true, default: false, circ: true }
+        hash['Gym'] = { ratio: 0.0520, space_type_gen: true, default: false }
+        hash['Kitchen'] = { ratio: 0.0244, space_type_gen: true, default: false }
+        hash['Library'] = { ratio: 0.0, space_type_gen: true, default: false } # no library in model
+        hash['Lobby'] = { ratio: 0.0249, space_type_gen: true, default: false }
+        hash['Mechanical'] = { ratio: 0.0367, space_type_gen: true, default: false }
+        hash['Office'] = { ratio: 0.0642, space_type_gen: true, default: false }
+        hash['Restroom'] = { ratio: 0.0277, space_type_gen: true, default: false }
+      else
+        # updated to 2004 which includes library vs. pre-1980
+        hash['Cafeteria'] = { ratio: 0.0458, space_type_gen: true, default: false }
+        hash['Classroom'] = { ratio: 0.4793, space_type_gen: true, default: true }
+        hash['ComputerRoom'] = { ratio: 0.0236, space_type_gen: true, default: true }
+        hash['Corridor'] = { ratio: 0.1633, space_type_gen: true, default: false, circ: true }
+        hash['Gym'] = { ratio: 0.0520, space_type_gen: true, default: false}
+        hash['Kitchen'] = { ratio: 0.0244, space_type_gen: true, default: false }
+        hash['Library'] = { ratio: 0.0581, space_type_gen: true, default: false }
+        hash['Lobby'] = { ratio: 0.0249, space_type_gen: true, default: false }
+        hash['Mechanical'] = { ratio: 0.0367, space_type_gen: true, default: false }
+        hash['Office'] = { ratio: 0.0642, space_type_gen: true, default: false }
+        hash['Restroom'] = { ratio: 0.0277, space_type_gen: true, default: false }
+      end
     elsif building_type == 'SmallOffice'
       # TODO: - populate Small, Medium, and Large office for whole_building false
       if whole_building
@@ -160,7 +464,7 @@ module OsLib_ModelGeneration
         hash['SmallOffice - Breakroom'] = { ratio: 0.99, space_type_gen: true, default: false }
         hash['SmallOffice - ClosedOffice'] = { ratio: 0.99, space_type_gen: true, default: false }
         hash['SmallOffice - Conference'] = { ratio: 0.99, space_type_gen: true, default: false }
-        hash['SmallOffice - Corridor'] = { ratio: 0.99, space_type_gen: true, default: false }
+        hash['SmallOffice - Corridor'] = { ratio: 0.99, space_type_gen: true, default: false, circ: true }
         hash['SmallOffice - Elec/MechRoom'] = { ratio: 0.99, space_type_gen: true, default: false }
         hash['SmallOffice - Lobby'] = { ratio: 0.99, space_type_gen: true, default: false }
         hash['SmallOffice - OpenOffice'] = { ratio: 0.99, space_type_gen: true, default: true }
@@ -178,7 +482,7 @@ module OsLib_ModelGeneration
         hash['MediumOffice - Breakroom'] = { ratio: 0.99, space_type_gen: true, default: false }
         hash['MediumOffice - ClosedOffice'] = { ratio: 0.99, space_type_gen: true, default: false }
         hash['MediumOffice - Conference'] = { ratio: 0.99, space_type_gen: true, default: false }
-        hash['MediumOffice - Corridor'] = { ratio: 0.99, space_type_gen: true, default: false }
+        hash['MediumOffice - Corridor'] = { ratio: 0.99, space_type_gen: true, default: false, circ: true }
         hash['MediumOffice - Elec/MechRoom'] = { ratio: 0.99, space_type_gen: true, default: false }
         hash['MediumOffice - Lobby'] = { ratio: 0.99, space_type_gen: true, default: false }
         hash['MediumOffice - OpenOffice'] = { ratio: 0.99, space_type_gen: true, default: true }
@@ -197,7 +501,7 @@ module OsLib_ModelGeneration
           hash['BreakRoom'] = { ratio: 0.99, space_type_gen: true, default: false }
           hash['ClosedOffice'] = { ratio: 0.99, space_type_gen: true, default: false }
           hash['Conference'] = { ratio: 0.99, space_type_gen: true, default: false }
-          hash['Corridor'] = { ratio: 0.99, space_type_gen: true, default: false }
+          hash['Corridor'] = { ratio: 0.99, space_type_gen: true, default: false, circ: true }
           hash['Elec/MechRoom'] = { ratio: 0.99, space_type_gen: true, default: false }
           hash['IT_Room'] = { ratio: 0.99, space_type_gen: true, default: false }
           hash['Lobby'] = { ratio: 0.99, space_type_gen: true, default: false }
@@ -218,7 +522,7 @@ module OsLib_ModelGeneration
           hash['BreakRoom'] = { ratio: 0.99, space_type_gen: true, default: false }
           hash['ClosedOffice'] = { ratio: 0.99, space_type_gen: true, default: false }
           hash['Conference'] = { ratio: 0.99, space_type_gen: true, default: false }
-          hash['Corridor'] = { ratio: 0.99, space_type_gen: true, default: false }
+          hash['Corridor'] = { ratio: 0.99, space_type_gen: true, default: false, circ: true }
           hash['Elec/MechRoom'] = { ratio: 0.99, space_type_gen: true, default: false }
           hash['IT_Room'] = { ratio: 0.99, space_type_gen: true, default: false }
           hash['Lobby'] = { ratio: 0.99, space_type_gen: true, default: false }
@@ -235,7 +539,7 @@ module OsLib_ModelGeneration
       end
     elsif building_type == 'SmallHotel'
       if ['DOE Ref Pre-1980', 'DOE Ref 1980-2004'].include?(template)
-        hash['Corridor'] = { ratio: 0.1313, space_type_gen: true, default: false }
+        hash['Corridor'] = { ratio: 0.1313, space_type_gen: true, default: false, circ: true }
         hash['Elec/MechRoom'] = { ratio: 0.0038, space_type_gen: true, default: false }
         hash['ElevatorCore'] = { ratio: 0.0113, space_type_gen: true, default: false }
         hash['Exercise'] = { ratio: 0.0081, space_type_gen: true, default: false }
@@ -250,7 +554,7 @@ module OsLib_ModelGeneration
         hash['Stair'] = { ratio: 0.0400, space_type_gen: true, default: false }
         hash['Storage'] = { ratio: 0.0325, space_type_gen: true, default: false }
       else
-        hash['Corridor'] = { ratio: 0.1313, space_type_gen: true, default: false }
+        hash['Corridor'] = { ratio: 0.1313, space_type_gen: true, default: false, circ: true }
         hash['Elec/MechRoom'] = { ratio: 0.0038, space_type_gen: true, default: false }
         hash['ElevatorCore'] = { ratio: 0.0113, space_type_gen: true, default: false }
         hash['Exercise'] = { ratio: 0.0081, space_type_gen: true, default: false }
@@ -270,7 +574,7 @@ module OsLib_ModelGeneration
       hash['Banquet'] = { ratio: 0.0585, space_type_gen: true, default: false }
       hash['Basement'] = { ratio: 0.1744, space_type_gen: false, default: false }
       hash['Cafe'] = { ratio: 0.0166, space_type_gen: true, default: false }
-      hash['Corridor'] = { ratio: 0.1736, space_type_gen: true, default: false }
+      hash['Corridor'] = { ratio: 0.1736, space_type_gen: true, default: false, circ: true }
       hash['GuestRoom'] = { ratio: 0.4099, space_type_gen: true, default: true }
       hash['Kitchen'] = { ratio: 0.0091, space_type_gen: true, default: false }
       hash['Laundry'] = { ratio: 0.0069, space_type_gen: true, default: false }
@@ -281,7 +585,7 @@ module OsLib_ModelGeneration
     elsif building_type == 'Warehouse'
       hash['Bulk'] = { ratio: 0.6628, space_type_gen: true, default: true }
       hash['Fine'] = { ratio: 0.2882, space_type_gen: true, default: false }
-      hash['Office'] = { ratio: 0.0490, space_type_gen: true, default: false, wwr: 0.71 }
+      hash['Office'] = { ratio: 0.0490, space_type_gen: true, default: false, wwr: 0.71, story_height: 14.0 }
     elsif building_type == 'RetailStandalone'
       hash['Back_Space'] = { ratio: 0.1656, space_type_gen: true, default: false }
       hash['Entry'] = { ratio: 0.0052, space_type_gen: true, default: false }
@@ -299,22 +603,22 @@ module OsLib_ModelGeneration
       hash['Kitchen'] = { ratio: 0.2728, space_type_gen: true, default: false }
     elsif building_type == 'MidriseApartment'
       hash['Apartment'] = { ratio: 0.8727, space_type_gen: true, default: true }
-      hash['Corridor'] = { ratio: 0.0991, space_type_gen: true, default: false }
+      hash['Corridor'] = { ratio: 0.0991, space_type_gen: true, default: false, circ: true }
       hash['Office'] = { ratio: 0.0282, space_type_gen: true, default: false }
     elsif building_type == 'HighriseApartment'
       hash['Apartment'] = { ratio: 0.8896, space_type_gen: true, default: true }
-      hash['Corridor'] = { ratio: 0.0991, space_type_gen: true, default: false }
+      hash['Corridor'] = { ratio: 0.0991, space_type_gen: true, default: false, circ: true }
       hash['Office'] = { ratio: 0.0113, space_type_gen: true, default: false }
     elsif building_type == 'Hospital'
       hash['Basement'] = { ratio: 0.1667, space_type_gen: false, default: false }
-      hash['Corridor'] = { ratio: 0.1741, space_type_gen: true, default: false }
+      hash['Corridor'] = { ratio: 0.1741, space_type_gen: true, default: false, circ: true }
       hash['Dining'] = { ratio: 0.0311, space_type_gen: true, default: false }
       hash['ER_Exam'] = { ratio: 0.0099, space_type_gen: true, default: false }
       hash['ER_NurseStn'] = { ratio: 0.0551, space_type_gen: true, default: false }
       hash['ER_Trauma'] = { ratio: 0.0025, space_type_gen: true, default: false }
       hash['ER_Triage'] = { ratio: 0.0050, space_type_gen: true, default: false }
       hash['ICU_NurseStn'] = { ratio: 0.0298, space_type_gen: true, default: false }
-      hash['ICE_Open'] = { ratio: 0.0275, space_type_gen: true, default: false }
+      hash['ICU_Open'] = { ratio: 0.0275, space_type_gen: true, default: false }
       hash['ICU_PatRm'] = { ratio: 0.0115, space_type_gen: true, default: false }
       hash['Kitchen'] = { ratio: 0.0414, space_type_gen: true, default: false }
       hash['Lab'] = { ratio: 0.0236, space_type_gen: true, default: false }
@@ -336,7 +640,7 @@ module OsLib_ModelGeneration
       hash['Elec/MechRoom'] = { ratio: 0.0109, space_type_gen: true, default: false }
       hash['ElevatorPumpRoom'] = { ratio: 0.0022, space_type_gen: true, default: false }
       hash['Exam'] = { ratio: 0.1029, space_type_gen: true, default: true }
-      hash['Hall'] = { ratio: 0.1924, space_type_gen: true, default: false }
+      hash['Hall'] = { ratio: 0.1924, space_type_gen: true, default: false, circ: true }
       hash['IT_Room'] = { ratio: 0.0027, space_type_gen: true, default: false }
       hash['Janitor'] = { ratio: 0.0672, space_type_gen: true, default: false }
       hash['Lobby'] = { ratio: 0.0152, space_type_gen: true, default: false }
@@ -372,6 +676,142 @@ module OsLib_ModelGeneration
       hash['Meeting'] = { ratio: 0.99, space_type_gen: true, default: true }
       hash['Restroom'] = { ratio: 0.99, space_type_gen: true, default: true }
       hash['Vestibule'] = { ratio: 0.99, space_type_gen: true, default: true }
+    elsif building_type == 'Laboratory'
+      hash['Office'] = { ratio: 0.50, space_type_gen: true, default: true }
+      hash['Open lab'] = { ratio: 0.35, space_type_gen: true, default: true }
+      hash['Equipment corridor'] = { ratio: 0.05, space_type_gen: true, default: true }
+      hash['Lab with fume hood'] = { ratio: 0.10, space_type_gen: true, default: true }
+    elsif building_type == 'LargeDataCenterHighITE'
+      hash['StandaloneDataCenter'] = { ratio: 1.0, space_type_gen: true, default: true }
+    elsif building_type == 'LargeDataCenterLowITE'
+      hash['StandaloneDataCenter'] = { ratio: 1.0, space_type_gen: true, default: true }
+    elsif building_type == 'SmallDataCenterHighITE'
+      hash['ComputerRoom'] = { ratio: 1.0, space_type_gen: true, default: true }
+    elsif building_type == 'SmallDataCenterLowITE'
+      hash['ComputerRoom'] = { ratio: 1.0, space_type_gen: true, default: true }
+      # DEER Prototypes
+    elsif building_type == 'Asm'
+      hash['Auditorium'] = { ratio: 0.7658, space_type_gen: true, default: true }
+      hash['OfficeGeneral'] = { ratio: 0.2342, space_type_gen: true, default: false }
+    elsif building_type == 'ECC'
+      hash['Classroom'] = { ratio: 0.5558, space_type_gen: true, default: true }
+      hash['CompRoomClassRm'] = { ratio: 0.0319, space_type_gen: true, default: false }
+      hash['Shop'] = { ratio: 0.1249, space_type_gen: true, default: false }
+      hash['Dining'] = { ratio: 0.0876, space_type_gen: true, default: false }
+      hash['Kitchen'] = { ratio: 0.0188, space_type_gen: true, default: false }
+      hash['OfficeGeneral'] = { ratio: 0.181, space_type_gen: true, default: false }
+    elsif building_type == 'EPr'
+      hash['Classroom'] = { ratio: 0.53, space_type_gen: true, default: true }
+      hash['CorridorStairway'] = { ratio: 0.1, space_type_gen: true, default: false }
+      hash['Dining'] = { ratio: 0.15, space_type_gen: true, default: false }
+      hash['Gymnasium'] = { ratio: 0.15, space_type_gen: true, default: false }
+      hash['Kitchen'] = { ratio: 0.07, space_type_gen: true, default: false }
+    elsif building_type == 'ERC'
+      hash['Classroom'] = { ratio: 0.5, space_type_gen: true, default: true }
+    elsif building_type == 'ESe'
+      hash['Classroom'] = { ratio: 0.488, space_type_gen: true, default: true }
+      hash['CompRoomClassRm'] = { ratio: 0.021, space_type_gen: true, default: false }
+      hash['CorridorStairway'] = { ratio: 0.1, space_type_gen: true, default: false }
+      hash['Dining'] = { ratio: 0.15, space_type_gen: true, default: false }
+      hash['Gymnasium'] = { ratio: 0.15, space_type_gen: true, default: false }
+      hash['Kitchen'] = { ratio: 0.07, space_type_gen: true, default: false }
+      hash['OfficeGeneral'] = { ratio: 0.021, space_type_gen: true, default: true }
+    elsif building_type == 'EUn'
+      hash['Dining'] = { ratio: 0.0238, space_type_gen: true, default: false }
+      hash['Classroom'] = { ratio: 0.3056, space_type_gen: true, default: false }
+      hash['OfficeGeneral'] = { ratio: 0.3422, space_type_gen: true, default: true }
+      hash['CompRoomClassRm'] = { ratio: 0.038, space_type_gen: true, default: false }
+      hash['Kitchen'] = { ratio: 0.0105, space_type_gen: true, default: false }
+      hash['CorridorStairway'] = { ratio: 0.03, space_type_gen: true, default: false }
+      hash['FacMaint'] = { ratio: 0.08, space_type_gen: true, default: false }
+      hash['DormitoryRoom'] = { ratio: 0.1699, space_type_gen: true, default: false }
+    elsif building_type == 'Gro'
+      hash['GrocSales'] = { ratio: 0.8002, space_type_gen: true, default: true }
+      hash['RefWalkInCool'] = { ratio: 0.0312, space_type_gen: true, default: false }
+      hash['OfficeGeneral'] = { ratio: 0.07, space_type_gen: true, default: false }
+      hash['RefFoodPrep'] = { ratio: 0.0253, space_type_gen: true, default: false }
+      hash['RefWalkInFreeze'] = { ratio: 0.0162, space_type_gen: true, default: false }
+      hash['IndLoadDock'] = { ratio: 0.057, space_type_gen: true, default: false }
+    elsif building_type == 'Hsp'
+      hash['HspSurgOutptLab'] = { ratio: 0.2317, space_type_gen: true, default: false }
+      hash['Dining'] = { ratio: 0.0172, space_type_gen: true, default: false }
+      hash['Kitchen'] = { ratio: 0.0075, space_type_gen: true, default: false }
+      hash['OfficeGeneral'] = { ratio: 0.3636, space_type_gen: true, default: false }
+      hash['PatientRoom'] = { ratio: 0.38, space_type_gen: true, default: true }
+    elsif building_type == 'Htl'
+      hash['Dining'] = { ratio: 0.004, space_type_gen: true, default: false }
+      hash['BarCasino'] = { ratio: 0.005, space_type_gen: true, default: false }
+      hash['HotelLobby'] = { ratio: 0.0411, space_type_gen: true, default: false }
+      hash['OfficeGeneral'] = { ratio: 0.0205, space_type_gen: true, default: false }
+      hash['GuestRmCorrid'] = { ratio: 0.1011, space_type_gen: true, default: false }
+      hash['Laundry'] = { ratio: 0.0205, space_type_gen: true, default: false }
+      hash['GuestRmOcc'] = { ratio: 0.64224, space_type_gen: true, default: true }
+      hash['GuestRmUnOcc'] = { ratio: 0.16056, space_type_gen: true, default: true }
+      hash['Kitchen'] = { ratio: 0.005, space_type_gen: true, default: false }
+    elsif building_type == 'MBT'
+      hash['CompRoomData'] = { ratio: 0.02, space_type_gen: true, default: false }
+      hash['Laboratory'] = { ratio: 0.4534, space_type_gen: true, default: true }
+      hash['CorridorStairway'] = { ratio: 0.2, space_type_gen: true, default: false }
+      hash['Conference'] = { ratio: 0.02, space_type_gen: true, default: false }
+      hash['Dining'] = { ratio: 0.03, space_type_gen: true, default: false }
+      hash['OfficeOpen'] = { ratio: 0.2666, space_type_gen: true, default: false }
+      hash['Kitchen'] = { ratio: 0.01, space_type_gen: true, default: false }
+    elsif building_type == 'MFm'
+      hash['ResLiving'] = { ratio: 0.9297, space_type_gen: true, default: true }
+      hash['ResPublicArea'] = { ratio: 0.0725, space_type_gen: true, default: false }
+    elsif building_type == 'MLI'
+      hash['StockRoom'] = { ratio: 0.2, space_type_gen: true, default: false }
+      hash['Work'] = { ratio: 0.8, space_type_gen: true, default: true }
+    elsif building_type == 'Mtl'
+      hash['OfficeGeneral'] = { ratio: 0.02, space_type_gen: true, default: false }
+      hash['GuestRmCorrid'] = { ratio: 0.649, space_type_gen: true, default: true }
+      hash['Laundry'] = { ratio: 0.016, space_type_gen: true, default: false }
+      hash['GuestRmOcc'] = { ratio: 0.25208, space_type_gen: true, default: false }
+      hash['GuestRmUnOcc'] = { ratio: 0.06302, space_type_gen: true, default: false }
+    elsif building_type == 'Nrs'
+      hash['CorridorStairway'] = { ratio: 0.0555, space_type_gen: true, default: false }
+      hash['Dining'] = { ratio: 0.105, space_type_gen: true, default: false }
+      hash['Kitchen'] = { ratio: 0.045, space_type_gen: true, default: false }
+      hash['OfficeGeneral'] = { ratio: 0.35, space_type_gen: true, default: false }
+      hash['PatientRoom'] = { ratio: 0.4445, space_type_gen: true, default: true }
+    elsif building_type == 'OfL'
+      hash['LobbyWaiting'] = { ratio: 0.0412, space_type_gen: true, default: false }
+      hash['OfficeSmall'] = { ratio: 0.3704, space_type_gen: true, default: false }
+      hash['OfficeOpen'] = { ratio: 0.5296, space_type_gen: true, default: true }
+      hash['MechElecRoom'] = { ratio: 0.0588, space_type_gen: true, default: false }
+    elsif building_type == 'OfS'
+      hash['Hall'] = { ratio: 0.3141, space_type_gen: true, default: false }
+      hash['OfficeSmall'] = { ratio: 0.6859, space_type_gen: true, default: true }
+    elsif building_type == 'RFF'
+      hash['Dining'] = { ratio: 0.3997, space_type_gen: true, default: false }
+      hash['Kitchen'] = { ratio: 0.4, space_type_gen: true, default: true }
+      hash['LobbyWaiting'] = { ratio: 0.1501, space_type_gen: true, default: false }
+      hash['Restroom'] = { ratio: 0.0501, space_type_gen: true, default: false }
+    elsif building_type == 'RSD'
+      hash['Restroom'] = { ratio: 0.0357, space_type_gen: true, default: false }
+      hash['Dining'] = { ratio: 0.5353, space_type_gen: true, default: true }
+      hash['LobbyWaiting'] = { ratio: 0.1429, space_type_gen: true, default: false }
+      hash['Kitchen'] = { ratio: 0.2861, space_type_gen: true, default: false }
+    elsif building_type == 'Rt3'
+      hash['RetailSales'] = { ratio: 1.0, space_type_gen: true, default: true }
+    elsif building_type == 'RtL'
+      hash['OfficeGeneral'] = { ratio: 0.0359, space_type_gen: true, default: false }
+      hash['Work'] = { ratio: 0.04, space_type_gen: true, default: false }
+      hash['StockRoom'] = { ratio: 0.091, space_type_gen: true, default: false }
+      hash['RetailSales'] = { ratio: 0.8219, space_type_gen: true, default: true }
+      hash['Kitchen'] = { ratio: 0.0113, space_type_gen: true, default: false }
+    elsif building_type == 'RtS'
+      hash['RetailSales'] = { ratio: 0.8, space_type_gen: true, default: true }
+      hash['StockRoom'] = { ratio: 0.2, space_type_gen: true, default: false }
+    elsif building_type == 'SCn'
+      hash['WarehouseCond'] = { ratio: 1.0, space_type_gen: true, default: true }
+    elsif building_type == 'SUn'
+      hash['WarehouseUnCond'] = { ratio: 1.0, space_type_gen: true, default: true }
+    elsif building_type == 'WRf'
+      hash['IndLoadDock'] = { ratio: 0.08, space_type_gen: true, default: false }
+      hash['OfficeGeneral'] = { ratio: 0.02, space_type_gen: true, default: false }
+      hash['RefStorFreezer'] = { ratio: 0.4005, space_type_gen: true, default: false }
+      hash['RefStorCooler'] = { ratio: 0.4995, space_type_gen: true, default: true }
     else
       return false
     end
@@ -588,12 +1028,14 @@ module OsLib_ModelGeneration
 
       # set primary space type to building default space type
       space_types = bar_hash[:space_types].sort_by { |k, v| v[:floor_area] }
-      model.getBuilding.setSpaceType(space_types.last.first)
+      if space_types.last.first.class.to_s == 'OpenStudio::Model::SpaceType'
+        model.getBuilding.setSpaceType(space_types.last.first)
+      end
 
     end
 
     # makeSpacesFromPolygons
-    OsLib_Geometry.makeSpacesFromPolygons(runner, model, footprints, bar_hash[:floor_height], bar_hash[:num_stories], bar_hash[:center_of_footprint], story_hash)
+    new_spaces = OsLib_Geometry.makeSpacesFromPolygons(runner, model, footprints, bar_hash[:floor_height], bar_hash[:num_stories], bar_hash[:center_of_footprint], story_hash)
 
     # put all of the spaces in the model into a vector for intersection and surface matching
     spaces = OpenStudio::Model::SpaceVector.new
@@ -601,19 +1043,136 @@ module OsLib_ModelGeneration
       spaces << space
     end
 
+    # flag for intersection and matching type
+    diagnostic_intersect = true
+
     # only intersect if make_mid_story_surfaces_adiabatic false
-    if !(bar_hash[:make_mid_story_surfaces_adiabatic])
-      # intersect surfaces
-      # (when bottom floor has many space types and one above doesn't will end up with heavily subdivided floor. Maybe use adiabatic and don't intersect floor/ceilings)
-      intersect_surfaces = true
-      if intersect_surfaces
-        OpenStudio::Model.intersectSurfaces(spaces)
-        runner.registerInfo('Intersecting surfaces, this will create additional geometry.')
+    if diagnostic_intersect
+
+      model.getPlanarSurfaces.each do |surface|
+        array = []
+        vertices = surface.vertices
+        fixed = false
+        vertices.each do |vertex|
+          next if fixed
+          if array.include?(vertex)
+            # create a new set of vertices
+            new_vertices = OpenStudio::Point3dVector.new
+            array_b = []
+            surface.vertices.each do |vertex_b|
+              next if array_b.include?(vertex_b)
+              new_vertices << vertex_b
+              array_b << vertex_b
+            end
+            surface.setVertices(new_vertices)
+            num_removed = vertices.size - surface.vertices.size
+            runner.registerWarning("#{surface.name} has duplicate vertices. Started with #{vertices.size} vertices, removed #{num_removed}.")
+            fixed = true
+          else
+            array << vertex
+          end
+        end
+      end
+
+      # remove collinear points in a surface
+      model.getPlanarSurfaces.each do |surface|
+        new_vertices = OpenStudio.removeCollinear(surface.vertices)
+        starting_count = surface.vertices.size
+        final_count = new_vertices.size
+        if final_count < starting_count
+          runner.registerWarning("Removing #{starting_count - final_count} collinear vertices from #{surface.name}.")
+          surface.setVertices(new_vertices)
+        end
+      end
+
+      # remove duplicate surfaces in a space (should be done after remove duplicate and collinear points)
+      model.getSpaces.each do |space|
+
+        # secondary array to compare against
+        surfaces_b = space.surfaces.sort
+
+        space.surfaces.sort.each do |surface_a|
+
+          # delete from secondary array
+          surfaces_b.delete(surface_a)
+
+          surfaces_b.each do |surface_b|
+            next if surface_a == surface_b # dont' test against same surface
+            if surface_a.equalVertices(surface_b)
+              runner.registerWarning("#{surface_a.name} and #{surface_b.name} in #{space.name} have duplicate geometry, removing #{surface_b.name}.")
+              surface_b.remove
+            elsif surface_a.reverseEqualVertices(surface_b)
+              # todo - add logic to determine which face naormal is reversed and which is correct
+              runner.registerWarning("#{surface_a.name} and #{surface_b.name} in #{space.name} have reversed geometry, removing #{surface_b.name}.")
+              surface_b.remove
+            end
+
+          end
+
+        end
       end
-    end
 
-    # match surfaces for each space in the vector
-    OpenStudio::Model.matchSurfaces(spaces)
+      if !(bar_hash[:make_mid_story_surfaces_adiabatic])
+        # intersect and surface match two pair by pair
+        spaces_b = model.getSpaces.sort
+        # looping through vector of each space
+        model.getSpaces.sort.each do |space_a|
+          spaces_b.delete(space_a)
+          spaces_b.each do |space_b|
+            #runner.registerInfo("Intersecting and matching surfaces between #{space_a.name} and #{space.name}")
+            spaces_temp = OpenStudio::Model::SpaceVector.new
+            spaces_temp << space_a
+            spaces_temp << space_b
+            # intersect and sort
+            OpenStudio::Model.intersectSurfaces(spaces_temp)
+            OpenStudio::Model.matchSurfaces(spaces_temp)
+          end
+        end
+        runner.registerInfo('Intersecting and matching surfaces in model, this will create additional geometry.')
+      else #elsif bar_hash[:double_loaded_corridor] # only intersect spaces in each story, not between wtory
+        model.getBuilding.buildingStories.each do |story|
+          # intersect and surface match two pair by pair
+          spaces_b = story.spaces.sort
+          # looping through vector of each space
+          story.spaces.sort.each do |space_a|
+            spaces_b.delete(space_a)
+            spaces_b.each do |space_b|
+              spaces_temp = OpenStudio::Model::SpaceVector.new
+              spaces_temp << space_a
+              spaces_temp << space_b
+              # intersect and sort
+              OpenStudio::Model.intersectSurfaces(spaces_temp)
+              OpenStudio::Model.matchSurfaces(spaces_temp)
+            end
+          end
+          runner.registerInfo("Intersecting and matching surfaces in story #{story.name}, this will create additional geometry.")
+        end
+      end
+
+    else
+
+      if !(bar_hash[:make_mid_story_surfaces_adiabatic])
+        # intersect surfaces
+        # (when bottom floor has many space types and one above doesn't will end up with heavily subdivided floor. Maybe use adiabatic and don't intersect floor/ceilings)
+        intersect_surfaces = true
+        if intersect_surfaces
+          OpenStudio::Model.intersectSurfaces(spaces)
+          OpenStudio::Model.matchSurfaces(spaces)
+          runner.registerInfo('Intersecting and matching surfaces in model, this will create additional geometry.')
+        end
+      else #elsif bar_hash[:double_loaded_corridor] # only intersect spaces in each story, not between wtory
+        model.getBuilding.buildingStories.each do |story|
+          story_spaces = OpenStudio::Model::SpaceVector.new
+          story.spaces.sort.each do |space|
+            story_spaces << space
+          end
+          OpenStudio::Model.intersectSurfaces(story_spaces)
+          OpenStudio::Model.matchSurfaces(story_spaces)
+          runner.registerInfo("Intersecting and matching surfaces in story #{story.name}, this will create additional geometry.")
+        end
+      end
+
+    end
 
     # set boundary conditions if not already set when geometry was created
     # todo - update this to use space original z value vs. story name
@@ -621,6 +1180,7 @@ module OsLib_ModelGeneration
       model.getBuildingStorys.each do |story|
         next if !story.name.to_s.include?('Story B')
         story.spaces.each do |space|
+          next if not new_spaces.include?(space)
           space.surfaces.each do |surface|
             next if surface.surfaceType != 'Wall'
             next if surface.outsideBoundaryCondition != 'Outdoors'
@@ -631,10 +1191,13 @@ module OsLib_ModelGeneration
     end
 
     # sort stories (by name for now but need better way)
-    # todo - need to change this so doesn't create issues when models have existing stories and spaces. Should be able to run it multiple times
     sorted_stories = {}
-    model.getBuildingStorys.each do |story|
-      sorted_stories[story.name.to_s] = story
+    new_spaces.each do |space|
+      next if ! space.buildingStory.is_initialized
+      story = space.buildingStory.get
+      if ! sorted_stories.has_key?(name.to_s)
+        sorted_stories[story.name.to_s] = story
+      end
     end
 
     # flag space types that have wwr overrides
@@ -651,7 +1214,7 @@ module OsLib_ModelGeneration
         adiabatic_ceiling = true
       end
 
-      # make all mid story floor and celings adiabiatc if requested
+      # make all mid story floor and ceilings adiabatic if requested
       if bar_hash[:make_mid_story_surfaces_adiabatic]
         if i > 0
           adiabatic_floor = true
@@ -665,6 +1228,7 @@ module OsLib_ModelGeneration
       party_wall_facades = stories_flat[i][:story_party_walls]
 
       story.spaces.each do |space|
+        next if not new_spaces.include?(space)
         space.surfaces. each do |surface|
           # set floor to adiabatic if requited
           if adiabatic_floor && surface.surfaceType == 'Floor'
@@ -693,11 +1257,11 @@ module OsLib_ModelGeneration
             space_type = surface.space.get.spaceType.get
 
             # see if space type has wwr value
-            bar_hash[:space_types].each do |k,v|
-              if v.has_key?(:space_type) && space_type == v[:space_type]
+            bar_hash[:space_types].each do |k, v|
+              if v.key?(:space_type) && space_type == v[:space_type]
 
-                # if matching space type specifies a wwr then override the orientaiton specific recommendations for this surface.
-                if v.has_key?(:wwr)
+                # if matching space type specifies a wwr then override the orientation specific recommendations for this surface.
+                if v.key?(:wwr)
                   wwr_n = v[:wwr]
                   wwr_e = v[:wwr]
                   wwr_s = v[:wwr]
@@ -742,12 +1306,25 @@ module OsLib_ModelGeneration
     end
 
     # report space types with custom wwr values
-    space_type_wwr_overrides.each do |space_type,wwr|
-      runner.registerInfo("For #{space_type.name} the default building wwr was replaced with a space type specifc value of #{wwr}")
+    space_type_wwr_overrides.each do |space_type, wwr|
+      runner.registerInfo("For #{space_type.name} the default building wwr was replaced with a space type specfic value of #{wwr}")
     end
 
+    new_floor_area_si = 0.0
+    new_spaces.each do |space|
+      new_floor_area_si += space.floorArea * space.multiplier
+    end
+    new_floor_area_ip = OpenStudio.convert(new_floor_area_si, 'm^2', 'ft^2').get
+
     final_floor_area_ip = OpenStudio.convert(model.getBuilding.floorArea, 'm^2', 'ft^2').get
-    runner.registerInfo("Created Bar envlope with floor area of #{OpenStudio.toNeatString(final_floor_area_ip, 0, true)} (ft^2)")
+    if new_floor_area_ip == final_floor_area_ip
+      runner.registerInfo("Created bar envelope with floor area of #{OpenStudio.toNeatString(new_floor_area_ip, 0, true)} ft^2.")
+    else
+      runner.registerInfo("Created bar envelope with floor area of #{OpenStudio.toNeatString(new_floor_area_ip, 0, true)} ft^2. Total building area is #{OpenStudio.toNeatString(final_floor_area_ip, 0, true)} ft^2.")
+    end
+
+    return new_spaces
+
   end
 
   # make selected surfaces adiabatic
@@ -814,4 +1391,1888 @@ module OsLib_ModelGeneration
 
     return bar
   end
+
+  def bar_hash_setup_run(runner,model,args,length,width,floor_height_si,center_of_footprint,space_types_hash,num_stories)
+    # create envelope
+    # populate bar_hash and create envelope with data from envelope_data_hash and user arguments
+    bar_hash = {}
+    bar_hash[:length] = length
+    bar_hash[:width] = width
+    bar_hash[:num_stories_below_grade] = args['num_stories_below_grade']
+    bar_hash[:num_stories_above_grade] = args['num_stories_above_grade']
+    bar_hash[:floor_height] = floor_height_si
+    bar_hash[:center_of_footprint] = center_of_footprint
+    bar_hash[:bar_division_method] = args['bar_division_method']
+    bar_hash[:make_mid_story_surfaces_adiabatic] = args['make_mid_story_surfaces_adiabatic']
+    bar_hash[:space_types] = space_types_hash
+    bar_hash[:building_wwr_n] = args['wwr']
+    bar_hash[:building_wwr_s] = args['wwr']
+    bar_hash[:building_wwr_e] = args['wwr']
+    bar_hash[:building_wwr_w] = args['wwr']
+
+    # round up non integer stoires to next integer
+    num_stories_round_up = num_stories.ceil
+    runner.registerInfo("Making bar with length of #{OpenStudio.toNeatString(OpenStudio.convert(length, 'm', 'ft').get, 0, true)} ft and width of #{OpenStudio.toNeatString(OpenStudio.convert(width, 'm', 'ft').get, 0, true)} ft")
+
+    # party_walls_array to be used by orientation specific or fractional party wall values
+    party_walls_array = [] # this is an array of arrays, where each entry is effective building story with array of directions
+
+    if args['party_wall_stories_north'] + args['party_wall_stories_south'] + args['party_wall_stories_east'] + args['party_wall_stories_west'] > 0
+
+      # loop through effective number of stories add orientation specific party walls per user arguments
+      num_stories_round_up.times do |i|
+        test_value = i + 1 - bar_hash[:num_stories_below_grade]
+
+        array = []
+        if args['party_wall_stories_north'] >= test_value
+          array << 'north'
+        end
+        if args['party_wall_stories_south'] >= test_value
+          array << 'south'
+        end
+        if args['party_wall_stories_east'] >= test_value
+          array << 'east'
+        end
+        if args['party_wall_stories_west'] >= test_value
+          array << 'west'
+        end
+
+        # populate party_wall_array for this story
+        party_walls_array << array
+      end
+    end
+
+    # calculate party walls if using party_wall_fraction method
+    if args['party_wall_fraction'] > 0 && !party_walls_array.empty?
+      runner.registerWarning('Both orientation and fractional party wall values arguments were populated, will ignore fractional party wall input')
+    elsif args['party_wall_fraction'] > 0
+
+      # orientation of long and short side of building will vary based on building rotation
+
+      # full story ext wall area
+      typical_length_facade_area = length * floor_height_si
+      typical_width_facade_area = width * floor_height_si
+
+      # top story ext wall area, may be partial story
+      partial_story_multiplier = (1.0 - args['num_stories_above_grade'].ceil + args['num_stories_above_grade'])
+      area_multiplier = partial_story_multiplier
+      edge_multiplier = Math.sqrt(area_multiplier)
+      top_story_length = length * edge_multiplier
+      top_story_width = width * edge_multiplier
+      top_story_length_facade_area = top_story_length * floor_height_si
+      top_story_width_facade_area = top_story_width * floor_height_si
+
+      total_exterior_wall_area = 2 * (length + width) * (args['num_stories_above_grade'].ceil - 1.0) * floor_height_si + 2 * (top_story_length + top_story_width) * floor_height_si
+      target_party_wall_area = total_exterior_wall_area * args['party_wall_fraction']
+
+      width_counter = 0
+      width_area = 0.0
+      facade_area = typical_width_facade_area
+      until (width_area + facade_area >= target_party_wall_area) || (width_counter == args['num_stories_above_grade'].ceil * 2)
+        # update facade area for top story
+        if width_counter == args['num_stories_above_grade'].ceil - 1 || width_counter == args['num_stories_above_grade'].ceil * 2 - 1
+          facade_area = top_story_width_facade_area
+        else
+          facade_area = typical_width_facade_area
+        end
+
+        width_counter += 1
+        width_area += facade_area
+
+      end
+      width_area_remainder = target_party_wall_area - width_area
+
+      length_counter = 0
+      length_area = 0.0
+      facade_area = typical_length_facade_area
+      until (length_area + facade_area >= target_party_wall_area) || (length_counter == args['num_stories_above_grade'].ceil * 2)
+        # update facade area for top story
+        if length_counter == args['num_stories_above_grade'].ceil - 1 || length_counter == args['num_stories_above_grade'].ceil * 2 - 1
+          facade_area = top_story_length_facade_area
+        else
+          facade_area = typical_length_facade_area
+        end
+
+        length_counter += 1
+        length_area += facade_area
+      end
+      length_area_remainder = target_party_wall_area - length_area
+
+      # get rotation and best fit to adjust orientation for fraction party wall
+      rotation = args['building_rotation'] % 360.0 # should result in value between 0 and 360
+      card_dir_array = [0.0, 90.0, 180.0, 270.0, 360.0]
+      # reverse array to properly handle 45, 135, 225, and 315
+      best_fit = card_dir_array.reverse.min_by { |x| (x.to_f - rotation).abs }
+
+      if ![90.0, 270.0].include? best_fit
+        width_card_dir = ['east', 'west']
+        length_card_dir = ['north', 'south']
+      else # if rotation is closest to 90 or 270 then reverse which orientation is used for length and width
+        width_card_dir = ['north', 'south']
+        length_card_dir = ['east', 'west']
+      end
+
+      # if dont' find enough on short sides
+      if width_area_remainder <= typical_length_facade_area
+
+        num_stories_round_up.times do |i|
+          if i + 1 <= args['num_stories_below_grade']
+            party_walls_array << []
+            next
+          end
+          if i + 1 - args['num_stories_below_grade'] <= width_counter
+            if i + 1 - args['num_stories_below_grade'] <= width_counter - args['num_stories_above_grade']
+              party_walls_array << width_card_dir
+            else
+              party_walls_array << [width_card_dir.first]
+            end
+          else
+            party_walls_array << []
+          end
+        end
+
+      else # use long sides instead
+
+        num_stories_round_up.times do |i|
+          if i + 1 <= args['num_stories_below_grade']
+            party_walls_array << []
+            next
+          end
+          if i + 1 - args['num_stories_below_grade'] <= length_counter
+            if i + 1 - args['num_stories_below_grade'] <= length_counter - args['num_stories_above_grade']
+              party_walls_array << length_card_dir
+            else
+              party_walls_array << [length_card_dir.first]
+            end
+          else
+            party_walls_array << []
+          end
+        end
+
+      end
+
+      # TODO: - currently won't go past making two opposing sets of walls party walls. Info and registerValue are after create_bar in measure.rb
+
+    end
+
+    # populate bar hash with story information
+    bar_hash[:stories] = {}
+    num_stories_round_up.times do |i|
+      if party_walls_array.empty?
+        party_walls = []
+      else
+        party_walls = party_walls_array[i]
+      end
+
+      # add below_partial_story
+      if num_stories.ceil > num_stories && i == num_stories_round_up - 2
+        below_partial_story = true
+      else
+        below_partial_story = false
+      end
+
+      # bottom_story_ground_exposed_floor and top_story_exterior_exposed_roof already setup as bool
+      bar_hash[:stories]["key #{i}"] = { story_party_walls: party_walls, story_min_multiplier: 1, story_included_in_building_area: true, below_partial_story: below_partial_story, bottom_story_ground_exposed_floor: args['bottom_story_ground_exposed_floor'], top_story_exterior_exposed_roof: args['top_story_exterior_exposed_roof'] }
+    end
+
+    # create bar
+    new_spaces = create_bar(runner, model, bar_hash, args['story_multiplier'])
+
+    # check expect roof and wall area
+    target_footprint = bar_hash[:length] * bar_hash[:width]
+    ground_floor_area = 0.0
+    roof_area = 0.0
+    new_spaces.each do |space|
+      space.surfaces.each do |surface|
+        if surface.surfaceType == "Floor" && surface.outsideBoundaryCondition == "Ground"
+          ground_floor_area += surface.netArea
+        elsif surface.surfaceType == "RoofCeiling" && surface.outsideBoundaryCondition == "Outdoors"
+          roof_area += surface.netArea
+        end
+      end
+    end
+    # todo - extend to address when top and or bottom story are not exposed via argument
+    if ground_floor_area > target_footprint + 0.001 || roof_area > target_footprint + 0.001
+      #runner.registerError("Ground exposed floor or Roof area is larger than footprint, likely inter-floor surface matching and intersection error.")
+      #return false
+
+      # not providing adiabatic work around when top story is partial story.
+      if args['num_stories_above_grade'].to_f != args['num_stories_above_grade'].ceil
+        runner.registerError("Ground exposed floor or Roof area is larger than footprint, likely inter-floor surface matching and intersection error.")
+        return false
+      else
+        runner.registerInfo("Ground exposed floor or Roof area is larger than footprint, likely inter-floor surface matching and intersection error, altering impacted surfaces boundary condition to be adiabatic.")
+        match_error = true
+      end
+    else
+      match_error = false
+    end
+
+    # todo - should be able to remove this fix after OpenStudio intersection issue is fixed. At that time turn the above message into an error with return false after it
+    if match_error
+
+      # identify z value of top and bottom story
+      bottom_story = nil
+      top_story = nil
+      new_spaces.each do |space|
+        story = space.buildingStory.get
+        nom_z = story.nominalZCoordinate.get
+        if bottom_story.nil?
+          bottom_story = nom_z
+        elsif bottom_story > nom_z
+          bottom_story = nom_z
+        end
+        if top_story.nil?
+          top_story = nom_z
+        elsif top_story < nom_z
+          top_story = nom_z
+        end
+      end
+
+      # change boundary condition and intersection as needed.
+      new_spaces.each do |space|
+        if space.buildingStory.get.nominalZCoordinate.get > bottom_story
+          # change floors
+          space.surfaces.each do |surface|
+            next if not surface.surfaceType == "Floor" && surface.outsideBoundaryCondition == "Ground"
+            surface.setOutsideBoundaryCondition("Adiabatic")
+          end
+        end
+        if space.buildingStory.get.nominalZCoordinate.get < top_story
+          # change ceilings
+          space.surfaces.each do |surface|
+            next if not surface.surfaceType == "RoofCeiling" && surface.outsideBoundaryCondition == "Outdoors"
+            surface.setOutsideBoundaryCondition("Adiabatic")
+          end
+        end
+      end
+
+    end
+
+
+  end
+
+  # bar_from_building_type_ratios
+  # used for varieties of measures that create bar from building type ratios
+  def bar_from_building_type_ratios(model, runner, user_arguments)
+
+    # assign the user inputs to variables
+    args = OsLib_HelperMethods.createRunVariables(runner, model, user_arguments, arguments(model))
+    if !args then return false end
+
+    # add in arguments that may not be passed in
+    if !args.has_key?("double_loaded_corridor")
+      args["double_loaded_corridor"] = "None" # use None when not in measure building type data may not contain this
+    end
+    if ! args.has_key?("perim_mult")
+      args["perim_mult"] = 1.0 # will not make two bars for extended perimeter
+    end
+
+    # lookup and replace argument values from upstream measures
+    if args['use_upstream_args'] == true
+      args.each do |arg, value|
+        next if arg == 'use_upstream_args' # this argument should not be changed
+        value_from_osw = OsLib_HelperMethods.check_upstream_measure_for_arg(runner, arg)
+        if !value_from_osw.empty?
+          runner.registerInfo("Replacing argument named #{arg} from current measure with a value of #{value_from_osw[:value]} from #{value_from_osw[:measure_name]}.")
+          new_val = value_from_osw[:value]
+          # TODO: - make code to handle non strings more robust. check_upstream_measure_for_arg could pass back the argument type
+          if arg == 'total_bldg_floor_area'
+            args[arg] = new_val.to_f
+          elsif arg == 'num_stories_above_grade'
+            args[arg] = new_val.to_f
+          elsif arg == 'zipcode'
+            args[arg] = new_val.to_i
+          else
+            args[arg] = new_val
+          end
+        end
+      end
+    end
+
+    # check expected values of double arguments
+    fraction_args = ['bldg_type_b_fract_bldg_area',
+                     'bldg_type_c_fract_bldg_area',
+                     'bldg_type_d_fract_bldg_area',
+                     'wwr', 'party_wall_fraction']
+    fraction = OsLib_HelperMethods.checkDoubleAndIntegerArguments(runner, user_arguments, 'min' => 0.0, 'max' => 1.0, 'min_eq_bool' => true, 'max_eq_bool' => true, 'arg_array' => fraction_args)
+
+    positive_args = ['total_bldg_floor_area']
+    positive = OsLib_HelperMethods.checkDoubleAndIntegerArguments(runner, user_arguments, 'min' => 0.0, 'max' => nil, 'min_eq_bool' => false, 'max_eq_bool' => false, 'arg_array' => positive_args)
+
+    one_or_greater_args = ['num_stories_above_grade']
+    one_or_greater = OsLib_HelperMethods.checkDoubleAndIntegerArguments(runner, user_arguments, 'min' => 1.0, 'max' => nil, 'min_eq_bool' => true, 'max_eq_bool' => false, 'arg_array' => one_or_greater_args)
+
+    non_neg_args = ['num_stories_below_grade',
+                    'floor_height',
+                    'ns_to_ew_ratio',
+                    'party_wall_stories_north',
+                    'party_wall_stories_south',
+                    'party_wall_stories_east',
+                    'party_wall_stories_west',
+                    'single_floor_area',
+                    'bar_width',]
+    non_neg = OsLib_HelperMethods.checkDoubleAndIntegerArguments(runner, user_arguments, 'min' => 0.0, 'max' => nil, 'min_eq_bool' => true, 'max_eq_bool' => false, 'arg_array' => non_neg_args)
+
+    # return false if any errors fail
+    if !fraction then return false end
+    if !positive then return false end
+    if !one_or_greater then return false end
+    if !non_neg then return false end
+
+    # if aspect ratio, story height or wwr have argument value of 0 then use smart building type defaults
+    building_form_defaults = building_form_defaults(args['bldg_type_a'])
+
+    # store list of defaulted items
+    defaulted_args = []
+
+    if args['ns_to_ew_ratio'] == 0.0
+      args['ns_to_ew_ratio'] = building_form_defaults[:aspect_ratio]
+      runner.registerInfo("0.0 value for aspect ratio will be replaced with smart default for #{args['bldg_type_a']} of #{building_form_defaults[:aspect_ratio]}.")
+    end
+
+    if args['perim_mult'] == 0.0
+      # if this is not defined then use default of 1.0
+      if !building_form_defaults.has_key?(:perim_mult)
+        args['perim_mult'] = 1.0
+      else
+        args['perim_mult'] = building_form_defaults[:perim_mult]
+      end
+      runner.registerInfo("0.0 value for minimum perimeter multiplier will be replaced with smart default for #{args['bldg_type_a']} of #{building_form_defaults[:perim_mult]}.")
+    elsif args['perim_mult'] < 1.0
+      runner.registerError("Other than the smart default value of 0, the minimum perimeter multiplier should be equal to 1.0 or greater.")
+      return false
+    end
+
+    if args['floor_height'] == 0.0
+      args['floor_height'] = building_form_defaults[:typical_story]
+      runner.registerInfo("0.0 value for floor height will be replaced with smart default for #{args['bldg_type_a']} of #{building_form_defaults[:typical_story]}.")
+      defaulted_args << 'floor_height'
+    end
+    # because of this can't set wwr to 0.0. If that is desired then we can change this to check for 1.0 instead of 0.0
+    if args['wwr'] == 0.0
+      args['wwr'] = building_form_defaults[:wwr]
+      runner.registerInfo("0.0 value for window to wall ratio will be replaced with smart default for #{args['bldg_type_a']} of #{building_form_defaults[:wwr]}.")
+    end
+
+    # check that sum of fractions for b,c, and d is less than 1.0 (so something is left for primary building type)
+    bldg_type_a_fract_bldg_area = 1.0 - args['bldg_type_b_fract_bldg_area'] - args['bldg_type_c_fract_bldg_area'] - args['bldg_type_d_fract_bldg_area']
+    if bldg_type_a_fract_bldg_area <= 0.0
+      runner.registerError('Primary Building Type fraction of floor area must be greater than 0. Please lower one or more of the fractions for Building Type B-D.')
+      return false
+    end
+
+    # Make the standard applier
+    standard = Standard.build("#{args['template']}")
+
+    # report initial condition of model
+    runner.registerInitialCondition("The building started with #{model.getSpaces.size} spaces.")
+
+    # determine of ns_ew needs to be mirrored
+    mirror_ns_ew = false
+    rotation = model.getBuilding.northAxis
+    if rotation > 45.0 && rotation < 135.0
+      mirror_ns_ew = true
+    elsif rotation > 45.0 && rotation < 135.0
+      mirror_ns_ew = true
+    end
+
+    # remove non-resource objects not removed by removing the building
+    remove_non_resource_objects(runner, model)
+
+    # rename building to infer template in downstream measure
+    name_array = [args['template'], args['bldg_type_a']]
+    if args['bldg_type_b_fract_bldg_area'] > 0 then name_array << args['bldg_type_b'] end
+    if args['bldg_type_c_fract_bldg_area'] > 0 then name_array << args['bldg_type_c'] end
+    if args['bldg_type_d_fract_bldg_area'] > 0 then name_array << args['bldg_type_d'] end
+    model.getBuilding.setName(name_array.join('|').to_s)
+
+    # hash to whole building type data
+    building_type_hash = {}
+
+    # gather data for bldg_type_a
+    building_type_hash[args['bldg_type_a']] = {}
+    building_type_hash[args['bldg_type_a']][:frac_bldg_area] = bldg_type_a_fract_bldg_area
+    #building_type_hash[args['bldg_type_a']][:num_units] = args['bldg_type_a_num_units']
+    building_type_hash[args['bldg_type_a']][:space_types] = get_space_types_from_building_type(args['bldg_type_a'], args['template'], true)
+
+    # gather data for bldg_type_b
+    if args['bldg_type_b_fract_bldg_area'] > 0
+      building_type_hash[args['bldg_type_b']] = {}
+      building_type_hash[args['bldg_type_b']][:frac_bldg_area] = args['bldg_type_b_fract_bldg_area']
+      #building_type_hash[args['bldg_type_b']][:num_units] = args['bldg_type_b_num_units']
+      building_type_hash[args['bldg_type_b']][:space_types] = get_space_types_from_building_type(args['bldg_type_b'], args['template'], true)
+    end
+
+    # gather data for bldg_type_c
+    if args['bldg_type_c_fract_bldg_area'] > 0
+      building_type_hash[args['bldg_type_c']] = {}
+      building_type_hash[args['bldg_type_c']][:frac_bldg_area] = args['bldg_type_c_fract_bldg_area']
+      #building_type_hash[args['bldg_type_c']][:num_units] = args['bldg_type_c_num_units']
+      building_type_hash[args['bldg_type_c']][:space_types] = get_space_types_from_building_type(args['bldg_type_c'], args['template'], true)
+    end
+
+    # gather data for bldg_type_d
+    if args['bldg_type_d_fract_bldg_area'] > 0
+      building_type_hash[args['bldg_type_d']] = {}
+      building_type_hash[args['bldg_type_d']][:frac_bldg_area] = args['bldg_type_d_fract_bldg_area']
+      #building_type_hash[args['bldg_type_d']][:num_units] = args['bldg_type_d_num_units']
+      building_type_hash[args['bldg_type_d']][:space_types] = get_space_types_from_building_type(args['bldg_type_d'], args['template'], true)
+    end
+
+    # creating space types for requested building types
+    building_type_hash.each do |building_type, building_type_hash|
+      runner.registerInfo("Creating Space Types for #{building_type}.")
+
+      # mapping building_type name is needed for a few methods
+      building_type = standard.model_get_lookup_name(building_type)
+
+      # create space_type_map from array
+      sum_of_ratios = 0.0
+      building_type_hash[:space_types] = building_type_hash[:space_types].sort_by { |k, v| v[:ratio] }.to_h
+      building_type_hash[:space_types].each do |space_type_name, hash|
+        next if hash[:space_type_gen] == false # space types like undeveloped and basement are skipped.
+
+        # create space type
+        space_type = OpenStudio::Model::SpaceType.new(model)
+        space_type.setStandardsBuildingType(building_type)
+        space_type.setStandardsSpaceType(space_type_name)
+        space_type.setName("#{building_type} #{space_type_name}")
+
+        # set color
+        test = standard.space_type_apply_rendering_color(space_type) # this uses openstudio-standards
+        if !test
+          # todo - once fixed in standards un-comment this
+          #runner.registerWarning("Could not find color for #{args['template']} #{space_type.name}")
+        end
+
+        # extend hash to hold new space type object
+        hash[:space_type] = space_type
+
+        # add to sum_of_ratios counter for adjustment multiplier
+        sum_of_ratios += hash[:ratio]
+      end
+
+      # store multiplier needed to adjust sum of ratios to equal 1.0
+      building_type_hash[:ratio_adjustment_multiplier] = 1.0 / sum_of_ratios
+    end
+
+    # calculate length and with of bar
+    total_bldg_floor_area_si = OpenStudio.convert(args['total_bldg_floor_area'], 'ft^2', 'm^2').get
+    single_floor_area_si = OpenStudio.convert(args['single_floor_area'], 'ft^2', 'm^2').get
+
+    # store number of stories
+    num_stories = args['num_stories_below_grade'] + args['num_stories_above_grade']
+
+    # handle user-assigned single floor plate size condition
+    if args['single_floor_area'] > 0.0
+      footprint_si = single_floor_area_si
+      total_bldg_floor_area_si = footprint_si * num_stories.to_f
+      runner.registerWarning('User-defined single floor area was used for calculation of total building floor area')
+      # add warning if custom_height_bar is true and applicable building type is selected
+      if args['custom_height_bar']
+        runner.registerWarning("Cannot use custom height bar with single floor area method, will not create custom height bar.")
+        args['custom_height_bar'] = false
+      end
+    else
+      footprint_si = nil
+    end
+
+    # populate space_types_hash
+    space_types_hash = {}
+    multi_height_space_types_hash = {}
+    custom_story_heights = []
+    if args['space_type_sort_logic'] == 'Building Type > Size'
+      building_type_hash = building_type_hash.sort_by { |k, v| v[:frac_bldg_area] }
+    end
+    building_type_hash.each do |building_type, building_type_hash|
+
+      if args["double_loaded_corridor"] == "Primary Space Type"
+
+        # see if building type has circulation space type, if so then merge that along with default space type into hash key in place of space type
+        default_st = nil
+        circ_st = nil
+        building_type_hash[:space_types].each do |space_type_name, hash|
+          if hash[:default] then default_st = space_type_name end
+          if hash[:circ] then circ_st = space_type_name end
+        end
+
+        # update building hash
+        if !default_st.nil? && !circ_st.nil?
+          runner.registerInfo("Combining #{default_st} and #{circ_st} into a group representing a double loaded corridor")
+
+          # add new item
+          building_type_hash[:space_types]["Double Loaded Corridor"] = {}
+          double_loaded_st = building_type_hash[:space_types]["Double Loaded Corridor"]
+          double_loaded_st[:ratio] = building_type_hash[:space_types][default_st][:ratio] + building_type_hash[:space_types][circ_st][:ratio]
+          double_loaded_st[:double_loaded_corridor] = true
+          double_loaded_st[:space_type] = model.getBuilding
+          double_loaded_st[:children] = {}
+          building_type_hash[:space_types][default_st][:orig_ratio] = building_type_hash[:ratio_adjustment_multiplier] * building_type_hash[:frac_bldg_area] * building_type_hash[:space_types][default_st][:ratio]
+          building_type_hash[:space_types][circ_st][:orig_ratio] = building_type_hash[:ratio_adjustment_multiplier] * building_type_hash[:frac_bldg_area] * building_type_hash[:space_types][circ_st][:ratio]
+          building_type_hash[:space_types][default_st][:name] = default_st
+          building_type_hash[:space_types][circ_st][:name] = circ_st
+          double_loaded_st[:children][:default] = building_type_hash[:space_types][default_st]
+          double_loaded_st[:children][:circ] = building_type_hash[:space_types][circ_st]
+          double_loaded_st[:orig_ratio] = 0.0
+
+          # zero out ratios from old item (don't delete because I still want the space types made)
+          building_type_hash[:space_types][default_st][:ratio] = 0.0
+          building_type_hash[:space_types][circ_st][:ratio] = 0.0
+        end
+      end
+
+      building_type_hash[:space_types].each do |space_type_name, hash|
+        next if hash[:space_type_gen] == false
+
+        space_type = hash[:space_type]
+        ratio_of_bldg_total = hash[:ratio] * building_type_hash[:ratio_adjustment_multiplier] * building_type_hash[:frac_bldg_area]
+        final_floor_area = ratio_of_bldg_total * total_bldg_floor_area_si # I think I can just pass ratio but passing in area is cleaner
+
+        # only add custom height space if 0 is used for floor_height
+        if defaulted_args.include?('floor_height') && hash.key?(:story_height) && args['custom_height_bar']
+          multi_height_space_types_hash[space_type] = { floor_area: final_floor_area, space_type: space_type, story_height: hash[:story_height] }
+          if hash.key?(:orig_ratio) then multi_height_space_types_hash[space_type][:orig_ratio] = hash[:orig_ratio] end
+          custom_story_heights << hash[:story_height]
+          if args['wwr'] == 0 && hash.key?(:wwr)
+            multi_height_space_types_hash[space_type][:wwr] = hash[:wwr]
+          end
+        else
+           # only add wwr if 0 used for wwr arg and if space type has wwr as key
+           space_types_hash[space_type] = { floor_area: final_floor_area, space_type: space_type }
+           if hash.key?(:orig_ratio) then space_types_hash[space_type][:orig_ratio] = hash[:orig_ratio] end
+           if args['wwr'] == 0 && hash.key?(:wwr)
+             space_types_hash[space_type][:wwr] = hash[:wwr]
+           end
+           if hash[:double_loaded_corridor]
+             space_types_hash[space_type][:children] = hash[:children]
+           end
+        end
+      end
+    end
+
+    # resort if not sorted by building type
+    if args['space_type_sort_logic'] == "Size"
+      # added code to convert to hash. I use sort_by 3 other times, but those seem to be working fine as is now.
+      space_types_hash = Hash[space_types_hash.sort_by { |k, v| v[:floor_area] }]
+    end
+
+    # calculate targets for testing
+    target_areas = {} # used for checks
+    target_areas_cust_height = 0.0
+    space_types_hash.each do |k,v|
+      if v.key?(:orig_ratio)
+        target_areas[k] = v[:orig_ratio] * total_bldg_floor_area_si
+      else
+        target_areas[k] = v[:floor_area]
+      end
+    end
+    multi_height_space_types_hash.each do |k,v|
+      if v.key?(:orig_ratio)
+        target_areas[k] = v[:orig_ratio] * total_bldg_floor_area_si
+        target_areas_cust_height += v[:orig_ratio] * total_bldg_floor_area_si
+      else
+        target_areas[k] = v[:floor_area]
+        target_areas_cust_height += v[:floor_area]
+      end
+    end
+
+    # gather inputs
+    if footprint_si.nil?
+      footprint_si = (total_bldg_floor_area_si - target_areas_cust_height) / num_stories.to_f
+    end
+    floor_height_si = OpenStudio.convert(args['floor_height'], 'ft', 'm').get
+    min_allow_size = OpenStudio.convert(15.0,'ft','m').get
+    specified_bar_width_si = OpenStudio.convert(args['bar_width'],'ft','m').get
+
+    # set custom width
+    if specified_bar_width_si > 0
+      runner.registerInfo("Ignoring perimeter multiplier argument when non zero width argument is used")
+      if footprint_si / specified_bar_width_si >= min_allow_size
+        width = specified_bar_width_si
+        length = footprint_si / width
+      else
+        length = min_allow_size
+        width = footprint_si / length
+        runner.registerWarning("User specified width results in a length that is too short, adjusting width to be narrower than specified.")
+      end
+      width_cust_height = specified_bar_width_si
+    else
+      width = Math.sqrt(footprint_si / args['ns_to_ew_ratio'])
+      length = footprint_si / width
+      width_cust_height = Math.sqrt(target_areas_cust_height / args['ns_to_ew_ratio'])
+    end
+    length_cust_height = target_areas_cust_height / width_cust_height
+    if args['perim_mult'] > 1.0 && target_areas_cust_height > 0.0
+      # todo - update tests that hit this warning
+      runner.registerWarning("Ignoring perimeter multiplier for bar that represents custom height spaces.")
+    end
+
+    # check if dual bar is needed
+    dual_bar = false
+    if specified_bar_width_si > 0.0 && args['bar_division_method'] == 'Multiple Space Types - Individual Stories Sliced'
+      if length/width != args['ns_to_ew_ratio']
+
+        if args['ns_to_ew_ratio'] >= 1.0 && args['ns_to_ew_ratio'] > length/width
+          runner.registerWarning("Can't meet target aspect ratio of #{args['ns_to_ew_ratio']}, Lowering it to #{length/width} ")
+          args['ns_to_ew_ratio'] = length/width
+        elsif args['ns_to_ew_ratio'] < 1.0 && args['ns_to_ew_ratio'] > length/width
+          runner.registerWarning("Can't meet target aspect ratio of #{args['ns_to_ew_ratio']}, Increasing it to #{length/width} ")
+          args['ns_to_ew_ratio'] = length/width
+        else
+          # check if each bar would be longer then 15 feet, then set as dual bar and override perimeter multiplier
+          length_alt1 = ((args['ns_to_ew_ratio'] * footprint_si) / width + 2 * args['ns_to_ew_ratio'] * width - 2 * width)/(1 + args['ns_to_ew_ratio'])
+          length_alt2 = length - length_alt1
+          if [length_alt1,length_alt2].min >= min_allow_size
+            dual_bar = true
+          else
+            runner.registerInfo("Second bar would be below minimum length, will model as single bar")
+            # swap length and width if single bar and aspect ratio less than 1
+            if args['ns_to_ew_ratio'] < 1.0
+              width = length
+              length = specified_bar_width_si
+            end
+          end
+        end
+      end
+    elsif args['perim_mult'] > 1.0 && args['bar_division_method'] == 'Multiple Space Types - Individual Stories Sliced'
+      runner.registerInfo("You selected a perimeter multiplier greater than 1.0 for a supported bar division method. This will result in two detached rectangular buildings if secondary bar meets minimum size requirements.")
+      dual_bar = true
+    elsif args['perim_mult'] > 1.0
+      runner.registerWarning("You selected a perimeter multiplier greater than 1.0 but didn't select a bar division method that supports this. The value for this argument will be ignored by the measure")
+    end
+
+    # calculations for dual bar, which later will be setup to run create_bar twice
+    if dual_bar
+      min_perim = 2 * width + 2 * length
+      target_area = footprint_si
+      target_perim = min_perim * args['perim_mult']
+      tol_testing = 0.00001
+      dual_bar_calc_approach = nil # stretched, adiabatic_ends_bar_b, dual_bar
+      runner.registerInfo("Minimum rectangle is #{OpenStudio.toNeatString(OpenStudio.convert(length, 'm', 'ft').get, 0, true)} ft x #{OpenStudio.toNeatString(OpenStudio.convert(width, 'm', 'ft').get, 0, true)} ft with an area of #{OpenStudio.toNeatString(OpenStudio.convert(length * width, 'm^2', 'ft^2').get, 0, true)} ft^2. Perimeter is #{OpenStudio.toNeatString(OpenStudio.convert(min_perim, 'm', 'ft').get, 0, true)} ft.")
+      runner.registerInfo("Target dual bar perimeter is #{OpenStudio.toNeatString(OpenStudio.convert(target_perim, 'm', 'ft').get, 0, true)} ft.")
+
+      # determine which of the three paths to hit target perimeter multiplier are possible
+      # A use dual bar non adiabatic
+      # B use dual bar adiabatic
+      # C use stretched bar (requires model to miss ns/ew ratio)
+
+      # custom quadratic equation to solve two bars with common width 2l^2 - p*l + 4a = 0
+      if target_perim**2 - 32 * footprint_si > 0
+        if specified_bar_width_si > 0
+          runner.registerInfo("Ignoring perimeter multiplier argument and using use specified bar width.")
+          dual_double_end_width = specified_bar_width_si
+          dual_double_end_length = footprint_si / dual_double_end_width
+        else
+          dual_double_end_length = 0.25 * (target_perim + Math.sqrt(target_perim**2 - 32 * footprint_si))
+          dual_double_end_width = footprint_si / dual_double_end_length
+        end
+
+        # now that stretched  bar is made, determine where to split it and rotate
+        bar_a_length = (args['ns_to_ew_ratio'] * (dual_double_end_length + dual_double_end_width) - dual_double_end_width)/(1 + args['ns_to_ew_ratio'])
+        bar_b_length = dual_double_end_length - bar_a_length
+        area_a = bar_a_length * dual_double_end_width
+        area_b = bar_b_length * dual_double_end_width
+      else
+        # this will throw it to adiabatic ends test
+        bar_a_length = 0
+        bar_b_length = 0
+      end
+
+      if bar_a_length >= min_allow_size && bar_b_length >= min_allow_size
+        dual_bar_calc_approach = 'dual_bar'
+      else
+        # adiabatic bar input calcs
+        if target_perim**2 - 16 * footprint_si > 0
+          adiabatic_dual_double_end_length = 0.25 * (target_perim + Math.sqrt(target_perim**2 - 16 * footprint_si))
+          adiabatic_dual_double_end_width = footprint_si / adiabatic_dual_double_end_length
+          # test for unexpected
+          unexpected = false
+          if (target_area - adiabatic_dual_double_end_length*adiabatic_dual_double_end_width).abs > tol_testing then unexpected = true end
+          if specified_bar_width_si == 0
+            if (target_perim - (adiabatic_dual_double_end_length * 2 + adiabatic_dual_double_end_width * 2)).abs > tol_testing then unexpected = true end
+          end
+          if unexpected
+            runner.registerWarning("Unexpected values for dual rectangle adiabatic ends bar b.")
+          end
+          # now that stretched  bar is made, determine where to split it and rotate
+          adiabatic_bar_a_length = (args['ns_to_ew_ratio'] * (adiabatic_dual_double_end_length + adiabatic_dual_double_end_width))/(1 + args['ns_to_ew_ratio'])
+          adiabatic_bar_b_length = adiabatic_dual_double_end_length - adiabatic_bar_a_length
+          adiabatic_area_a = adiabatic_bar_a_length * adiabatic_dual_double_end_width
+          adiabatic_area_b = adiabatic_bar_b_length * adiabatic_dual_double_end_width
+        else
+          # this will throw it stretched single bar
+          adiabatic_bar_a_length = 0
+          adiabatic_bar_b_length = 0
+        end
+        if adiabatic_bar_a_length >= min_allow_size && adiabatic_bar_b_length >= min_allow_size
+          dual_bar_calc_approach = 'adiabatic_ends_bar_b'
+        else
+          dual_bar_calc_approach = 'stretched'
+        end
+      end
+
+      # apply prescribed approach for stretched or dual bar
+      if dual_bar_calc_approach == 'dual_bar'
+        runner.registerInfo("Stretched  #{OpenStudio.toNeatString(OpenStudio.convert(dual_double_end_length, 'm', 'ft').get, 0, true)} ft x #{OpenStudio.toNeatString(OpenStudio.convert(dual_double_end_width, 'm', 'ft').get, 0, true)} ft rectangle has an area of #{OpenStudio.toNeatString(OpenStudio.convert(dual_double_end_length * dual_double_end_width, 'm^2', 'ft^2').get, 0, true)} ft^2. When split in two the perimeter will be #{OpenStudio.toNeatString(OpenStudio.convert(dual_double_end_length * 2 + dual_double_end_width * 4, 'm', 'ft').get, 0, true)} ft")
+        if (target_area - dual_double_end_length*dual_double_end_width).abs > tol_testing || (target_perim - (dual_double_end_length * 2 + dual_double_end_width * 4)).abs > tol_testing
+          runner.registerWarning("Unexpected values for dual rectangle.")
+        end
+
+        runner.registerInfo("For stretched split bar, to match target ns/ew aspect ratio #{OpenStudio.toNeatString(OpenStudio.convert(bar_a_length, 'm', 'ft').get, 0, true)} ft of bar should be horizontal, with #{OpenStudio.toNeatString(OpenStudio.convert(bar_b_length, 'm', 'ft').get, 0, true)} ft turned 90 degrees. Combined area is #{OpenStudio.toNeatString(OpenStudio.convert(area_a + area_b, 'm^2', 'ft^2').get, 0, true)} ft^2. Combined perimeter is #{OpenStudio.toNeatString(OpenStudio.convert(bar_a_length*2 + bar_b_length*2 + dual_double_end_width*4, 'm', 'ft').get, 0, true)} ft")
+        if (target_area - (area_a + area_b)).abs > tol_testing || (target_perim - (bar_a_length*2 + bar_b_length*2 + dual_double_end_width*4)).abs > tol_testing
+          runner.registerWarning("Unexpected values for rotated dual rectangle")
+        end
+      elsif dual_bar_calc_approach == 'adiabatic_ends_bar_b'
+        runner.registerInfo("Can't hit target perimeter with two rectangles, need to make two ends adiabatic")
+
+        runner.registerInfo("For dual bar with adiabatic ends on bar b, to reach target aspect ratio #{OpenStudio.toNeatString(OpenStudio.convert(adiabatic_bar_a_length, 'm', 'ft').get, 0, true)} ft of bar should be north/south, with #{OpenStudio.toNeatString(OpenStudio.convert(adiabatic_bar_b_length, 'm', 'ft').get, 0, true)} ft turned 90 degrees. Combined area is #{OpenStudio.toNeatString(OpenStudio.convert(adiabatic_area_a + adiabatic_area_b, 'm^2', 'ft^2').get, 0, true)} ft^2}. Combined perimeter is #{OpenStudio.toNeatString(OpenStudio.convert(adiabatic_bar_a_length*2 + adiabatic_bar_b_length*2 + adiabatic_dual_double_end_width*2, 'm', 'ft').get, 0, true)} ft")
+        if (target_area - (adiabatic_area_a + adiabatic_area_b)).abs > tol_testing || (target_perim - (adiabatic_bar_a_length*2 + adiabatic_bar_b_length*2 + adiabatic_dual_double_end_width*2)).abs > tol_testing
+          runner.registerWarning("Unexpected values for rotated dual rectangle adiabatic ends bar b")
+        end
+      else # stretched bar
+        dual_bar = false
+
+        stretched_length = 0.25 * (target_perim + Math.sqrt(target_perim**2 - 16 * footprint_si))
+        stretched_width = footprint_si / stretched_length
+        if (target_area - stretched_length*stretched_width).abs > tol_testing || (target_perim - (stretched_length + stretched_width)*2) > tol_testing
+          runner.registerWarning("Unexpected values for single stretched")
+        end
+
+        width = stretched_width
+        length = stretched_length
+        runner.registerInfo("Creating a dual bar to match the target minimum perimeter multiplier at the given aspect ratio would result in a bar with edge shorter than #{OpenStudio.toNeatString(OpenStudio.convert(min_allow_size, 'm', 'ft').get, 0, true)} ft. Will create a single stretched bar instead that hits the target perimeter with a slightly different ns/ew aspect ratio.")
+      end
+    end
+
+    bars = {}
+    bars['primary'] = {}
+    if dual_bar
+      if mirror_ns_ew && dual_bar_calc_approach == 'dual_bar'
+        bars['primary'][:length] = dual_double_end_width
+        bars['primary'][:width] = bar_a_length
+      elsif dual_bar_calc_approach == 'dual_bar'
+        bars['primary'][:length] = bar_a_length
+        bars['primary'][:width] = dual_double_end_width
+      elsif mirror_ns_ew
+        bars['primary'][:length] = adiabatic_dual_double_end_width
+        bars['primary'][:width] = adiabatic_bar_a_length
+      else
+        bars['primary'][:length] = adiabatic_bar_a_length
+        bars['primary'][:width] = adiabatic_dual_double_end_width
+      end
+    else
+      if mirror_ns_ew
+        bars['primary'][:length] = width
+        bars['primary'][:width] = length
+      else
+        bars['primary'][:length] = length
+        bars['primary'][:width] = width
+      end
+    end
+    bars['primary'][:floor_height_si] = floor_height_si # can make use of this when breaking out multi-height spaces
+    bars['primary'][:num_stories] = num_stories
+    bars['primary'][:center_of_footprint] = OpenStudio::Point3d.new(0.0,0.0,0.0)
+    space_types_hash_secondary = {}
+    if dual_bar
+      # loop through each story and move portion for other bar to its own hash
+      primary_footprint = bars['primary'][:length] * bars['primary'][:width]
+      secondary_footprint = target_area - primary_footprint
+      footprint_counter = primary_footprint
+      secondary_footprint_counter = secondary_footprint
+      story_counter = 0
+      pri_sec_tol = 0.0001 #m^2
+      pri_sec_min_area = 0.0001 #m^2
+      space_types_hash.each do |k,v|
+        space_type_left = v[:floor_area]
+
+        # do not go to next space type until this one is evaulate, which may span stories
+        until space_type_left == 0.0 || story_counter >= num_stories
+
+          # use secondary footprint if any left
+          if secondary_footprint_counter > 0.0
+            hash_area = [space_type_left,secondary_footprint_counter].min
+
+            # confirm that the part of space type use or what is left is greater than min allowed value
+            projected_space_type_left = space_type_left - hash_area
+            test_a = if hash_area >= pri_sec_min_area then true else false end
+            test_b = if projected_space_type_left >= pri_sec_min_area || projected_space_type_left == 0.0 then true else false end
+            test_c = if k == space_types_hash.keys.last then true else false end # if last space type accept sliver, no other space to infil
+            if (test_a && test_b) || test_c
+              if space_types_hash_secondary.has_key?(k)
+                # add to what was added for previous story
+                space_types_hash_secondary[k][:floor_area] += hash_area
+              else
+                # add new space type to hash
+                if v.has_key?(:children)
+                  space_types_hash_secondary[k] = {:floor_area => hash_area, :space_type => v[:space_type], :children => v[:children],}
+                else
+                  space_types_hash_secondary[k] = {:floor_area => hash_area, :space_type => v[:space_type]}
+                end
+              end
+              space_types_hash[k][:floor_area] -= hash_area
+              secondary_footprint_counter -= hash_area
+              space_type_left -= hash_area
+            else
+              runner.registerInfo("Shifting space types between bars to avoid sliver of #{k.name}.")
+            end
+          end
+
+          # remove space if entirely used up by secondary bar
+          if space_types_hash[k][:floor_area] <= pri_sec_tol
+            space_types_hash.delete(k)
+            space_type_left = 0.0
+          else
+            # then look at primary bar
+            hash_area_pri = [space_type_left,footprint_counter].min
+            footprint_counter -= hash_area_pri
+            space_type_left -= hash_area_pri
+          end
+
+          # reset counter when full
+          if footprint_counter <= pri_sec_tol && secondary_footprint_counter <= pri_sec_tol
+            # check if this is partial top floor
+            story_counter += 1
+            if num_stories < story_counter + 1
+              footprint_counter = primary_footprint * (num_stories - story_counter)
+              secondary_footprint_counter = secondary_footprint * (num_stories - story_counter)
+            else
+              footprint_counter = primary_footprint
+              secondary_footprint_counter = secondary_footprint
+            end
+          end
+        end
+      end
+    end
+
+    # setup bar_hash and run create_bar
+    bars['primary'][:space_types_hash] = space_types_hash
+    bars['primary'][:args] = args
+    v = bars['primary']
+    bar_hash_setup_run(runner,model,v[:args],v[:length],v[:width],v[:floor_height_si],v[:center_of_footprint],v[:space_types_hash],v[:num_stories])
+
+    # store offset value for multiple bars
+    if args.has_key?('bar_sep_dist_mult') && args['bar_sep_dist_mult'] > 0.0
+      offset_val = num_stories.ceil * floor_height_si * args['bar_sep_dist_mult']
+    elsif args.has_key?('bar_sep_dist_mult')
+      runner.registerWarning("Positive valu eis required for bar_sep_dist_mult, ignoring input and using value of 0.1")
+      offset_val = num_stories.ceil * floor_height_si * 0.1
+    else
+      offset_val = num_stories.ceil * floor_height_si * 10.0
+    end
+
+    if dual_bar
+      args2 = args.clone
+      bars['secondary'] = {}
+      if mirror_ns_ew && dual_bar_calc_approach == 'dual_bar'
+        bars['secondary'][:length] = bar_b_length
+        bars['secondary'][:width] = dual_double_end_width
+      elsif dual_bar_calc_approach == 'dual_bar'
+        bars['secondary'][:length] = dual_double_end_width
+        bars['secondary'][:width] = bar_b_length
+      elsif mirror_ns_ew
+        bars['secondary'][:length] = adiabatic_bar_b_length
+        bars['secondary'][:width] = adiabatic_dual_double_end_width
+        args2['party_wall_stories_east'] = num_stories.ceil
+        args2['party_wall_stories_west'] = num_stories.ceil
+      else
+        bars['secondary'][:length] = adiabatic_dual_double_end_width
+        bars['secondary'][:width] = adiabatic_bar_b_length
+        args2['party_wall_stories_south'] = num_stories.ceil
+        args2['party_wall_stories_north'] = num_stories.ceil
+      end
+      bars['secondary'][:floor_height_si] = floor_height_si # can make use of this when breaking out multi-height spaces
+      bars['secondary'][:num_stories] = num_stories
+      bars['secondary'][:space_types_hash] = space_types_hash_secondary
+      if dual_bar_calc_approach == 'adiabatic_ends_bar_b'
+        # warn that combination of dual bar with low perimeter multiplier and use of party wall may result in discrepency between target and actual adiabatic walls
+        if args['party_wall_fraction'] > 0 || args['party_wall_stories_north'] > 0 || args['party_wall_stories_south'] > 0 || args['party_wall_stories_east'] > 0 || args['party_wall_stories_west'] > 0
+          runner.registerWarning('The combination of low perimeter multiplier and use of non zero party wall inputs may result in discrepency between target and actual adiabatic walls. This is due to the need to create adiabatic walls on secondary bar to maintian target building perimeter.')
+        else
+          runner.registerInfo('Adiabatic ends added to secondary bar because target perimeter multiplier could not be met with two full rectangular footprints.')
+        end
+        bars['secondary'][:center_of_footprint] = OpenStudio::Point3d.new(adiabatic_bar_a_length * 0.5 + adiabatic_dual_double_end_width * 0.5 + offset_val,adiabatic_bar_b_length * 0.5 + adiabatic_dual_double_end_width * 0.5 + offset_val,0.0)
+      else
+        bars['secondary'][:center_of_footprint] = OpenStudio::Point3d.new(bar_a_length * 0.5 + dual_double_end_width * 0.5 + offset_val,bar_b_length * 0.5 + dual_double_end_width * 0.5 + offset_val,0.0)
+      end
+      bars['secondary'][:args] = args2
+
+      # setup bar_hash and run create_bar
+      v = bars['secondary']
+      bar_hash_setup_run(runner,model,v[:args],v[:length],v[:width],v[:floor_height_si],v[:center_of_footprint],v[:space_types_hash],v[:num_stories])
+
+    end
+
+    # future development (up against primary bar run intersection and surface matching after add all bars, avoid interior windows)
+    # I could loop through each space type and give them unique height but for now will just take largest height and make bar of that height, which is fine for prototypes
+    if multi_height_space_types_hash.size > 0
+      args3 = args.clone
+      bars['custom_height'] = {}
+      if mirror_ns_ew
+        bars['custom_height'][:length] = width_cust_height
+        bars['custom_height'][:width] = length_cust_height
+      else
+        bars['custom_height'][:length] = length_cust_height
+        bars['custom_height'][:width] = width_cust_height
+      end
+      if args['party_wall_stories_east'] + args['party_wall_stories_west'] + args['party_wall_stories_south'] + args['party_wall_stories_north'] > 0.0
+        runner.registerWarning("Ignorning party wall inputs for custom height bar")
+      end
+
+      # disable party walls
+      args3['party_wall_stories_east'] = 0
+      args3['party_wall_stories_west'] = 0
+      args3['party_wall_stories_south'] = 0
+      args3['party_wall_stories_north'] = 0
+
+      # setup stories
+      args3['num_stories_below_grade'] = 0
+      args3['num_stories_above_grade'] = 1
+
+      bars['custom_height'][:floor_height_si] = floor_height_si # can make use of this when breaking out multi-height spaces
+      bars['custom_height'][:num_stories] = num_stories
+      bars['custom_height'][:center_of_footprint] = OpenStudio::Point3d.new(bars['primary'][:length] * -0.5 - length_cust_height * 0.5 - offset_val,0.0,0.0)
+      bars['custom_height'][:floor_height_si] = OpenStudio.convert(custom_story_heights.max,'ft','m').get
+      bars['custom_height'][:num_stories] = 1
+      bars['custom_height'][:space_types_hash] = multi_height_space_types_hash
+      bars['custom_height'][:args] = args3
+
+      v = bars['custom_height']
+      bar_hash_setup_run(runner,model,v[:args],v[:length],v[:width],v[:floor_height_si],v[:center_of_footprint],v[:space_types_hash],v[:num_stories])
+    end
+
+    # diagnostic log
+    sum_actual = 0.0
+    sum_target = 0.0
+    throw_error = false
+
+    # check expected floor areas against actual
+    model.getSpaceTypes.sort.each do |space_type|
+      next if !target_areas.key? space_type # space type in model not part of building type(s), maybe issue warning
+
+      # convert to IP
+      actual_ip = OpenStudio.convert(space_type.floorArea, 'm^2', 'ft^2').get
+      target_ip = OpenStudio.convert(target_areas[space_type], 'm^2', 'ft^2').get
+      sum_actual += actual_ip
+      sum_target += target_ip
+
+      if (space_type.floorArea - target_areas[space_type]).abs >= 1.0
+
+        if !args['bar_division_method'].include? 'Single Space Type'
+          runner.registerError("#{space_type.name} doesn't have the expected floor area (actual #{OpenStudio.toNeatString(actual_ip, 0, true)} ft^2, target #{OpenStudio.toNeatString(target_ip, 0, true)} ft^2)")
+          throw_error = true
+        else
+          # will see this if use Single Space type division method on multi-use building or single building type without whole building space type
+          runner.registerWarning("#{space_type.name} doesn't have the expected floor area (actual #{OpenStudio.toNeatString(actual_ip, 0, true)} ft^2, target #{OpenStudio.toNeatString(target_ip, 0, true)} ft^2)")
+        end
+
+      end
+    end
+
+    # report summary then throw error
+    if throw_error
+      runner.registerError("Sum of actual floor area is #{sum_actual} ft^2, sum of target floor area is #{sum_target}.")
+      return false
+    end
+
+    # check party wall fraction by looping through surfaces
+    if args['party_wall_fraction'] > 0
+      actual_ext_wall_area = model.getBuilding.exteriorWallArea
+      actual_party_wall_area = 0.0
+      model.getSurfaces.each do |surface|
+        next if surface.outsideBoundaryCondition != 'Adiabatic'
+        next if surface.surfaceType != 'Wall'
+        actual_party_wall_area += surface.grossArea * surface.space.get.multiplier
+      end
+      actual_party_wall_fraction = actual_party_wall_area / (actual_party_wall_area + actual_ext_wall_area)
+      runner.registerInfo("Target party wall fraction is #{args['party_wall_fraction']}. Realized fraction is #{actual_party_wall_fraction.round(2)}")
+      runner.registerValue('party_wall_fraction_actual', actual_party_wall_fraction)
+    end
+
+    # check ns/ew aspect ratio (harder to check when party walls are added)
+    wall_and_window_by_orientation = OsLib_Geometry.getExteriorWindowAndWllAreaByOrientation(model,model.getSpaces)
+    wall_ns = (wall_and_window_by_orientation['northWall'] + wall_and_window_by_orientation['southWall'])
+    wall_ew = wall_and_window_by_orientation['eastWall'] + wall_and_window_by_orientation['westWall']
+    wall_ns_ip = OpenStudio.convert(wall_ns,'m^2','ft^2').get
+    wall_ew_ip = OpenStudio.convert(wall_ew,'m^2','ft^2').get
+    runner.registerValue('wall_area_ip',wall_ns_ip + wall_ew_ip,'ft^2')
+    runner.registerValue('ns_wall_area_ip',wall_ns_ip,'ft^2')
+    runner.registerValue('ew_wall_area_ip',wall_ew_ip,'ft^2')
+    # for now using perimeter of ground floor and average story area (building area / num_stories)
+    runner.registerValue('floor_area_to_perim_ratio',model.getBuilding.floorArea /  (OsLib_Geometry.calculate_perimeter(model) * num_stories))
+    runner.registerValue('bar_width',OpenStudio.convert(bars['primary'][:width],'m','ft').get,'ft')
+
+    if args['party_wall_fraction'] > 0 || args['party_wall_stories_north'] > 0 || args['party_wall_stories_south'] > 0 || args['party_wall_stories_east'] > 0 || args['party_wall_stories_west'] > 0
+      runner.registerInfo("Target facade area by orientation not validated when party walls are applied")
+    elsif args['num_stories_above_grade'] != args['num_stories_above_grade'].ceil
+      runner.registerInfo("Target facade area by orientation not validated when partial top story is used")
+    elsif dual_bar_calc_approach == 'stretched'
+      runner.registerInfo("Target facade area by orientation not validated when single stretched bar has to be used to meet target minimum perimeter multiplier")
+    elsif defaulted_args.include?('floor_height')  && args['custom_height_bar'] && multi_height_space_types_hash.size > 0
+      runner.registerInfo("Target facade area by orientation not validated when a dedicated bar is added for space types with custom heights")
+    elsif args['bar_width'] > 0
+      runner.registerInfo("Target facade area by orientation not validated when a dedicated custom bar width is defined")
+    else
+
+      # adjust length versus width based on building rotation
+      if mirror_ns_ew
+        wall_target_ns_ip = 2 * OpenStudio.convert(width,'m','ft').get * args['perim_mult'] * args['num_stories_above_grade'] * args['floor_height']
+        wall_target_ew_ip = 2 * OpenStudio.convert(length,'m','ft').get  * args['perim_mult'] * args['num_stories_above_grade'] * args['floor_height']
+      else
+        wall_target_ns_ip = 2 * OpenStudio.convert(length,'m','ft').get * args['perim_mult'] * args['num_stories_above_grade'] * args['floor_height']
+        wall_target_ew_ip = 2 * OpenStudio.convert(width,'m','ft').get  * args['perim_mult'] * args['num_stories_above_grade'] * args['floor_height']
+      end
+      flag_error = false
+      if (wall_target_ns_ip - wall_ns_ip).abs > 0.1
+        runner.registerError("North/South walls don't have the expected area (actual #{OpenStudio.toNeatString(wall_ns_ip, 4, true)} ft^2, target #{OpenStudio.toNeatString(wall_target_ns_ip, 4, true)} ft^2)")
+        flag_error = true
+      end
+      if (wall_target_ew_ip - wall_ew_ip).abs > 0.1
+        runner.registerError("East/West walls don't have the expected area (actual #{OpenStudio.toNeatString(wall_ew_ip, 4, true)} ft^2, target #{OpenStudio.toNeatString(wall_target_ew_ip, 4, true)} ft^2)")
+        flag_error = true
+      end
+      if flag_error
+        return false
+      end
+    end
+
+    # test for excessive exterior roof area (indication of problem with intersection and or surface matching)
+    ext_roof_area = model.getBuilding.exteriorSurfaceArea - model.getBuilding.exteriorWallArea
+    expected_roof_area = args['total_bldg_floor_area'] / (args['num_stories_above_grade'] + args['num_stories_below_grade']).to_f
+    if ext_roof_area > expected_roof_area && single_floor_area_si == 0.0 # only test if using whole-building area input
+      runner.registerError('Roof area larger than expected, may indicate problem with inter-floor surface intersection or matching.')
+      return false
+    end
+
+    # set building rotation
+    initial_rotation = model.getBuilding.northAxis
+    if args['building_rotation'] != initial_rotation
+      model.getBuilding.setNorthAxis(args['building_rotation'])
+      runner.registerInfo("Set Building Rotation to #{model.getBuilding.northAxis}. Rotation altered after geometry generation is completed, as a result party wall orientation and aspect ratio may not reflect input values.")
+    end
+
+    # report final condition of model
+    runner.registerFinalCondition("The building finished with #{model.getSpaces.size} spaces.")
+
+    return true
+  end
+
+  # typical
+  # used for varieties of measures that create typical building from model
+  def typical_building_from_model(model, runner, user_arguments)
+
+    # assign the user inputs to variables
+    args = OsLib_HelperMethods.createRunVariables(runner, model, user_arguments, arguments(model))
+    if !args then return false end
+
+    # lookup and replace argument values from upstream measures
+    if args['use_upstream_args'] == true
+      args.each do |arg, value|
+        next if arg == 'use_upstream_args' # this argument should not be changed
+        value_from_osw = OsLib_HelperMethods.check_upstream_measure_for_arg(runner, arg)
+        if !value_from_osw.empty?
+          runner.registerInfo("Replacing argument named #{arg} from current measure with a value of #{value_from_osw[:value]} from #{value_from_osw[:measure_name]}.")
+          new_val = value_from_osw[:value]
+          # TODO: - make code to handle non strings more robust. check_upstream_measure_for_arg coudl pass bakc the argument type
+          if arg == 'total_bldg_floor_area'
+            args[arg] = new_val.to_f
+          elsif arg == 'num_stories_above_grade'
+            args[arg] = new_val.to_f
+          elsif arg == 'zipcode'
+            args[arg] = new_val.to_i
+          else
+            args[arg] = new_val
+          end
+        end
+      end
+    end
+
+    # validate fraction parking
+    fraction = OsLib_HelperMethods.checkDoubleAndIntegerArguments(runner, user_arguments, 'min' => 0.0, 'max' => 1.0, 'min_eq_bool' => true, 'max_eq_bool' => true, 'arg_array' => ['onsite_parking_fraction'])
+    if !fraction then return false end
+
+    # validate unmet hours tolerance
+    unmet_hours_tolerance_valid = OsLib_HelperMethods.checkDoubleAndIntegerArguments(runner, user_arguments, 'min' => 0.0, 'max' => 5.0, 'min_eq_bool' => true, 'max_eq_bool' => true, 'arg_array' => ['unmet_hours_tolerance'])
+    if !unmet_hours_tolerance_valid then return false end
+
+    # validate weekday hours of operation
+    wkdy_op_hrs_start_time_hr = nil
+    wkdy_op_hrs_start_time_min = nil
+    wkdy_op_hrs_duration_hr = nil
+    wkdy_op_hrs_duration_min = nil
+    if args['modify_wkdy_op_hrs']
+      # weekday start time hr
+      wkdy_op_hrs_start_time_hr = args['wkdy_op_hrs_start_time'].floor
+      if wkdy_op_hrs_start_time_hr < 0 || wkdy_op_hrs_start_time_hr > 24
+        runner.registerError("Weekday operating hours start time hrs must be between 0 and 24.  #{args['wkdy_op_hrs_start_time']} was entered.")
+        return false
+      end
+
+      # weekday start time min
+      wkdy_op_hrs_start_time_min = (60.0 * (args['wkdy_op_hrs_start_time'] - args['wkdy_op_hrs_start_time'].floor)).floor
+      if wkdy_op_hrs_start_time_min < 0 || wkdy_op_hrs_start_time_min > 59
+        runner.registerError("Weekday operating hours start time mins must be between 0 and 59.  #{args['wkdy_op_hrs_start_time']} was entered.")
+        return false
+      end
+
+      # weekday duration hr
+      wkdy_op_hrs_duration_hr = args['wkdy_op_hrs_duration'].floor
+      if wkdy_op_hrs_duration_hr < 0 || wkdy_op_hrs_duration_hr > 24
+        runner.registerError("Weekday operating hours duration hrs must be between 0 and 24.  #{args['wkdy_op_hrs_duration']} was entered.")
+        return false
+      end
+
+      # weekday duration min
+      wkdy_op_hrs_duration_min = (60.0 * (args['wkdy_op_hrs_duration'] - args['wkdy_op_hrs_duration'].floor)).floor
+      if wkdy_op_hrs_duration_min < 0 || wkdy_op_hrs_duration_min > 59
+        runner.registerError("Weekday operating hours duration mins must be between 0 and 59.  #{args['wkdy_op_hrs_duration']} was entered.")
+        return false
+      end
+
+      # check that weekday start time plus duration does not exceed 24 hrs
+      if (wkdy_op_hrs_start_time_hr + wkdy_op_hrs_duration_hr + (wkdy_op_hrs_start_time_min + wkdy_op_hrs_duration_min)/60.0) > 24.0
+        runner.registerInfo("Weekday start time of #{args['wkdy_op_hrs_start']} plus duration of #{args['wkdy_op_hrs_duration']} is more than 24 hrs, hours of operation overlap midnight.")
+      end
+    end
+
+    # validate weekend hours of operation
+    wknd_op_hrs_start_time_hr = nil
+    wknd_op_hrs_start_time_min = nil
+    wknd_op_hrs_duration_hr = nil
+    wknd_op_hrs_duration_min = nil
+    if args['modify_wknd_op_hrs']
+      # weekend start time hr
+      wknd_op_hrs_start_time_hr = args['wknd_op_hrs_start_time'].floor
+      if wknd_op_hrs_start_time_hr < 0 || wknd_op_hrs_start_time_hr > 24
+        runner.registerError("Weekend operating hours start time hrs must be between 0 and 24.  #{args['wknd_op_hrs_start_time_change']} was entered.")
+        return false
+      end
+
+      # weekend start time min
+      wknd_op_hrs_start_time_min = (60.0 * (args['wknd_op_hrs_start_time'] - args['wknd_op_hrs_start_time'].floor)).floor
+      if wknd_op_hrs_start_time_min < 0 || wknd_op_hrs_start_time_min > 59
+        runner.registerError("Weekend operating hours start time mins must be between 0 and 59.  #{args['wknd_op_hrs_start_time_change']} was entered.")
+        return false
+      end
+
+      # weekend duration hr
+      wknd_op_hrs_duration_hr = args['wknd_op_hrs_duration'].floor
+      if wknd_op_hrs_duration_hr < 0 || wknd_op_hrs_duration_hr > 24
+        runner.registerError("Weekend operating hours duration hrs must be between 0 and 24.  #{args['wknd_op_hrs_duration']} was entered.")
+        return false
+      end
+
+      # weekend duration min
+      wknd_op_hrs_duration_min = (60.0 * (args['wknd_op_hrs_duration'] - args['wknd_op_hrs_duration'].floor)).floor
+      if wknd_op_hrs_duration_min < 0 || wknd_op_hrs_duration_min > 59
+        runner.registerError("Weekend operating hours duration min smust be between 0 and 59.  #{args['wknd_op_hrs_duration']} was entered.")
+        return false
+      end
+
+      # check that weekend start time plus duration does not exceed 24 hrs
+      if (wknd_op_hrs_start_time_hr + wknd_op_hrs_duration_hr + (wknd_op_hrs_start_time_min + wknd_op_hrs_duration_min)/60.0) > 24.0
+        runner.registerInfo("Weekend start time of #{args['wknd_op_hrs_start']} plus duration of #{args['wknd_op_hrs_duration']} is more than 24 hrs, hours of operation overlap midnight.")
+      end
+    end
+
+    # report initial condition of model
+    initial_objects = model.getModelObjects.size
+    runner.registerInitialCondition("The building started with #{initial_objects} objects.")
+
+    # open channel to log messages
+    reset_log
+
+    # Make the standard applier
+    standard = Standard.build((args['template']).to_s)
+
+    # validate climate zone
+    if !args.has_key?('climate_zone') || args['climate_zone'] == 'Lookup From Model'
+      climate_zone = standard.model_get_building_climate_zone_and_building_type(model)['climate_zone']
+      runner.registerInfo("Using climate zone #{climate_zone} from model")
+    else
+      climate_zone = args['climate_zone']
+      runner.registerInfo("Using climate zone #{climate_zone} from user arguments")
+    end
+    if climate_zone == ''
+      runner.registerError("Could not determine climate zone from measure arguments or model.")
+      return false
+    end
+
+    # make sure daylight savings is turned on up prior to any sizing runs being done.
+    if args['enable_dst']
+      start_date = '2nd Sunday in March'
+      end_date = '1st Sunday in November'
+
+      runperiodctrl_daylgtsaving = model.getRunPeriodControlDaylightSavingTime
+      runperiodctrl_daylgtsaving.setStartDate(start_date)
+      runperiodctrl_daylgtsaving.setEndDate(end_date)
+    end
+
+    # add internal loads to space types
+    if args['add_space_type_loads']
+
+      # remove internal loads
+      if args['remove_objects']
+        model.getSpaceLoads.each do |instance|
+          next if instance.name.to_s.include?('Elevator') # most prototype building types model exterior elevators with name Elevator
+          next if instance.to_InternalMass.is_initialized
+          next if instance.to_WaterUseEquipment.is_initialized
+          instance.remove
+        end
+        model.getDesignSpecificationOutdoorAirs.each(&:remove)
+        model.getDefaultScheduleSets.each(&:remove)
+      end
+
+      model.getSpaceTypes.each do |space_type|
+        # Don't add infiltration here; will be added later in the script
+        test = standard.space_type_apply_internal_loads(space_type, true, true, true, true, true, false)
+        if test == false
+          runner.registerWarning("Could not add loads for #{space_type.name}. Not expected for #{args['template']}")
+          next
+        end
+
+        # apply internal load schedules
+        # the last bool test it to make thermostat schedules. They are now added in HVAC section instead of here
+        standard.space_type_apply_internal_load_schedules(space_type, true, true, true, true, true, true, false)
+
+        # extend space type name to include the args['template']. Consider this as well for load defs
+        space_type.setName("#{space_type.name} - #{args['template']}")
+        runner.registerInfo("Adding loads to space type named #{space_type.name}")
+      end
+
+      # warn if spaces in model without space type
+      spaces_without_space_types = []
+      model.getSpaces.each do |space|
+        next if space.spaceType.is_initialized
+        spaces_without_space_types << space
+      end
+      if !spaces_without_space_types.empty?
+        runner.registerWarning("#{spaces_without_space_types.size} spaces do not have space types assigned, and wont' receive internal loads from standards space type lookups.")
+      end
+    end
+
+    # identify primary building type (used for construction, and ideally HVAC as well)
+    building_types = {}
+    model.getSpaceTypes.each do |space_type|
+      # populate hash of building types
+      if space_type.standardsBuildingType.is_initialized
+        bldg_type = space_type.standardsBuildingType.get
+        if !building_types.key?(bldg_type)
+          building_types[bldg_type] = space_type.floorArea
+        else
+          building_types[bldg_type] += space_type.floorArea
+        end
+      else
+        runner.registerWarning("Can't identify building type for #{space_type.name}")
+      end
+    end
+    primary_bldg_type = building_types.key(building_types.values.max) # TODO: - this fails if no space types, or maybe just no space types with standards
+    lookup_building_type = standard.model_get_lookup_name(primary_bldg_type) # Used for some lookups in the standards gem
+    model.getBuilding.setStandardsBuildingType(primary_bldg_type)
+
+    # make construction set and apply to building
+    if args['add_constructions']
+
+      # remove default construction sets
+      if args['remove_objects']
+        model.getDefaultConstructionSets.each(&:remove)
+      end
+
+      # TODO: - allow building type and space type specific constructions set selection.
+      if ['SmallHotel', 'LargeHotel', 'MidriseApartment', 'HighriseApartment'].include?(primary_bldg_type)
+        is_residential = 'Yes'
+      else
+        is_residential = 'No'
+      end
+      bldg_def_const_set = standard.model_add_construction_set(model, climate_zone, lookup_building_type, nil, is_residential)
+      if bldg_def_const_set.is_initialized
+        bldg_def_const_set = bldg_def_const_set.get
+        if is_residential then bldg_def_const_set.setName("Res #{bldg_def_const_set.name}") end
+        model.getBuilding.setDefaultConstructionSet(bldg_def_const_set)
+        runner.registerInfo("Adding default construction set named #{bldg_def_const_set.name}")
+      else
+        runner.registerError("Could not create default construction set for the building type #{lookup_building_type} in climate zone #{climate_zone}.")
+        log_messages_to_runner(runner, debug = true)
+        return false
+      end
+
+      # address any adiabatic surfaces that don't have hard assigned constructions
+      model.getSurfaces.each do |surface|
+        next if surface.outsideBoundaryCondition != 'Adiabatic'
+        next if surface.construction.is_initialized
+        surface.setAdjacentSurface(surface)
+        surface.setConstruction(surface.construction.get)
+        surface.setOutsideBoundaryCondition('Adiabatic')
+      end
+
+      # modify the infiltration rates
+      if args['remove_objects']
+        model.getSpaceInfiltrationDesignFlowRates.each(&:remove)
+      end
+      standard.model_apply_infiltration_standard(model)
+      standard.model_modify_infiltration_coefficients(model, primary_bldg_type, climate_zone)
+
+      # set ground temperatures from DOE prototype buildings
+      standard.model_add_ground_temperatures(model, primary_bldg_type, climate_zone)
+
+    end
+
+    # add elevators (returns ElectricEquipment object)
+    if args['add_elevators']
+
+      # remove elevators as spaceLoads or exteriorLights
+      model.getSpaceLoads.each do |instance|
+        next if !instance.name.to_s.include?('Elevator') # most prototype building types model exterior elevators with name Elevator
+        instance.remove
+      end
+      model.getExteriorLightss.each do |ext_light|
+        next if !ext_light.name.to_s.include?('Fuel equipment') # some prototype building types model exterior elevators by this name
+        ext_light.remove
+      end
+
+      elevators = standard.model_add_elevators(model)
+      if elevators.nil?
+        runner.registerInfo('No elevators added to the building.')
+      else
+        elevator_def = elevators.electricEquipmentDefinition
+        design_level = elevator_def.designLevel.get
+        runner.registerInfo("Adding #{elevators.multiplier.round(1)} elevators each with power of #{OpenStudio.toNeatString(design_level, 0, true)} (W), plus lights and fans.")
+        elevator_def.setFractionLost(1.0)
+        elevator_def.setFractionRadiant(0.0)
+      end
+    end
+
+    # add exterior lights (returns a hash where key is lighting type and value is exteriorLights object)
+    if args['add_exterior_lights']
+
+      if args['remove_objects']
+        model.getExteriorLightss.each do |ext_light|
+          next if ext_light.name.to_s.include?('Fuel equipment') # some prototype building types model exterior elevators by this name
+          ext_light.remove
+        end
+      end
+
+      exterior_lights = standard.model_add_typical_exterior_lights(model, args['exterior_lighting_zone'].chars[0].to_i, args['onsite_parking_fraction'])
+      exterior_lights.each do |k, v|
+        runner.registerInfo("Adding Exterior Lights named #{v.exteriorLightsDefinition.name} with design level of #{v.exteriorLightsDefinition.designLevel} * #{OpenStudio.toNeatString(v.multiplier, 0, true)}.")
+      end
+    end
+
+    # add_exhaust
+    if args['add_exhaust']
+
+      # remove exhaust objects
+      if args['remove_objects']
+        model.getFanZoneExhausts.each(&:remove)
+      end
+
+      zone_exhaust_fans = standard.model_add_exhaust(model, args['kitchen_makeup']) # second argument is strategy for finding makeup zones for exhaust zones
+      zone_exhaust_fans.each do |k, v|
+        max_flow_rate_ip = OpenStudio.convert(k.maximumFlowRate.get, 'm^3/s', 'cfm').get
+        if v.key?(:zone_mixing)
+          zone_mixing = v[:zone_mixing]
+          mixing_source_zone_name = zone_mixing.sourceZone.get.name
+          mixing_design_flow_rate_ip = OpenStudio.convert(zone_mixing.designFlowRate.get, 'm^3/s', 'cfm').get
+          runner.registerInfo("Adding #{OpenStudio.toNeatString(max_flow_rate_ip, 0, true)} (cfm) of exhaust to #{k.thermalZone.get.name}, with #{OpenStudio.toNeatString(mixing_design_flow_rate_ip, 0, true)} (cfm) of makeup air from #{mixing_source_zone_name}")
+        else
+          runner.registerInfo("Adding #{OpenStudio.toNeatString(max_flow_rate_ip, 0, true)} (cfm) of exhaust to #{k.thermalZone.get.name}")
+        end
+      end
+    end
+
+    # add service water heating demand and supply
+    if args['add_swh']
+
+      # remove water use equipment and water use connections
+      if args['remove_objects']
+        # TODO: - remove plant loops used for service water heating
+        model.getWaterUseEquipments.each(&:remove)
+        model.getWaterUseConnectionss.each(&:remove)
+      end
+
+      # Infer the SWH type
+      if args['swh_src'] == 'Inferred'
+        if args['htg_src'] == 'NaturalGas' || args['htg_src'] == 'DistrictHeating'
+          args['swh_src'] = 'NaturalGas' # If building has gas service, probably uses natural gas for SWH
+        elsif args['htg_src'] == 'Electricity'
+          args['swh_src'] == 'Electricity' # If building is doing space heating with electricity, probably used for SWH
+        elsif args['htg_src'] == 'DistrictAmbient'
+          args['swh_src'] == 'HeatPump' # If building has district ambient loop, it is fancy and probably uses HPs for SWH
+        else
+          args['swh_src'] = nil # Use inferences built into OpenStudio Standards for each building and space type
+        end
+      end
+
+      typical_swh = standard.model_add_typical_swh(model, water_heater_fuel: args['swh_src'])
+      midrise_swh_loops = []
+      stripmall_swh_loops = []
+      typical_swh.each do |loop|
+        if loop.name.get.include?('MidriseApartment')
+          midrise_swh_loops << loop
+        elsif loop.name.get.include?('RetailStripmall')
+          stripmall_swh_loops << loop
+        else
+          water_use_connections = []
+          loop.demandComponents.each do |component|
+            next if !component.to_WaterUseConnections.is_initialized
+            water_use_connections << component
+          end
+          runner.registerInfo("Adding #{loop.name} to the building. It has #{water_use_connections.size} water use connections.")
+        end
+      end
+      if !midrise_swh_loops.empty?
+        runner.registerInfo("Adding #{midrise_swh_loops.size} MidriseApartment service water heating loops.")
+      end
+      if !stripmall_swh_loops.empty?
+        runner.registerInfo("Adding #{stripmall_swh_loops.size} RetailStripmall service water heating loops.")
+      end
+    end
+
+    # add_daylighting_controls (since outdated measure don't have this default to true if arg not found)
+    if !args.has_key?('add_daylighting_controls')
+      args['add_daylighting_controls'] = true
+    end
+    if args['add_daylighting_controls']
+      # remove add_daylighting_controls objects
+      if args['remove_objects']
+        model.getDaylightingControls.each(&:remove)
+      end
+
+      # add daylight controls, need to perform a sizing run for 2010
+      if args['template'] == '90.1-2010'
+        if standard.model_run_sizing_run(model, "#{Dir.pwd}/SRvt") == false
+          log_messages_to_runner(runner, debug = true)
+          return false
+        end
+      end
+    standard.model_add_daylighting_controls(model)
+    end
+
+    # add refrigeration
+    if args['add_refrigeration']
+
+      # remove refrigeration equipment
+      if args['remove_objects']
+        model.getRefrigerationSystems.each(&:remove)
+      end
+
+      # Add refrigerated cases and walkins
+      standard.model_add_typical_refrigeration(model, primary_bldg_type)
+    end
+
+    # add internal mass
+    if args['add_internal_mass']
+
+      if args['remove_objects']
+        model.getSpaceLoads.each do |instance|
+          next unless instance.to_InternalMass.is_initialized
+          instance.remove
+        end
+      end
+
+      # add internal mass to conditioned spaces; needs to happen after thermostats are applied
+      standard.model_add_internal_mass(model, primary_bldg_type)
+    end
+
+    # TODO: - add slab modeling and slab insulation
+
+    # TODO: - fuel customization for cooking and laundry
+    # works by switching some fraction of electric loads to gas if requested (assuming base load is electric)
+
+    # add thermostats
+    if args['add_thermostat']
+
+      # remove thermostats
+      if args['remove_objects']
+        model.getThermostatSetpointDualSetpoints.each(&:remove)
+      end
+
+      model.getSpaceTypes.each do |space_type|
+        # create thermostat schedules
+        # skip un-recognized space types
+        next if standard.space_type_get_standards_data(space_type).empty?
+        # the last bool test it to make thermostat schedules. They are added to the model but not assigned
+        standard.space_type_apply_internal_load_schedules(space_type, false, false, false, false, false, false, true)
+
+        # identify thermal thermostat and apply to zones (apply_internal_load_schedules names )
+        model.getThermostatSetpointDualSetpoints.each do |thermostat|
+          next if thermostat.name.to_s != "#{space_type.name} Thermostat"
+          next if !thermostat.coolingSetpointTemperatureSchedule.is_initialized
+          next if !thermostat.heatingSetpointTemperatureSchedule.is_initialized
+          runner.registerInfo("Assigning #{thermostat.name} to thermal zones with #{space_type.name} assigned.")
+          space_type.spaces.each do |space|
+            next if !space.thermalZone.is_initialized
+            space.thermalZone.get.setThermostatSetpointDualSetpoint(thermostat)
+          end
+        end
+      end
+    end
+
+    # add hvac system
+    if args['add_hvac']
+
+      # remove HVAC objects
+      if args['remove_objects']
+        standard.model_remove_prm_hvac(model)
+      end
+
+      case args['system_type']
+      when 'Inferred'
+
+        # Get the hvac delivery type enum
+        hvac_delivery = case args['hvac_delivery_type']
+                        when 'Forced Air'
+                          'air'
+                        when 'Hydronic'
+                          'hydronic'
+                        end
+
+        # Group the zones by occupancy type.  Only split out non-dominant groups if their total area exceeds the limit.
+        sys_groups = standard.model_group_zones_by_type(model, OpenStudio.convert(20_000, 'ft^2', 'm^2').get)
+
+        # For each group, infer the HVAC system type.
+        sys_groups.each do |sys_group|
+          # Infer the primary system type
+          # runner.registerInfo("template = #{args['template']}, climate_zone = #{climate_zone}, occ_type = #{sys_group['type']}, hvac_delivery = #{hvac_delivery}, htg_src = #{args['htg_src']}, clg_src = #{args['clg_src']}, area_ft2 = #{sys_group['area_ft2']}, num_stories = #{sys_group['stories']}")
+          sys_type, central_htg_fuel, zone_htg_fuel, clg_fuel = standard.model_typical_hvac_system_type(model,
+                                                                                                        climate_zone,
+                                                                                                        sys_group['type'],
+                                                                                                        hvac_delivery,
+                                                                                                        args['htg_src'],
+                                                                                                        args['clg_src'],
+                                                                                                        OpenStudio.convert(sys_group['area_ft2'], 'ft^2', 'm^2').get,
+                                                                                                        sys_group['stories'])
+
+          # Infer the secondary system type for multizone systems
+          sec_sys_type = case sys_type
+                         when 'PVAV Reheat', 'VAV Reheat'
+                           'PSZ-AC'
+                         when 'PVAV PFP Boxes', 'VAV PFP Boxes'
+                           'PSZ-HP'
+                         else
+                           sys_type # same as primary system type
+                         end
+
+          # Group zones by story
+          story_zone_lists = standard.model_group_zones_by_story(model, sys_group['zones'])
+
+          # On each story, add the primary system to the primary zones
+          # and add the secondary system to any zones that are different.
+          story_zone_lists.each do |story_group|
+            # Differentiate primary and secondary zones, based on
+            # operating hours and internal loads (same as 90.1 PRM)
+            pri_sec_zone_lists = standard.model_differentiate_primary_secondary_thermal_zones(model, story_group)
+            system_zones = pri_sec_zone_lists['primary']
+
+            # if the primary system type is PTAC, filter to cooled zones to prevent sizing error if no cooling
+            if sys_type == 'PTAC'
+              heated_and_cooled_zones = system_zones.select { |zone| standard.thermal_zone_heated?(zone) && standard.thermal_zone_cooled?(zone) }
+              cooled_only_zones = system_zones.select { |zone| !standard.thermal_zone_heated?(zone) && standard.thermal_zone_cooled?(zone) }
+              system_zones = heated_and_cooled_zones + cooled_only_zones
+            end
+
+            # Add the primary system to the primary zones
+            standard.model_add_hvac_system(model, sys_type, central_htg_fuel, zone_htg_fuel, clg_fuel, system_zones)
+
+            # Add the secondary system to the secondary zones (if any)
+            if !pri_sec_zone_lists['secondary'].empty?
+              system_zones = pri_sec_zone_lists['secondary']
+              if (sec_sys_type == 'PTAC') || (sec_sys_type == 'PSZ-AC')
+                heated_and_cooled_zones = system_zones.select { |zone| standard.thermal_zone_heated?(zone) && standard.thermal_zone_cooled?(zone) }
+                cooled_only_zones = system_zones.select { |zone| !standard.thermal_zone_heated?(zone) && standard.thermal_zone_cooled?(zone) }
+                system_zones = heated_and_cooled_zones + cooled_only_zones
+              end
+              standard.model_add_hvac_system(model, sec_sys_type, central_htg_fuel, zone_htg_fuel, clg_fuel, system_zones)
+            end
+          end
+        end
+
+      else # HVAC system_type specified
+
+        # Group the zones by occupancy type.  Only split out non-dominant groups if their total area exceeds the limit.
+        sys_groups = standard.model_group_zones_by_type(model, OpenStudio.convert(20_000, 'ft^2', 'm^2').get)
+        sys_groups.each do |sys_group|
+          # Group the zones by story
+          story_groups = standard.model_group_zones_by_story(model, sys_group['zones'])
+
+          # Add the user specified HVAC system for each story.
+          # Single-zone systems will get one per zone.
+          story_groups.each do |zones|
+            model.add_cbecs_hvac_system(standard, args['system_type'], zones)
+          end
+        end
+      end
+    end
+
+    # hours of operation
+    if args['modify_wkdy_op_hrs'] || args['modify_wknd_op_hrs']
+      # Infer the current hours of operation schedule for the building
+      op_sch = standard.model_infer_hours_of_operation_building(model)
+
+      # Convert existing schedules in the model to parametric schedules based on current hours of operation
+      standard.model_setup_parametric_schedules(model)
+
+      # Create start and end times from start time and duration supplied
+      wkdy_start_time = nil
+      wkdy_end_time = nil
+      wknd_start_time = nil
+      wknd_end_time = nil
+      # weekdays
+      if args['modify_wkdy_op_hrs']
+        wkdy_start_time = OpenStudio::Time.new(0, wkdy_op_hrs_start_time_hr, wkdy_op_hrs_start_time_min, 0)
+        wkdy_end_time = wkdy_start_time + OpenStudio::Time.new(0, wkdy_op_hrs_duration_hr, wkdy_op_hrs_duration_min, 0)
+      end
+      # weekends
+      if args['modify_wknd_op_hrs']
+        wknd_start_time = OpenStudio::Time.new(0, wknd_op_hrs_start_time_hr, wknd_op_hrs_start_time_min, 0)
+        wknd_end_time = wknd_start_time + OpenStudio::Time.new(0, wknd_op_hrs_duration_hr, wknd_op_hrs_duration_min, 0)
+      end
+
+      # Modify hours of operation, using weekdays values for all weekdays and weekend values for Saturday and Sunday
+      standard.schedule_ruleset_set_hours_of_operation(op_sch,
+                                                       wkdy_start_time: wkdy_start_time,
+                                                       wkdy_end_time: wkdy_end_time,
+                                                       sat_start_time: wknd_start_time,
+                                                       sat_end_time: wknd_end_time,
+                                                       sun_start_time: wknd_start_time,
+                                                       sun_end_time: wknd_end_time)
+
+      # Apply new operating hours to parametric schedules to make schedules in model reflect modified hours of operation
+      parametric_schedules = standard.model_apply_parametric_schedules(model, error_on_out_of_order: false)
+      runner.registerInfo("Updated #{parametric_schedules.size} schedules with new hours of operation.")
+    end
+
+    # set hvac controls and efficiencies (this should be last model articulation element)
+    if args['add_hvac']
+      # set additional properties for building
+      props = model.getBuilding.additionalProperties
+      props.setFeature('hvac_system_type',"#{args['system_type']}")
+
+      case args['system_type']
+      when 'Ideal Air Loads'
+
+      else
+        # Set the heating and cooling sizing parameters
+        standard.model_apply_prm_sizing_parameters(model)
+
+        # Perform a sizing run
+        if standard.model_run_sizing_run(model, "#{Dir.pwd}/SR1") == false
+          log_messages_to_runner(runner, debug = true)
+          return false
+        end
+
+        # If there are any multizone systems, reset damper positions
+        # to achieve a 60% ventilation effectiveness minimum for the system
+        # following the ventilation rate procedure from 62.1
+        standard.model_apply_multizone_vav_outdoor_air_sizing(model)
+
+        # Apply the prototype HVAC assumptions
+        standard.model_apply_prototype_hvac_assumptions(model, primary_bldg_type, climate_zone)
+
+        # Apply the HVAC efficiency standard
+        standard.model_apply_hvac_efficiency_standard(model, climate_zone)
+      end
+    end
+
+    # set unmet hours tolerance
+    unmet_hrs_tol_r = args['unmet_hours_tolerance']
+    unmet_hrs_tol_k = OpenStudio.convert(unmet_hrs_tol_r, 'R', 'K').get
+    tolerances = model.getOutputControlReportingTolerances
+    tolerances.setToleranceforTimeHeatingSetpointNotMet(unmet_hrs_tol_k)
+    tolerances.setToleranceforTimeCoolingSetpointNotMet(unmet_hrs_tol_k)
+
+    # remove everything but spaces, zones, and stub space types (extend as needed for additional objects, may make bool arg for this)
+    if args['remove_objects']
+      model.purgeUnusedResourceObjects
+      objects_after_cleanup = initial_objects - model.getModelObjects.size
+      if objects_after_cleanup > 0
+        runner.registerInfo("Removing #{objects_after_cleanup} objects from model")
+      end
+    end
+
+    # report final condition of model
+    runner.registerFinalCondition("The building finished with #{model.getModelObjects.size} objects.")
+
+    # log messages to info messages
+    log_messages_to_runner(runner, debug = false)
+
+    return true
+  end
+
+  # wizard
+  # used for varieties of measures that create space type and construction set wizard
+  def wizard(model, runner, user_arguments)
+
+    # use the built-in error checking
+    if !runner.validateUserArguments(arguments(model), user_arguments)
+      return false
+    end
+
+    # assign the user inputs to variables
+    building_type = runner.getStringArgumentValue('building_type', user_arguments)
+    template = runner.getStringArgumentValue('template', user_arguments)
+    climate_zone = runner.getStringArgumentValue('climate_zone', user_arguments)
+    create_space_types = runner.getBoolArgumentValue('create_space_types', user_arguments)
+    create_construction_set = runner.getBoolArgumentValue('create_construction_set', user_arguments)
+    set_building_defaults = runner.getBoolArgumentValue('set_building_defaults', user_arguments)
+
+    # reporting initial condition of model
+    starting_spaceTypes = model.getSpaceTypes
+    starting_constructionSets = model.getDefaultConstructionSets
+    runner.registerInitialCondition("The building started with #{starting_spaceTypes.size} space types and #{starting_constructionSets.size} construction sets.")
+
+    # lookup space types for specified building type (false indicates not to use whole building type only)
+    space_type_hash = get_space_types_from_building_type(building_type, template, false)
+    if space_type_hash == false
+      runner.registerError("#{building_type} is an unexpected building type.")
+      return false
+    end
+
+    # create space_type_map from array
+    space_type_map = {}
+    default_space_type_name = nil
+    space_type_hash.each do |space_type_name, hash|
+      next if hash[:space_type_gen] == false # space types like undeveloped and basement are skipped.
+      space_type_map[space_type_name] = [] # no spaces to pass in
+      if hash[:default]
+        default_space_type_name = space_type_name
+      end
+    end
+
+    # Make the standard applier
+    standard = Standard.build(template)
+
+    # mapping building_type name is needed for a few methods
+    lookup_building_type = standard.model_get_lookup_name(building_type)
+
+    # remap small medium and large office to office
+    if building_type.include?("Office") then building_type = "Office" end
+
+    # get array of new space types
+    space_types_new = []
+
+    # create_space_types
+    if create_space_types
+
+      # array of starting space types
+      space_types_starting = model.getSpaceTypes
+
+      # create stub space types
+      space_type_hash.each do |space_type_name, hash|
+        next if hash[:space_type_gen] == false # space types like undeveloped and basement are skipped.
+
+        # create space type
+        space_type = OpenStudio::Model::SpaceType.new(model)
+        space_type.setStandardsBuildingType(building_type)
+        space_type.setStandardsSpaceType(space_type_name)
+        space_type.setName("#{building_type} #{space_type_name}")
+
+        # add to array of new space types
+        space_types_new << space_type
+
+        # add internal loads (the nil check isn't ncessary, but I will keep it in as a warning instad of an error)
+        test = standard.space_type_apply_internal_loads(space_type, true, true, true, true, true, true)
+        if test.nil?
+          runner.registerWarning("Could not add loads for #{space_type.name}. Not expected for #{template} #{lookup_building_type}")
+        end
+
+        # the last bool test it to make thermostat schedules. They are added to the model but not assigned
+        standard.space_type_apply_internal_load_schedules(space_type, true, true, true, true, true, true, true)
+
+        # assign colors
+        standard.space_type_apply_rendering_color(space_type)
+
+        # exend space type name to include the template. Consider this as well for load defs
+        space_type.setName("#{space_type.name} - #{template}")
+        runner.registerInfo("Added space type named #{space_type.name}")
+      end
+
+    end
+
+    # add construction sets
+    bldg_def_const_set = nil
+    if create_construction_set
+
+      # Make the default construction set for the building
+      is_residential = 'No' # default is nonresidential for building level
+      bldg_def_const_set = standard.model_add_construction_set(model, climate_zone, lookup_building_type, nil, is_residential)
+      if bldg_def_const_set.is_initialized
+        bldg_def_const_set = bldg_def_const_set.get
+        runner.registerInfo("Added default construction set named #{bldg_def_const_set.name}")
+      else
+        runner.registerError('Could not create default construction set for the building.')
+        return false
+      end
+
+      # make residential construction set as unused resource
+      if ['SmallHotel', 'LargeHotel', 'MidriseApartment', 'HighriseApartment'].include?(building_type)
+        res_const_set = standard.model_add_construction_set(model, climate_zone, lookup_building_type, nil, 'Yes')
+        if res_const_set.is_initialized
+          res_const_set = res_const_set.get
+          res_const_set.setName("#{bldg_def_const_set.name} - Residential ")
+          runner.registerInfo("Added residential construction set named #{res_const_set.name}")
+        else
+          runner.registerError('Could not create residential construction set for the building.')
+          return false
+        end
+      end
+
+    end
+
+    # set_building_defaults
+    if set_building_defaults
+
+      # identify default space type
+      space_type_standards_info_hash = OsLib_HelperMethods.getSpaceTypeStandardsInformation(space_types_new)
+      default_space_type = nil
+      space_type_standards_info_hash.each do |space_type, standards_array|
+        standards_space_type = standards_array[1]
+        if default_space_type_name == standards_space_type
+          default_space_type = space_type
+        end
+      end
+
+      # set default space type
+      building = model.getBuilding
+      if !default_space_type.nil?
+        building.setSpaceType(default_space_type)
+        runner.registerInfo("Setting default Space Type for building to #{building.spaceType.get.name}")
+      end
+
+      # default construction
+      if !bldg_def_const_set.nil?
+        building.setDefaultConstructionSet(bldg_def_const_set)
+        runner.registerInfo("Setting default Construction Set for building to #{building.defaultConstructionSet.get.name}")
+      end
+
+      # set climate zone
+      os_climate_zone = climate_zone.gsub('ASHRAE 169-2013-', '')
+      # trim off letter from climate zone 7 or 8
+      if (os_climate_zone[0] == '7') || (os_climate_zone[0] == '8')
+        os_climate_zone = os_climate_zone[0]
+      end
+      climate_zone = model.getClimateZones.setClimateZone('ASHRAE', os_climate_zone)
+      runner.registerInfo("Setting #{climate_zone.institution} Climate Zone to #{climate_zone.value}")
+
+      # set building type
+      # use lookup_building_type so spaces like MediumOffice will map to Office (Supports baseline automation)
+      building.setStandardsBuildingType(lookup_building_type)
+      runner.registerInfo("Setting Standards Building Type to #{building.standardsBuildingType}")
+
+      # rename building if it is named "Building 1"
+      if model.getBuilding.name.to_s == 'Building 1'
+        model.getBuilding.setName("#{building_type} #{template} #{os_climate_zone}")
+        runner.registerInfo("Renaming building to #{model.getBuilding.name}")
+      end
+
+    end
+
+    # reporting final condition of model
+    finishing_spaceTypes = model.getSpaceTypes
+    finishing_constructionSets = model.getDefaultConstructionSets
+    runner.registerFinalCondition("The building finished with #{finishing_spaceTypes.size} space types and #{finishing_constructionSets.size} construction sets.")
+
+    return true
+  end
+
 end