openstudio-extension 0.2.0 → 0.2.5

data/lib/measures/openstudio_extension_test_measure/measure.xml

@@ -1,17 +1,18 @@
+<?xml version="1.0"?>
 <measure>
   <schema_version>3.0</schema_version>
   <name>openstudio_extension_test_measure</name>
   <uid>36b99a29-41e1-4d85-9272-85d43b966e5a</uid>
-  <version_id>e9fedf04-7619-4c93-a865-0e54adfe3507</version_id>
-  <version_modified>20190430T155209Z</version_modified>
+  <version_id>edf7f103-9f51-4944-a5af-1d8fa2b0c9b7</version_id>
+  <version_modified>20200427T230714Z</version_modified>
   <xml_checksum>49BEF039</xml_checksum>
   <class_name>OpenStudioExtensionTestMeasure</class_name>
   <display_name>OpenStudio Extension Test Measure</display_name>
-  <description>Rotate your building relative to its current orientation. This will not rotate site shading objects.</description>
-  <modeler_description>Get the North Axis field for the  OS:Building object and adjusted it based on the user specified value. If the starting value is 20 degrees and the user value is 5 degrees, then the resulting value is 25 degrees.</modeler_description>
-  <arguments/>
-  <outputs/>
-  <provenances/>
+  <description>A measure that tests OpenStudio Extension gem functionality</description>
+  <modeler_description>This is a test measure that tests OpenStudio Extension gem functionality.</modeler_description>
+  <arguments />
+  <outputs />
+  <provenances />
   <tags>
     <tag>Envelope.Form</tag>
   </tags>
@@ -38,12 +39,6 @@
     </attribute>
   </attributes>
   <files>
-    <file>
-      <filename>LICENSE.md</filename>
-      <filetype>md</filetype>
-      <usage_type>license</usage_type>
-      <checksum>9640B6CB</checksum>
-    </file>
     <file>
       <filename>README.md.erb</filename>
       <filetype>erb</filetype>
@@ -51,16 +46,16 @@
       <checksum>703C9964</checksum>
     </file>
     <file>
-      <filename>README.md</filename>
+      <filename>LICENSE.md</filename>
       <filetype>md</filetype>
-      <usage_type>readme</usage_type>
-      <checksum>7258830F</checksum>
+      <usage_type>license</usage_type>
+      <checksum>E0468DD6</checksum>
     </file>
     <file>
       <filename>OpenStudioExtensionTestMeasure_Test.rb</filename>
       <filetype>rb</filetype>
       <usage_type>test</usage_type>
-      <checksum>8452EA9A</checksum>
+      <checksum>66A00EA8</checksum>
     </file>
     <file>
       <version>
@@ -71,13 +66,19 @@
       <filename>measure.rb</filename>
       <filetype>rb</filetype>
       <usage_type>script</usage_type>
-      <checksum>E5793A49</checksum>
+      <checksum>51BB85EF</checksum>
     </file>
     <file>
       <filename>os_lib_helper_methods.rb</filename>
       <filetype>rb</filetype>
       <usage_type>resource</usage_type>
-      <checksum>22515A49</checksum>
+      <checksum>07B01D67</checksum>
+    </file>
+    <file>
+      <filename>README.md</filename>
+      <filetype>md</filetype>
+      <usage_type>readme</usage_type>
+      <checksum>7258830F</checksum>
     </file>
   </files>
 </measure>

data/lib/openstudio/extension.rb

@@ -101,11 +101,9 @@ module OpenStudio
     def self.all_measure_dirs
       result = []
       all_extensions.each do |obj|
-        begin
-          dir = obj.new.measures_dir
-          result << dir if dir
-        rescue StandardError
-        end
+        dir = obj.new.measures_dir
+        result << dir if dir
+      rescue StandardError
       end
       return result.uniq
     end
@@ -117,11 +115,9 @@ module OpenStudio
     def self.all_file_dirs
       result = []
       all_extensions.each do |obj|
-        begin
-          dir = obj.new.files_dir
-          result << dir if dir
-        rescue StandardError
-        end
+        dir = obj.new.files_dir
+        result << dir if dir
+      rescue StandardError
       end
       return result.uniq
     end
@@ -230,5 +226,26 @@ module OpenStudio
 
       return osw
     end
+
+    ##
+    # Module method used to check whether a measure is present in an OSW file
+    ##
+    #  @param [Hash] in_osw Initial OSW object as a Hash, keys should be symbolized
+    #  @param [String] measure_dir_name Directory name of measure to set argument on
+    #  @param [String] step_name Optional argument, if present used to further identify the measure
+    #
+    #  @return [Boolean] true or false
+    def self.measure_in_osw(osw, measure_dir_name, step_name = nil)
+      result = false
+      osw[:steps].each do |step|
+        if step[:measure_dir_name] == measure_dir_name
+          if step_name.nil? || step[:name] == step_name
+            result = true
+          end
+        end
+      end
+
+      return result
+    end
   end
 end

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

@@ -45,6 +45,23 @@ module OsLib_CreateResults
   # @param end_mo [String] the end month for the peak demand window
   # @param end_day [Integer] the end day for the peak demand window
   # @param end_hr [Integer] the end hour for the peak demand window, using 24-hr clock
+  # @param electricity_consumption_tou_periods [Array<Hash>] optional array of hashes to add
+  # time-of-use electricity consumption values to the annual consumption information.
+  # Periods may overlap, but should be listed in the order in which they must be checked,
+  # where the value will be assigned to the first encountered period it falls into.
+  # An example hash looks like this:
+  #       {
+  #         'tou_name' => 'system_peak',
+  #         'tou_id' => 1,
+  #         'skip_weekends' => true,
+  #         'skip_holidays' => true,
+  #         'start_mo' => 'July',
+  #         'start_day' => 1,
+  #         'start_hr' => 14,
+  #         'end_mo' => 'August',
+  #         'end_day' => 31,
+  #         'end_hr' => 18
+  #       }
   # @return [OpenStudio::AttributeVector] a vector of results needed by EDAPT
   def create_results(skip_weekends = true,
                      skip_holidays = true,
@@ -53,7 +70,8 @@ module OsLib_CreateResults
                      start_hr = 14,
                      end_mo = 'September',
                      end_day = 30,
-                     end_hr = 18)
+                     end_hr = 18,
+                     electricity_consumption_tou_periods = [])
 
     # get the current version of OS being used to determine if sql query
     # changes are needed (for when E+ changes).
@@ -497,6 +515,83 @@ module OsLib_CreateResults
         @runner.registerValue('annual_demand_electricity_peak_demand', 0.0, 'kW')
       end
 
+      # Describe the TOU periods
+      electricity_consumption_tou_periods.each do |tou_pd|
+        @runner.registerInfo("TOU period #{tou_pd['tou_id']} represents #{tou_pd['tou_name']} and covers #{tou_pd['start_mo']}-#{tou_pd['start_day']} to #{tou_pd['end_mo']}-#{tou_pd['end_day']} from #{tou_pd['start_hr']} to #{tou_pd['end_hr']}, skip weekends = #{tou_pd['skip_weekends']}, skip holidays = #{tou_pd['skip_holidays']}")
+      end
+
+      # electricity time-of-use periods
+      elec = @sql.timeSeries(ann_env_pd, 'Zone Timestep', 'Electricity:Facility', '')
+      if elec.is_initialized && day_types
+        elec = elec.get
+        # Put timeseries into array
+        elec_vals = []
+        ann_elec_vals = elec.values
+        for i in 0..(ann_elec_vals.size - 1)
+          elec_vals << ann_elec_vals[i]
+        end
+
+        # Put values into array
+        elec_times = []
+        ann_elec_times = elec.dateTimes
+        for i in 0..(ann_elec_times.size - 1)
+          elec_times << ann_elec_times[i]
+        end
+
+        # Loop through the time/value pairs and find the peak
+        # excluding the times outside of the Xcel peak demand window
+        electricity_tou_vals = Hash.new(0)
+        elec_times.zip(elec_vals).each_with_index do |vs, ind|
+          date_time = vs[0]
+          joules = vs[1]
+          day_type = day_types[ind]
+          time = date_time.time
+          date = date_time.date
+
+          # puts("#{val_kW}kW; #{date}; #{time}; #{day_of_week.valueName}")
+
+          # Determine which TOU period this hour falls into
+          tou_period_assigned = false
+          electricity_consumption_tou_periods.each do |tou_pd|
+            pd_start_date = OpenStudio::DateTime.new(OpenStudio::Date.new(OpenStudio::MonthOfYear.new(tou_pd['start_mo']), tou_pd['start_day'], timeseries_yr), OpenStudio::Time.new(0, 0, 0, 0))
+            pd_end_date = OpenStudio::DateTime.new(OpenStudio::Date.new(OpenStudio::MonthOfYear.new(tou_pd['end_mo']), tou_pd['end_day'], timeseries_yr), OpenStudio::Time.new(0, 24, 0, 0))
+            pd_start_time = OpenStudio::Time.new(0, tou_pd['start_hr'], 0, 0)
+            pd_end_time = OpenStudio::Time.new(0, tou_pd['end_hr'], 0, 0)
+            # Skip times outside of the correct months
+            next if date_time < pd_start_date || date_time > pd_end_date
+            # Skip times before some time and after another time
+            next if time < pd_start_time || time > pd_end_time
+            # Skip weekends if asked
+            if tou_pd['skip_weekends']
+              # Sunday = 1, Saturday = 7
+              next if day_type == 1 || day_type == 7
+            end
+            # Skip holidays if asked
+            if tou_pd['skip_holidays']
+              # Holiday = 8
+              next if day_type == 8
+            end
+            # If here, this hour falls into the specified period
+            tou_period_assigned = true
+            electricity_tou_vals[tou_pd['tou_id']] += joules
+            break
+          end
+          # Ensure that the value fell into a period
+          unless tou_period_assigned
+            @runner.registerError("Did not find a TOU period covering #{time} on #{date}, kWh will not be included in any TOU period.")
+          end
+        end
+        # Register values for any time-of-use period with kWh
+        electricity_tou_vals.each do |tou_pd_id, joules_in_pd|
+          gj_in_pd = OpenStudio.convert(joules_in_pd, 'J', 'GJ').get
+          kwh_in_pd = OpenStudio.convert(joules_in_pd, 'J', 'kWh').get
+          @runner.registerValue("annual_consumption_electricity_tou_#{tou_pd_id}", gj_in_pd, 'GJ')
+          @runner.registerInfo("TOU period #{tou_pd_id} annual electricity consumption = #{kwh_in_pd} kWh.")
+        end
+      else
+        @runner.registerError('Electricity timeseries (Electricity:Facility at zone timestep) could not be found, cannot determine the information needed to calculate savings or incentives.')
+      end
+
       # electricity_annual_avg_peak_demand
       val = @sql.electricityTotalEndUses
       if val.is_initialized
@@ -587,6 +682,88 @@ module OsLib_CreateResults
         @runner.registerValue('annual_demand_district_cooling_peak_demand', 0.0, 'kW')
       end
 
+      # district cooling time-of-use periods
+      dist_clg = @sql.timeSeries(ann_env_pd, 'Zone Timestep', 'DistrictCooling:Facility', '')
+      if dist_clg.is_initialized && day_types
+        dist_clg = dist_clg.get
+        # Put timeseries into array
+        dist_clg_vals = []
+        ann_dist_clg_vals = dist_clg.values
+        for i in 0..(ann_dist_clg_vals.size - 1)
+          dist_clg_vals << ann_dist_clg_vals[i]
+        end
+
+        # Put values into array
+        dist_clg_times = []
+        ann_dist_clg_times = dist_clg.dateTimes
+        for i in 0..(ann_dist_clg_times.size - 1)
+          dist_clg_times << ann_dist_clg_times[i]
+        end
+
+        # Loop through the time/value pairs and find the peak
+        # excluding the times outside of the Xcel peak demand window
+        dist_clg_tou_vals = Hash.new(0)
+        dist_clg_times.zip(dist_clg_vals).each_with_index do |vs, ind|
+          date_time = vs[0]
+          joules = vs[1]
+          day_type = day_types[ind]
+          time = date_time.time
+          date = date_time.date
+
+          # puts("#{val_kW}kW; #{date}; #{time}; #{day_of_week.valueName}")
+
+          # Determine which TOU period this hour falls into
+          tou_period_assigned = false
+          electricity_consumption_tou_periods.each do |tou_pd|
+            pd_start_date = OpenStudio::DateTime.new(OpenStudio::Date.new(OpenStudio::MonthOfYear.new(tou_pd['start_mo']), tou_pd['start_day'], timeseries_yr), OpenStudio::Time.new(0, 0, 0, 0))
+            pd_end_date = OpenStudio::DateTime.new(OpenStudio::Date.new(OpenStudio::MonthOfYear.new(tou_pd['end_mo']), tou_pd['end_day'], timeseries_yr), OpenStudio::Time.new(0, 24, 0, 0))
+            pd_start_time = OpenStudio::Time.new(0, tou_pd['start_hr'], 0, 0)
+            pd_end_time = OpenStudio::Time.new(0, tou_pd['end_hr'], 0, 0)
+            # Skip times outside of the correct months
+            next if date_time < pd_start_date || date_time > pd_end_date
+            # Skip times before some time and after another time
+            next if time < pd_start_time || time > pd_end_time
+            # Skip weekends if asked
+            if tou_pd['skip_weekends']
+              # Sunday = 1, Saturday = 7
+              next if day_type == 1 || day_type == 7
+            end
+            # Skip holidays if asked
+            if tou_pd['skip_holidays']
+              # Holiday = 8
+              next if day_type == 8
+            end
+            # If here, this hour falls into the specified period
+            tou_period_assigned = true
+            dist_clg_tou_vals[tou_pd['tou_id']] += joules
+            break
+          end
+          # Ensure that the value fell into a period
+          unless tou_period_assigned
+            @runner.registerError("Did not find a TOU period covering #{time} on #{date}, kWh will not be included in any TOU period.")
+          end
+        end
+        # Register values for any time-of-use period with kWh
+        dist_clg_tou_vals.each do |tou_pd_id, joules_in_pd|
+          gj_in_pd = OpenStudio.convert(joules_in_pd, 'J', 'GJ').get
+          kwh_in_pd = OpenStudio.convert(joules_in_pd, 'J', 'kWh').get
+          @runner.registerValue("annual_consumption_district_cooling_tou_#{tou_pd_id}", gj_in_pd, 'GJ')
+          @runner.registerInfo("TOU period #{tou_pd_id} annual district cooling consumption = #{kwh_in_pd} kWh.")
+        end
+      else
+        # If TOU periods were specified but this model has no district cooling, report zeroes
+        if electricity_consumption_tou_periods.size > 0
+          # Get the TOU ids
+          tou_ids = []
+          electricity_consumption_tou_periods.each do |tou_pd|
+            tou_ids << tou_pd['tou_id']
+          end
+          tou_ids.uniq.each do |tou_id|
+            @runner.registerValue("annual_consumption_district_cooling_tou_#{tou_id}", 0.0, 'GJ')
+          end
+        end
+      end
+
     else
       @runner.registerError('Could not find an annual run period')
       return OpenStudio::Attribute.new('report', result_elems)

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

@@ -283,7 +283,12 @@ module OsLib_Constructions
     # create info message
     if !runner.nil? # todo - need to look for bad visible transmittance here
       uFactorSiToIpConversion = OpenStudio.convert(material.uFactor, 'W/m^2*K', 'Btu/ft^2*h*R').get
-      runner.registerInfo("Created #{construction.name} construction. U-factor: #{OpenStudio.toNeatString(uFactorSiToIpConversion, 2, true)}(Btu/ft^2*h*R), SHGC: #{material.getSolarHeatGainCoefficient}, VT: #{material.getVisibleTransmittance.get}.")
+      # version check to support 2.x and 3.x
+      if Gem::Version.new(OpenStudio::openStudioVersion) > Gem::Version.new("2.9.1")
+        runner.registerInfo("Created #{construction.name} construction. U-factor: #{OpenStudio.toNeatString(uFactorSiToIpConversion, 2, true)}(Btu/ft^2*h*R), SHGC: #{material.solarHeatGainCoefficient}, VT: #{material.getVisibleTransmittance.get}.")
+      else
+        runner.registerInfo("Created #{construction.name} construction. U-factor: #{OpenStudio.toNeatString(uFactorSiToIpConversion, 2, true)}(Btu/ft^2*h*R), SHGC: #{material.getSolarHeatGainCoefficient}, VT: #{material.getVisibleTransmittance.get}.")
+      end
     end
 
     result = construction

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

@@ -327,7 +327,8 @@ module OsLib_Geometry
     end
 
     # sort array by floor area, this hash will be altered to reduce floor area for each space type to 0
-    space_types_running_count = space_types.sort_by { |k, v| v[:floor_area] }
+    #space_types_running_count = space_types.sort_by { |k, v| v[:floor_area] }
+    space_types_running_count = space_types
 
     # array entry for each story
     footprints = []
@@ -354,8 +355,10 @@ module OsLib_Geometry
 
       space_types_running_count.each do |space_type, space_type_hash|
         # next if floor area is full or space type is empty
-        next if current_footprint_area >= target_footprint_area
-        next if space_type_hash[:floor_area] <= 0.0
+
+        tol_value = 0.0001
+        next if current_footprint_area + tol_value >= target_footprint_area
+        next if space_type_hash[:floor_area] <= tol_value
 
         # special test for when total floor area is smaller than valid_bar_area_min, just make bar smaller that valid min and warn user
         if target_per_space_type[space_type] < valid_bar_area_min
@@ -367,20 +370,18 @@ module OsLib_Geometry
 
         # add entry for space type if it doesn't have one yet
         if !space_types_local_count.key?(space_type)
-          space_types_local_count[space_type] = { floor_area: 0.0 }
+          if space_type_hash.has_key?(:children)
+            space_type = space_type_hash[:children][:default][:space_type] # will re-using space type create issue
+            space_types_local_count[space_type] = { floor_area: 0.0 }
+            space_types_local_count[space_type][:children] = space_type_hash[:children]
+          else
+            space_types_local_count[space_type] = { floor_area: 0.0 }
+          end
         end
 
         # if there is enough of this space type to fill rest of floor area
         remaining_in_footprint = target_footprint_area - current_footprint_area
-        if space_type_hash[:floor_area] > remaining_in_footprint
-
-          # add to local count for story and remove from running count from space type
-          raw_footprint_area_used = remaining_in_footprint
-
-        else
-          # if not then use up the rest of the floor area and move on to next space type
-          raw_footprint_area_used = space_type_hash[:floor_area]
-        end
+        raw_footprint_area_used = [space_type_hash[:floor_area],remaining_in_footprint].min
 
         # add to local hash
         space_types_local_count[space_type][:floor_area] = raw_footprint_area_used / v[:multiplier].to_f
@@ -389,13 +390,13 @@ module OsLib_Geometry
         current_footprint_area += raw_footprint_area_used
         space_type_hash[:floor_area] -= raw_footprint_area_used
 
-        # test if think slice left on current floor.
+        # test if think sliver left on current floor.
         # fix by moving smallest space type to next floor and and the same amount more of the sliver space type to this story
         raw_footprint_area_used < valid_bar_area_min && sliver_override == false ? (test_a = true) : (test_a = false)
 
         # test if what would be left of the current space type would result in a sliver on the next story.
         # fix by removing some of this space type so their is enough left for the next story, and replace the removed amount with the largest space type in the model
-        (space_type_hash[:floor_area] < valid_bar_area_min) && (space_type_hash[:floor_area] > 0.0001) ? (test_b = true) : (test_b = false)
+        (space_type_hash[:floor_area] < valid_bar_area_min) && (space_type_hash[:floor_area] > tol_value) ? (test_b = true) : (test_b = false)
 
         # identify very small slices and re-arrange spaces to different stories to avoid this
         if test_a
@@ -422,6 +423,10 @@ module OsLib_Geometry
 
           # swap size
           swap_size = valid_bar_area_min * 5 # currently equal to default perimeter zone depth of 15'
+          # this prevents too much area from being swapped resulting in a negative number for floor area
+          if swap_size > space_types_local_count[space_type][:floor_area] * v[:multiplier].to_f
+            swap_size = space_types_local_count[space_type][:floor_area] * v[:multiplier].to_f
+          end
 
           # adjust running count for current space type
           space_type_hash[:floor_area] += swap_size
@@ -445,12 +450,18 @@ module OsLib_Geometry
   end
 
   # sliced bar simple creates a single sliced bar for space types passed in
-  # todo - look at length and width to adjust slicing direction
+  # look at length and width to adjust slicing direction
   def self.make_sliced_bar_simple_polygons(runner, space_types, length, width, footprint_origin = OpenStudio::Point3d.new(0, 0, 0), perimeter_zone_depth = OpenStudio.convert(15, 'ft', 'm').get)
     hash_of_point_vectors = {} # key is name, value is a hash, one item of which is polygon. Another could be space type
 
+    reverse_slice = false
+    if length < width
+      reverse_slice = true
+      #runner.registerInfo("reverse typical slice direction for bar because of aspect ratio less than 1.0.")
+    end
+
     # determine if core and perimeter zoning can be used
-    if !(length > perimeter_zone_depth * 2.5 && width > perimeter_zone_depth * 2.5)
+    if !([length,width].min > perimeter_zone_depth * 2.5 && [length,width].min > perimeter_zone_depth * 2.5)
       perimeter_zone_depth = 0 # if any size is to small then just model floor as single zone, issue warning
       runner.registerWarning('Not modeling core and perimeter zones for some portion of the model.')
     end
@@ -461,6 +472,7 @@ module OsLib_Geometry
     # this represents the entire bar, not individual space type slices
     nw_point = OpenStudio::Point3d.new(x_delta, y_delta + width, z)
     sw_point = OpenStudio::Point3d.new(x_delta, y_delta, z)
+    se_point = OpenStudio::Point3d.new(x_delta + length, y_delta, z) # used when length is less than width
 
     # total building floor area to calculate ratios from space type floor areas
     total_floor_area = 0.0
@@ -470,7 +482,7 @@ module OsLib_Geometry
 
     # sort array by floor area but shift largest object to front
     space_types = space_types.sort_by { |k, v| v[:floor_area] }
-    space_types.insert(0, space_types.delete_at(space_types.size - 1))
+    space_types.insert(0, space_types.delete_at(space_types.size - 1)) #.to_h
 
     # min and max bar end values
     min_bar_end_multiplier = 0.75
@@ -484,20 +496,20 @@ module OsLib_Geometry
       start_perimeter_width_deduction = 0.0
       end_perimeter_width_deduction = 0.0
       if space_type == space_types.first[0]
-        if length * space_type_hash[:floor_area] / total_floor_area > max_bar_end_multiplier * perimeter_zone_depth
+        if [length,width].max * space_type_hash[:floor_area] / total_floor_area > max_bar_end_multiplier * perimeter_zone_depth
           start_perimeter_width_deduction = perimeter_zone_depth
         end
         # see if last space type is too small for perimeter. If it is then save some of this space type
-        if length * space_types.last[1][:floor_area] / total_floor_area < perimeter_zone_depth * min_bar_end_multiplier
+        if [length,width].max * space_types.last[1][:floor_area] / total_floor_area < perimeter_zone_depth * min_bar_end_multiplier
           re_apply_largest_space_type_at_end = true
         end
       end
       if space_type == space_types.last[0]
-        if length * space_type_hash[:floor_area] / total_floor_area > max_bar_end_multiplier * perimeter_zone_depth
+        if [length,width].max * space_type_hash[:floor_area] / total_floor_area > max_bar_end_multiplier * perimeter_zone_depth
           end_perimeter_width_deduction = perimeter_zone_depth
         end
       end
-      non_end_adjusted_width = (length * space_type_hash[:floor_area] / total_floor_area) - start_perimeter_width_deduction - end_perimeter_width_deduction
+      non_end_adjusted_width = ([length,width].max * space_type_hash[:floor_area] / total_floor_area) - start_perimeter_width_deduction - end_perimeter_width_deduction
 
       # adjustment of end space type is too small and is replaced with largest space type
       if (space_type == space_types.first[0]) && re_apply_largest_space_type_at_end
@@ -506,69 +518,223 @@ module OsLib_Geometry
       end
       if (space_type == space_types.last[0]) && re_apply_largest_space_type_at_end
         end_perimeter_width_deduction = space_types.first[0]
+        end_b_flag = true
+      else
+        end_b_flag = false
       end
 
-      # poulate data for core and perimeter of slice
+      # populate data for core and perimeter of slice
       section_hash_for_space_type = {}
       section_hash_for_space_type['end_a'] = start_perimeter_width_deduction
       section_hash_for_space_type[''] = non_end_adjusted_width
       section_hash_for_space_type['end_b'] = end_perimeter_width_deduction
 
+      # determine if this space+type is double loaded corridor, and if so what the perimeter zone depth should be based on building width
+      # look at reverse_slice to see if length or width should be used to determine perimeter depth
+      if space_type_hash.has_key?(:children)
+        core_ratio = space_type_hash[:children][:circ][:orig_ratio]
+        perim_ratio = space_type_hash[:children][:default][:orig_ratio]
+        core_ratio_adj = core_ratio / (core_ratio + perim_ratio)
+        perim_ratio_adj = perim_ratio / (core_ratio + perim_ratio)
+        core_space_type = space_type_hash[:children][:circ][:space_type]
+        perim_space_type = space_type_hash[:children][:default][:space_type]
+        if !reverse_slice
+          custom_cor_val = width * core_ratio_adj
+          custom_perim_val = (width - custom_cor_val)/2.0
+        else
+          custom_cor_val = length * core_ratio_adj
+          custom_perim_val = (length - custom_cor_val)/2.0
+        end
+        actual_perim = custom_perim_val
+        double_loaded_corridor = true
+      else
+        actual_perim = perimeter_zone_depth
+        double_loaded_corridor = false
+      end
+
+      # may overwrite
+      first_space_type_hash = space_types.first[1]
+      if end_b_flag && first_space_type_hash.has_key?(:children)
+        end_b_core_ratio = first_space_type_hash[:children][:circ][:orig_ratio]
+        end_b_perim_ratio = first_space_type_hash[:children][:default][:orig_ratio]
+        end_b_core_ratio_adj = end_b_core_ratio / (end_b_core_ratio + end_b_perim_ratio)
+        end_b_perim_ratio_adj = end_b_perim_ratio / (end_b_core_ratio + end_b_perim_ratio)
+        end_b_core_space_type = first_space_type_hash[:children][:circ][:space_type]
+        end_b_perim_space_type = first_space_type_hash[:children][:default][:space_type]
+        if !reverse_slice
+          end_b_custom_cor_val = width * end_b_core_ratio_adj
+          end_b_custom_perim_val = (width - end_b_custom_cor_val)/2.0
+        else
+          end_b_custom_cor_val = length * end_b_core_ratio_adj
+          end_b_custom_perim_val = (length - end_b_custom_cor_val)/2.0
+        end
+        end_b_actual_perim = end_b_custom_perim_val
+        end_b_double_loaded_corridor = true
+      else
+        end_b_actual_perim = perimeter_zone_depth
+        end_b_double_loaded_corridor = false
+      end
+
       # loop through sections for space type (main and possibly one or two end perimeter sections)
-      section_hash_for_space_type.each do |k, width|
-        if width.class.to_s == 'OpenStudio::Model::SpaceType' # confirm this
-          space_type = width
+      section_hash_for_space_type.each do |k, slice|
+
+        # need to use different space type for end_b
+        if end_b_flag && k == "end_b" && space_types.first[1].has_key?(:children)
+          slice = space_types.first[0]
+          actual_perim = end_b_actual_perim
+          double_loaded_corridor = end_b_double_loaded_corridor
+          core_ratio = end_b_core_ratio
+          perim_ratio = end_b_perim_ratio
+          core_ratio_adj = end_b_core_ratio_adj
+          perim_ratio_adj = end_b_perim_ratio_adj
+          core_space_type = end_b_core_space_type
+          perim_space_type = end_b_perim_space_type
+        end
+
+        if slice.class.to_s == 'OpenStudio::Model::SpaceType' || slice.class.to_s == 'OpenStudio::Model::Building'
+          space_type = slice
           max_reduction = [perimeter_zone_depth, max_reduction].min
-          width = max_reduction
+          slice = max_reduction
         end
-        if width == 0
+        if slice == 0
           next
         end
 
-        ne_point = nw_point + OpenStudio::Vector3d.new(width, 0, 0)
-        se_point = sw_point + OpenStudio::Vector3d.new(width, 0, 0)
-
-        if perimeter_zone_depth > 0
-          polygon_a = OpenStudio::Point3dVector.new
-          polygon_a << sw_point
-          polygon_a << sw_point + OpenStudio::Vector3d.new(0, perimeter_zone_depth, 0)
-          polygon_a << se_point + OpenStudio::Vector3d.new(0, perimeter_zone_depth, 0)
-          polygon_a << se_point
-          hash_of_point_vectors["#{space_type.name} A #{k}"] = {}
-          hash_of_point_vectors["#{space_type.name} A #{k}"][:space_type] = space_type
-          hash_of_point_vectors["#{space_type.name} A #{k}"][:polygon] = polygon_a
-
-          polygon_b = OpenStudio::Point3dVector.new
-          polygon_b << sw_point + OpenStudio::Vector3d.new(0, perimeter_zone_depth, 0)
-          polygon_b << nw_point + OpenStudio::Vector3d.new(0, - perimeter_zone_depth, 0)
-          polygon_b << ne_point + OpenStudio::Vector3d.new(0, - perimeter_zone_depth, 0)
-          polygon_b << se_point + OpenStudio::Vector3d.new(0, perimeter_zone_depth, 0)
-          hash_of_point_vectors["#{space_type.name} B #{k}"] = {}
-          hash_of_point_vectors["#{space_type.name} B #{k}"][:space_type] = space_type
-          hash_of_point_vectors["#{space_type.name} B #{k}"][:polygon] = polygon_b
-
-          polygon_c = OpenStudio::Point3dVector.new
-          polygon_c << nw_point + OpenStudio::Vector3d.new(0, - perimeter_zone_depth, 0)
-          polygon_c << nw_point
-          polygon_c << ne_point
-          polygon_c << ne_point + OpenStudio::Vector3d.new(0, - perimeter_zone_depth, 0)
-          hash_of_point_vectors["#{space_type.name} C #{k}"] = {}
-          hash_of_point_vectors["#{space_type.name} C #{k}"][:space_type] = space_type
-          hash_of_point_vectors["#{space_type.name} C #{k}"][:polygon] = polygon_c
+        if !reverse_slice
+
+          ne_point = nw_point + OpenStudio::Vector3d.new(slice, 0, 0)
+          se_point = sw_point + OpenStudio::Vector3d.new(slice, 0, 0)
+
+          if actual_perim > 0 && (actual_perim * 2.0) < width
+            polygon_a = OpenStudio::Point3dVector.new
+            polygon_a << sw_point
+            polygon_a << sw_point + OpenStudio::Vector3d.new(0, actual_perim, 0)
+            polygon_a << se_point + OpenStudio::Vector3d.new(0, actual_perim, 0)
+            polygon_a << se_point
+            if double_loaded_corridor
+              hash_of_point_vectors["#{perim_space_type.name} A #{k}"] = {}
+              hash_of_point_vectors["#{perim_space_type.name} A #{k}"][:space_type] = perim_space_type
+              hash_of_point_vectors["#{perim_space_type.name} A #{k}"][:polygon] = polygon_a
+            else
+              hash_of_point_vectors["#{space_type.name} A #{k}"] = {}
+              hash_of_point_vectors["#{space_type.name} A #{k}"][:space_type] = space_type
+              hash_of_point_vectors["#{space_type.name} A #{k}"][:polygon] = polygon_a
+            end
+
+            polygon_b = OpenStudio::Point3dVector.new
+            polygon_b << sw_point + OpenStudio::Vector3d.new(0, actual_perim, 0)
+            polygon_b << nw_point + OpenStudio::Vector3d.new(0, - actual_perim, 0)
+            polygon_b << ne_point + OpenStudio::Vector3d.new(0, - actual_perim, 0)
+            polygon_b << se_point + OpenStudio::Vector3d.new(0, actual_perim, 0)
+            if double_loaded_corridor
+              hash_of_point_vectors["#{core_space_type.name} B #{k}"] = {}
+              hash_of_point_vectors["#{core_space_type.name} B #{k}"][:space_type] = core_space_type
+              hash_of_point_vectors["#{core_space_type.name} B #{k}"][:polygon] = polygon_b
+            else
+              hash_of_point_vectors["#{space_type.name} B #{k}"] = {}
+              hash_of_point_vectors["#{space_type.name} B #{k}"][:space_type] = space_type
+              hash_of_point_vectors["#{space_type.name} B #{k}"][:polygon] = polygon_b
+            end
+
+            polygon_c = OpenStudio::Point3dVector.new
+            polygon_c << nw_point + OpenStudio::Vector3d.new(0, - actual_perim, 0)
+            polygon_c << nw_point
+            polygon_c << ne_point
+            polygon_c << ne_point + OpenStudio::Vector3d.new(0, - actual_perim, 0)
+            if double_loaded_corridor
+              hash_of_point_vectors["#{perim_space_type.name} C #{k}"] = {}
+              hash_of_point_vectors["#{perim_space_type.name} C #{k}"][:space_type] = perim_space_type
+              hash_of_point_vectors["#{perim_space_type.name} C #{k}"][:polygon] = polygon_c
+            else
+              hash_of_point_vectors["#{space_type.name} C #{k}"] = {}
+              hash_of_point_vectors["#{space_type.name} C #{k}"][:space_type] = space_type
+              hash_of_point_vectors["#{space_type.name} C #{k}"][:polygon] = polygon_c
+            end
+          else
+            polygon_a = OpenStudio::Point3dVector.new
+            polygon_a << sw_point
+            polygon_a << nw_point
+            polygon_a << ne_point
+            polygon_a << se_point
+            hash_of_point_vectors["#{space_type.name} #{k}"] = {}
+            hash_of_point_vectors["#{space_type.name} #{k}"][:space_type] = space_type
+            hash_of_point_vectors["#{space_type.name} #{k}"][:polygon] = polygon_a
+          end
+
+          # update west points
+          nw_point = ne_point
+          sw_point = se_point
+
         else
-          polygon_a = OpenStudio::Point3dVector.new
-          polygon_a << sw_point
-          polygon_a << nw_point
-          polygon_a << ne_point
-          polygon_a << se_point
-          hash_of_point_vectors["#{space_type.name} #{k}"] = {}
-          hash_of_point_vectors["#{space_type.name} #{k}"][:space_type] = space_type
-          hash_of_point_vectors["#{space_type.name} #{k}"][:polygon] = polygon_a
-        end
 
-        # update west points
-        nw_point = ne_point
-        sw_point = se_point
+          # create_bar at 90 degrees if aspect ration is less than 1.0
+          # typical order (sw,nw,ne,se)
+          # order used here (se,sw,nw,ne)
+
+          nw_point = sw_point + OpenStudio::Vector3d.new(0, slice, 0)
+          ne_point = se_point + OpenStudio::Vector3d.new(0, slice, 0)
+
+          if actual_perim > 0 && (actual_perim * 2.0) < length
+            polygon_a = OpenStudio::Point3dVector.new
+            polygon_a << se_point
+            polygon_a << se_point + OpenStudio::Vector3d.new(- actual_perim, 0, 0)
+            polygon_a << ne_point + OpenStudio::Vector3d.new(- actual_perim, 0, 0)
+            polygon_a << ne_point
+            if double_loaded_corridor
+              hash_of_point_vectors["#{perim_space_type.name} A #{k}"] = {}
+              hash_of_point_vectors["#{perim_space_type.name} A #{k}"][:space_type] = perim_space_type
+              hash_of_point_vectors["#{perim_space_type.name} A #{k}"][:polygon] = polygon_a
+            else
+              hash_of_point_vectors["#{space_type.name} A #{k}"] = {}
+              hash_of_point_vectors["#{space_type.name} A #{k}"][:space_type] = space_type
+              hash_of_point_vectors["#{space_type.name} A #{k}"][:polygon] = polygon_a
+            end
+
+            polygon_b = OpenStudio::Point3dVector.new
+            polygon_b << se_point + OpenStudio::Vector3d.new(- actual_perim, 0, 0)
+            polygon_b << sw_point + OpenStudio::Vector3d.new(actual_perim, 0, 0)
+            polygon_b << nw_point + OpenStudio::Vector3d.new(actual_perim, 0, 0)
+            polygon_b << ne_point + OpenStudio::Vector3d.new(- actual_perim, 0, 0)
+            if double_loaded_corridor
+              hash_of_point_vectors["#{core_space_type.name} B #{k}"] = {}
+              hash_of_point_vectors["#{core_space_type.name} B #{k}"][:space_type] = core_space_type
+              hash_of_point_vectors["#{core_space_type.name} B #{k}"][:polygon] = polygon_b
+            else
+              hash_of_point_vectors["#{space_type.name} B #{k}"] = {}
+              hash_of_point_vectors["#{space_type.name} B #{k}"][:space_type] = space_type
+              hash_of_point_vectors["#{space_type.name} B #{k}"][:polygon] = polygon_b
+            end
+
+            polygon_c = OpenStudio::Point3dVector.new
+            polygon_c << sw_point + OpenStudio::Vector3d.new(actual_perim, 0, 0)
+            polygon_c << sw_point
+            polygon_c << nw_point
+            polygon_c << nw_point + OpenStudio::Vector3d.new(actual_perim, 0, 0)
+            if double_loaded_corridor
+              hash_of_point_vectors["#{perim_space_type.name} C #{k}"] = {}
+              hash_of_point_vectors["#{perim_space_type.name} C #{k}"][:space_type] = perim_space_type
+              hash_of_point_vectors["#{perim_space_type.name} C #{k}"][:polygon] = polygon_c
+            else
+              hash_of_point_vectors["#{space_type.name} C #{k}"] = {}
+              hash_of_point_vectors["#{space_type.name} C #{k}"][:space_type] = space_type
+              hash_of_point_vectors["#{space_type.name} C #{k}"][:polygon] = polygon_c
+            end
+          else
+            polygon_a = OpenStudio::Point3dVector.new
+            polygon_a << se_point
+            polygon_a << sw_point
+            polygon_a << nw_point
+            polygon_a << ne_point
+            hash_of_point_vectors["#{space_type.name} #{k}"] = {}
+            hash_of_point_vectors["#{space_type.name} #{k}"][:space_type] = space_type
+            hash_of_point_vectors["#{space_type.name} #{k}"][:polygon] = polygon_a
+          end
+
+          # update west points
+          sw_point = nw_point
+          se_point = ne_point
+
+        end
       end
     end
 
@@ -592,13 +758,24 @@ module OsLib_Geometry
       end
     end
 
+    # hash of new spaces (only change boundary conditions for these)
+    new_spaces = []
+
     # loop through story_hash and polygons to generate all of the spaces
     story_hash.each_with_index do |(story_name, story_data), index|
-      # make new story
-      story = OpenStudio::Model::BuildingStory.new(model)
-      story.setNominalFloortoFloorHeight(story_data[:space_height]) # not used for anything
-      story.setNominalZCoordinate (story_data[:space_origin_z]) # not used for anything
-      story.setName("Story #{story_name}")
+      # make new story unless story at requested height already exists.
+      story = nil
+      model.getBuildingStorys.each do |ext_story|
+        if (ext_story.nominalZCoordinate.to_f - story_data[:space_origin_z].to_f).abs < 0.01
+          story = ext_story
+        end
+      end
+      if story.nil?
+        story = OpenStudio::Model::BuildingStory.new(model)
+        story.setNominalFloortoFloorHeight(story_data[:space_height]) # not used for anything
+        story.setNominalZCoordinate (story_data[:space_origin_z]) # not used for anything
+        story.setName("Story #{story_name}")
+      end
 
       # multiplier values for adjacent stories to be altered below as needed
       multiplier_story_above = 1
@@ -647,6 +824,7 @@ module OsLib_Geometry
 
         # make space
         space = OsLib_Geometry.makeSpaceFromPolygon(model, space_data[:polygon].first, space_data[:polygon], options)
+        new_spaces << space
 
         # set z origin to proper position
         space.setZOrigin(story_data[:space_origin_z])
@@ -676,7 +854,7 @@ module OsLib_Geometry
     # any changes to wall boundary conditions will be handled by same code that calls this method.
     # this method doesn't need to know about basements and party walls.
 
-    return model
+    return new_spaces
   end
 
   # add def to create a space from input, optionally take a name, space type, story and thermal zone.
@@ -714,7 +892,7 @@ module OsLib_Geometry
       space.setName(options['name'])
     end
 
-    if !options['spaceType'].nil?
+    if !options['spaceType'].nil? && options['spaceType'].class.to_s == 'OpenStudio::Model::SpaceType'
       space.setSpaceType(options['spaceType'])
     end