openstudio-standards 0.1.4 → 0.1.5

data/lib/openstudio-standards/standards/Standards.SubSurface.rb

@@ -1,44 +1,42 @@
 
 # open the class to add methods to apply HVAC efficiency standards
 class OpenStudio::Model::SubSurface
-
   # Determine the component infiltration rate for this surface
   #
   # @param type [String] choices are 'baseline' and 'advanced'
   # @return [Double] infiltration rate
   #   @units cubic meters per second (m^3/s)
   def component_infiltration_rate(type)
-       
-    comp_infil_rate_m3_per_s = 0.0   
-       
+    comp_infil_rate_m3_per_s = 0.0
+
     # Define the envelope component infiltration rates
     component_infil_rates_cfm_per_ft2 = {
-      'baseline'=>{
-        'opaque_door'=>0.40,
-        'loading_dock_door'=>0.40,
-        'swinging_or_revolving_glass_door'=>1.0,
-        'vestibule'=>1.0,
-        'sliding_glass_door'=>0.40,
-        'window'=>0.40,
-        'skylight'=>0.40
+      'baseline' => {
+        'opaque_door' => 0.40,
+        'loading_dock_door' => 0.40,
+        'swinging_or_revolving_glass_door' => 1.0,
+        'vestibule' => 1.0,
+        'sliding_glass_door' => 0.40,
+        'window' => 0.40,
+        'skylight' => 0.40
       },
-      'advanced'=>{
-        'opaque_door'=>0.20,
-        'loading_dock_door'=>0.20,
-        'swinging_or_revolving_glass_door'=>1.0,
-        'vestibule'=>1.0,
-        'sliding_glass_door'=>0.20,
-        'window'=>0.20,
-        'skylight'=>0.20
+      'advanced' => {
+        'opaque_door' => 0.20,
+        'loading_dock_door' => 0.20,
+        'swinging_or_revolving_glass_door' => 1.0,
+        'vestibule' => 1.0,
+        'sliding_glass_door' => 0.20,
+        'window' => 0.20,
+        'skylight' => 0.20
       }
     }
-    
-    boundary_condition = self.outsideBoundaryCondition
+
+    boundary_condition = outsideBoundaryCondition
     # Skip non-outdoor surfaces
-    return comp_infil_rate_m3_per_s unless self.outsideBoundaryCondition == 'Outdoors' || self.outsideBoundaryCondition == 'Ground'
-    
+    return comp_infil_rate_m3_per_s unless outsideBoundaryCondition == 'Outdoors' || outsideBoundaryCondition == 'Ground'
+
     # Per area infiltration rate for this surface
-    surface_type = self.subSurfaceType 
+    surface_type = subSurfaceType
     infil_rate_cfm_per_ft2 = nil
     case boundary_condition
     when 'Outdoors'
@@ -48,50 +46,84 @@ class OpenStudio::Model::SubSurface
       when 'OverheadDoor'
         infil_rate_cfm_per_ft2 = component_infil_rates_cfm_per_ft2[type]['loading_dock_door']
       when 'GlassDoor'
-        OpenStudio::logFree(OpenStudio::Info, "openstudio.Standards.Model", "For #{self.name}, assuming swinging_or_revolving_glass_door for infiltration calculation.")
+        OpenStudio.logFree(OpenStudio::Info, 'openstudio.Standards.Model', "For #{name}, assuming swinging_or_revolving_glass_door for infiltration calculation.")
         infil_rate_cfm_per_ft2 = component_infil_rates_cfm_per_ft2[type]['swinging_or_revolving_glass_door']
-      when 'FixedWindow','OperableWindow'
+      when 'FixedWindow', 'OperableWindow'
         infil_rate_cfm_per_ft2 = component_infil_rates_cfm_per_ft2[type]['window']
-      when 'Skylight','TubularDaylightDome','TubularDaylightDiffuser'
+      when 'Skylight', 'TubularDaylightDome', 'TubularDaylightDiffuser'
         infil_rate_cfm_per_ft2 = component_infil_rates_cfm_per_ft2[type]['skylight']
       end
     end
     if infil_rate_cfm_per_ft2.nil?
-      OpenStudio::logFree(OpenStudio::Warn, "openstudio.Standards.Model", "For #{self.name}, could not determine surface type for infiltration, will not be included in calculation.")
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.Standards.Model', "For #{name}, could not determine surface type for infiltration, will not be included in calculation.")
       return comp_infil_rate_m3_per_s
     end
-      
+
     # Area of the surface
-    area_m2 = self.netArea
-    area_ft2 = OpenStudio.convert(area_m2,'m^2','ft^2').get
-    
+    area_m2 = netArea
+    area_ft2 = OpenStudio.convert(area_m2, 'm^2', 'ft^2').get
+
     # Rate for this surface
     comp_infil_rate_cfm = area_ft2 * infil_rate_cfm_per_ft2
 
-    comp_infil_rate_m3_per_s = OpenStudio.convert(comp_infil_rate_cfm,'cfm','m^3/s').get
+    comp_infil_rate_m3_per_s = OpenStudio.convert(comp_infil_rate_cfm, 'cfm', 'm^3/s').get
+
+    # OpenStudio::logFree(OpenStudio::Debug, "openstudio.Standards.Model", "......#{self.name}, infil = #{comp_infil_rate_cfm.round(2)} cfm @ rate = #{infil_rate_cfm_per_ft2} cfm/ft2, area = #{area_ft2.round} ft2.")
 
-    #OpenStudio::logFree(OpenStudio::Debug, "openstudio.Standards.Model", "......#{self.name}, infil = #{comp_infil_rate_cfm.round(2)} cfm @ rate = #{infil_rate_cfm_per_ft2} cfm/ft2, area = #{area_ft2.round} ft2.")
-    
     return comp_infil_rate_m3_per_s
-    
   end
-  
+
+  # Reduce the area of the subsurface by shrinking it
+  # toward the centroid.
+  # @author Julien Marrec
+  #
+  # @param percent_reduction [Double] the fractional amount
+  # to reduce the area.
+  def reduce_area_by_percent_by_shrinking_toward_centroid(percent_reduction)
+    mult = 1 - percent_reduction
+    scale_factor = mult**0.5
+
+    # Get the centroid (Point3d)
+    g = centroid
+
+    # Create an array to collect the new vertices
+    new_vertices = []
+
+    # Loop on vertices (Point3ds)
+    vertices.each do |vertex|
+      # Point3d - Point3d = Vector3d
+      # Vector from centroid to vertex (GA, GB, GC, etc)
+      centroid_vector = vertex - g
+
+      # Resize the vector (done in place) according to scale_factor
+      centroid_vector.setLength(centroid_vector.length * scale_factor)
+
+      # Move the vertex toward the centroid
+      vertex = g + centroid_vector
+
+      new_vertices << vertex
+    end
+
+    # Assign the new vertices to the self
+    setVertices(new_vertices)
+  end
+
   # Reduce the area of the subsurface by raising the
   # sill height.
   #
   # @param percent_reduction [Double] the fractional amount
   # to reduce the area.
   def reduce_area_by_percent_by_raising_sill(percent_reduction)
-  
-    mult = 1-percent_reduction
-    
+
+    mult = 1 - percent_reduction
+
     # Calculate the original area
-    area_original = self.netArea
+    area_original = netArea
 
     # Find the min and max z values
     min_z_val = 99999
     max_z_val = -99999
-    self.vertices.each do |vertex|
+    vertices.each do |vertex|
       # Min z value
       if vertex.z < min_z_val
         min_z_val = vertex.z
@@ -101,16 +133,16 @@ class OpenStudio::Model::SubSurface
         max_z_val = vertex.z
       end
     end
-    
+
     # Calculate the window height
     height = max_z_val - min_z_val
-    
+
     # Calculate the new sill height
     new_sill_z = max_z_val - (height * mult)    
-    
+
     # Reset the z value of the lowest points
     new_vertices = []
-    self.vertices.each do |vertex|
+    vertices.each do |vertex|
       new_x = vertex.x
       new_y = vertex.y
       new_z = vertex.z
@@ -119,69 +151,37 @@ class OpenStudio::Model::SubSurface
       end
       new_vertices << OpenStudio::Point3d.new(new_x, new_y, new_z)
     end
-    
+
     # Reset the vertices
-    self.setVertices(new_vertices)
-    
-    # Compare the new area to the old for validation
-    act_pct_red = 1.0 - (self.netArea / area_original)
-    
+    setVertices(new_vertices)
+
     return true
-  
   end
 
-  # Reduce the area of the subsurface by shrinking it
-  # in the x direction.  Designed to work on skylights.
-  #
-  # @param percent_reduction [Double] the fractional amount
-  # to reduce the area.
-  def reduce_area_by_percent_by_shrinking_x(percent_reduction)
-  
-    mult = 1-percent_reduction
-    
-    # Calculate the original area
-    area_original = self.netArea
-
-    # Find the min and max x values
-    min_x_val = 99999
-    max_x_val = -99999
-    self.vertices.each do |vertex|
-      # Min x value
-      if vertex.x < min_x_val
-        min_x_val = vertex.x
-      end
-      # Max x value
-      if vertex.x > max_x_val
-        max_x_val = vertex.x
-      end
-    end
-    
-    # Calculate the skylight width
-    width = max_x_val - min_x_val
-    
-    # Calculate the new sill width
-    new_width_x = max_x_val - (width * mult)    
-    
-    # Reset the z value of the lowest points
-    new_vertices = []
-    self.vertices.each do |vertex|
-      new_x = vertex.x
-      if new_x == min_x_val
-        new_x = new_width_x
-      end
-      new_y = vertex.y
-      new_z = vertex.z
-      new_vertices << OpenStudio::Point3d.new(new_x, new_y, new_z)
+  # Determine if the sub surface is a vertical rectangle,
+  # meaning a rectangle where the bottom is parallel to the ground.
+  def vertical_rectangle?
+    # Get the vertices once
+    verts = vertices
+
+    # Check for 4 vertices
+    return false unless verts.size == 4
+
+    # Check if the 2 lowest z-values
+    # are the same
+    z_vals = []
+    verts.each do |vertex|
+      z_vals << vertex.z
     end
-    
-    # Reset the vertices
-    self.setVertices(new_vertices)
-    
-    # Compare the new area to the old for validation
-    act_pct_red = 1.0 - (self.netArea / area_original)
-    
+    z_vals = z_vals.sort
+    return false unless z_vals[0] = z_vals[1]
+
+    # Check if the diagonals are equal length
+    diag_a = verts[0] - verts[2]
+    diag_b = verts[1] - verts[3]
+    return false unless diag_a.length == diag_b.length
+
+    # If here, we have a rectangle
     return true
-  
   end
- 
 end

data/lib/openstudio-standards/standards/Standards.Surface.rb

@@ -1,7 +1,6 @@
 
 # open the class to add methods to apply HVAC efficiency standards
 class OpenStudio::Model::Surface
-
   # Determine the component infiltration rate for this surface
   #
   # @param type [String] choices are 'baseline' and 'advanced'
@@ -9,33 +8,32 @@ class OpenStudio::Model::Surface
   #   @units cubic meters per second (m^3/s)
   # @todo handle floors over unconditioned spaces
   def component_infiltration_rate(type)
-       
-    comp_infil_rate_m3_per_s = 0.0   
-       
+    comp_infil_rate_m3_per_s = 0.0
+
     # Define the envelope component infiltration rates
     component_infil_rates_cfm_per_ft2 = {
-      'baseline'=>{
-        'roof'=>0.12,
-        'exterior_wall'=>0.12,
-        'below_grade_wall'=>0.12,
-        'floor_over_unconditioned'=>0.12,
-        'slab_on_grade'=>0.12,
+      'baseline' => {
+        'roof' => 0.12,
+        'exterior_wall' => 0.12,
+        'below_grade_wall' => 0.12,
+        'floor_over_unconditioned' => 0.12,
+        'slab_on_grade' => 0.12
       },
-      'advanced'=>{
-        'roof'=>0.04,
-        'exterior_wall'=>0.04,
-        'below_grade_wall'=>0.04,
-        'floor_over_unconditioned'=>0.04,
-        'slab_on_grade'=>0.04,
+      'advanced' => {
+        'roof' => 0.04,
+        'exterior_wall' => 0.04,
+        'below_grade_wall' => 0.04,
+        'floor_over_unconditioned' => 0.04,
+        'slab_on_grade' => 0.04
       }
     }
-    
-    boundary_condition = self.outsideBoundaryCondition
+
+    boundary_condition = outsideBoundaryCondition
     # Skip non-outdoor surfaces
-    return comp_infil_rate_m3_per_s unless self.outsideBoundaryCondition == 'Outdoors' || self.outsideBoundaryCondition == 'Ground'
-    
+    return comp_infil_rate_m3_per_s unless outsideBoundaryCondition == 'Outdoors' || outsideBoundaryCondition == 'Ground'
+
     # Per area infiltration rate for this surface
-    surface_type = self.surfaceType 
+    surface_type = surfaceType
     infil_rate_cfm_per_ft2 = nil
     case boundary_condition
     when 'Outdoors'
@@ -59,23 +57,21 @@ class OpenStudio::Model::Surface
       end
     end
     if infil_rate_cfm_per_ft2.nil?
-      OpenStudio::logFree(OpenStudio::Warn, "openstudio.Standards.Model", "For #{self.name}, could not determine surface type for infiltration, will not be included in calculation.")
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.Standards.Model', "For #{name}, could not determine surface type for infiltration, will not be included in calculation.")
       return comp_infil_rate_m3_per_s
     end
-      
+
     # Area of the surface
-    area_m2 = self.netArea
-    area_ft2 = OpenStudio.convert(area_m2,'m^2','ft^2').get
-    
+    area_m2 = netArea
+    area_ft2 = OpenStudio.convert(area_m2, 'm^2', 'ft^2').get
+
     # Rate for this surface
     comp_infil_rate_cfm = area_ft2 * infil_rate_cfm_per_ft2
 
-    comp_infil_rate_m3_per_s = OpenStudio.convert(comp_infil_rate_cfm,'cfm','m^3/s').get
+    comp_infil_rate_m3_per_s = OpenStudio.convert(comp_infil_rate_cfm, 'cfm', 'm^3/s').get
+
+    # OpenStudio::logFree(OpenStudio::Debug, "openstudio.Standards.Model", "...#{self.name}, infil = #{comp_infil_rate_cfm.round(2)} cfm @ rate = #{infil_rate_cfm_per_ft2} cfm/ft2, area = #{area_ft2.round} ft2.")
 
-    #OpenStudio::logFree(OpenStudio::Debug, "openstudio.Standards.Model", "...#{self.name}, infil = #{comp_infil_rate_cfm.round(2)} cfm @ rate = #{infil_rate_cfm_per_ft2} cfm/ft2, area = #{area_ft2.round} ft2.")
-    
     return comp_infil_rate_m3_per_s
-    
   end
-  
 end

data/lib/openstudio-standards/standards/Standards.ThermalZone.rb

@@ -1,7 +1,6 @@
 
 # Reopen the OpenStudio class to add methods to apply standards to this object
 class OpenStudio::Model::ThermalZone
-
   # Calculates the zone outdoor airflow requirement (Voz)
   # based on the inputs in the DesignSpecification:OutdoorAir obects
   # in all spaces in the zone.
@@ -9,9 +8,8 @@ class OpenStudio::Model::ThermalZone
   # @return [Double] the zone outdoor air flow rate
   #   @units cubic meters per second (m^3/s)
   def outdoor_airflow_rate
-
     tot_oa_flow_rate = 0.0
-  
+
     spaces = self.spaces.sort
 
     sum_floor_area = 0.0
@@ -27,7 +25,6 @@ class OpenStudio::Model::ThermalZone
 
     # Find common variables for the new space
     spaces.each do |space|
-
       floor_area = space.floorArea
       sum_floor_area += floor_area
 
@@ -40,10 +37,10 @@ class OpenStudio::Model::ThermalZone
       dsn_oa = space.designSpecificationOutdoorAir
       next if dsn_oa.empty?
       dsn_oa = dsn_oa.get
-      
+
       # compute outdoor air rates in case we need them
       oa_for_people = number_of_people * dsn_oa.outdoorAirFlowperPerson
-      oa_for_floor_area = floorArea * dsn_oa.outdoorAirFlowperFloorArea
+      oa_for_floor_area = floor_area * dsn_oa.outdoorAirFlowperFloorArea
       oa_rate = dsn_oa.outdoorAirFlowRate
       oa_for_volume = volume * dsn_oa.outdoorAirFlowAirChangesperHour
 
@@ -56,21 +53,19 @@ class OpenStudio::Model::ThermalZone
         sum_oa_rate += oa_rate
         sum_oa_for_volume += oa_for_volume
       end
-
     end
 
     tot_oa_flow_rate += sum_oa_for_people
     tot_oa_flow_rate += sum_oa_for_floor_area
     tot_oa_flow_rate += sum_oa_rate
     tot_oa_flow_rate += sum_oa_for_volume
-    
+
     # Convert to cfm
-    tot_oa_flow_rate_cfm = OpenStudio.convert(tot_oa_flow_rate,'m^3/s','cfm').get
-    
-    OpenStudio::logFree(OpenStudio::Debug, "openstudio.Standards.Model", "For #{self.name}, design min OA = #{tot_oa_flow_rate_cfm.round} cfm.")
-    
-    return tot_oa_flow_rate
+    tot_oa_flow_rate_cfm = OpenStudio.convert(tot_oa_flow_rate, 'm^3/s', 'cfm').get
 
+    OpenStudio.logFree(OpenStudio::Debug, 'openstudio.Standards.Model', "For #{name}, design min OA = #{tot_oa_flow_rate_cfm.round} cfm.")
+
+    return tot_oa_flow_rate
   end
 
   # Calculates the zone outdoor airflow requirement and
@@ -78,26 +73,63 @@ class OpenStudio::Model::ThermalZone
   #
   # @return [Double] the zone outdoor air flow rate per area
   #   @units cubic meters per second (m^3/s)
-  def outdoor_airflow_rate_per_area()
-
+  def outdoor_airflow_rate_per_area
     tot_oa_flow_rate_per_area = 0.0
 
     # Find total area of the zone
     sum_floor_area = 0.0
-    self.spaces.sort.each do |space|
+    spaces.sort.each do |space|
       sum_floor_area += space.floorArea
     end
 
     # Get the OA flow rate
     tot_oa_flow_rate = outdoor_airflow_rate
-    
+
     # Calculate the per-area value
     tot_oa_flow_rate_per_area = tot_oa_flow_rate / sum_floor_area
 
     # OpenStudio::logFree(OpenStudio::Debug, "openstudio.Standards.Model", "For #{self.name}, OA per area = #{tot_oa_flow_rate_per_area.round(8)} m^3/s*m^2.")
 
     return tot_oa_flow_rate_per_area
+  end
+
+  # Convert total minimum OA requirement to a per-area value.
+  #
+  # @return [Bool] true if successful, false if not
+  def convert_oa_req_to_per_area
 
+    # For each space in the zone, convert
+    # all design OA to per-area
+    spaces.each do |space|
+      dsn_oa = space.designSpecificationOutdoorAir
+      next if dsn_oa.empty?
+      dsn_oa = dsn_oa.get
+
+      # Get the space properties
+      floor_area = space.floorArea
+      number_of_people = space.numberOfPeople
+      volume = space.volume
+
+      # Sum up the total OA from all sources
+      oa_for_people = number_of_people * dsn_oa.outdoorAirFlowperPerson
+      oa_for_floor_area = floor_area * dsn_oa.outdoorAirFlowperFloorArea
+      oa_rate = dsn_oa.outdoorAirFlowRate
+      oa_for_volume = volume * dsn_oa.outdoorAirFlowAirChangesperHour
+      tot_oa = oa_for_people + oa_for_floor_area + oa_rate + oa_for_volume
+
+      # Convert total to per-area
+      tot_oa_per_area = tot_oa / floor_area
+
+      # Set the per-area requirement
+      dsn_oa.setOutdoorAirFlowperFloorArea(tot_oa_per_area)
+      # Zero-out the per-person, ACH, and flow requirements
+      dsn_oa.setOutdoorAirFlowperPerson(0.0)
+      dsn_oa.setOutdoorAirFlowAirChangesperHour(0.0)
+      dsn_oa.setOutdoorAirFlowRate(0.0)
+
+    end
+
+    return true
   end
 
   # This method creates a schedule where the value is zero when
@@ -109,16 +141,15 @@ class OpenStudio::Model::ThermalZone
   # @param occupied_percentage_threshold [Double] the minimum fraction (0 to 1) that counts as occupied
   # @return [ScheduleRuleset] a ScheduleRuleset where 0 = unoccupied, 1 = occupied
   # @todo Speed up this method.  Bottleneck is ScheduleRule.getDaySchedules
- def get_occupancy_schedule(occupied_percentage_threshold = 0.05)
-
+  def get_occupancy_schedule(occupied_percentage_threshold = 0.05)
     # Get all the occupancy schedules in every space in the zone
     # Include people added via the SpaceType
     # in addition to people hard-assigned to the Space itself.
     occ_schedules_num_occ = {}
     max_occ_on_thermal_zone = 0
-	
+
     # Get the people objects
-    self.spaces.each do |space|
+    spaces.each do |space|
       # From the space type
       if space.spaceType.is_initialized
         space.spaceType.get.people.each do |people|
@@ -131,11 +162,10 @@ class OpenStudio::Model::ThermalZone
             num_ppl = people.getNumberOfPeople(space.floorArea)
             if occ_schedules_num_occ[num_ppl_sch].nil?
               occ_schedules_num_occ[num_ppl_sch] = num_ppl
-              max_occ_on_thermal_zone += num_ppl     
             else
               occ_schedules_num_occ[num_ppl_sch] += num_ppl
-              max_occ_on_thermal_zone += num_ppl
             end
+            max_occ_on_thermal_zone += num_ppl
           end
         end
       end
@@ -150,32 +180,29 @@ class OpenStudio::Model::ThermalZone
           num_ppl = people.getNumberOfPeople(space.floorArea)
           if occ_schedules_num_occ[num_ppl_sch].nil?
             occ_schedules_num_occ[num_ppl_sch] = num_ppl
-            max_occ_on_thermal_zone += num_ppl     
           else
             occ_schedules_num_occ[num_ppl_sch] += num_ppl
-            max_occ_on_thermal_zone += num_ppl
           end
+          max_occ_on_thermal_zone += num_ppl
         end
       end
     end
-	   
+
     # For each day of the year, determine
-    #time_value_pairs = []
-    year = self.model.getYearDescription
+    # time_value_pairs = []
+    year = model.getYearDescription
     yearly_data = []
     yearly_times = OpenStudio::DateTimeVector.new
     yearly_values = []
-    for i in 1..365
-
+    (1..365).each do |i|
       times_on_this_day = []
       os_date = year.makeDate(i)
       day_of_week = os_date.dayOfWeek.valueName
-    
+
       # Get the unique time indices and corresponding day schedules
       occ_schedules_day_schs = {}
       day_sch_num_occ = {}
       occ_schedules_num_occ.each do |occ_sch, num_occ|
-        
         # Get the day schedules for this day
         # (there should only be one)
         day_schs = occ_sch.getDaySchedules(os_date, os_date)
@@ -183,7 +210,6 @@ class OpenStudio::Model::ThermalZone
           times_on_this_day << time.toString
         end
         day_sch_num_occ[day_schs[0]] = num_occ
-        
       end
 
       # Determine the total fraction for the airloop at each time
@@ -192,7 +218,6 @@ class OpenStudio::Model::ThermalZone
       daily_values = []
       daily_occs = []
       times_on_this_day.uniq.sort.each do |time|
-
         os_time = OpenStudio::Time.new(time)
         os_date_time = OpenStudio::DateTime.new(os_date, os_time)
         # Total number of people at each time
@@ -201,7 +226,7 @@ class OpenStudio::Model::ThermalZone
           occ_frac = day_sch.getValue(os_time)
           tot_occ_at_time += occ_frac * num_occ
         end
-      
+
         # Total fraction for the airloop at each time
         thermal_zone_occ_frac = tot_occ_at_time / max_occ_on_thermal_zone
         occ_status = 0 # unoccupied
@@ -214,36 +239,33 @@ class OpenStudio::Model::ThermalZone
         daily_os_times << os_time
         daily_values << occ_status
         daily_occs << thermal_zone_occ_frac.round(2)
-
       end
 
-     
       # Simplify the daily times to eliminate intermediate
       # points with the same value as the following point.
       simple_daily_times = []
       simple_daily_os_times = []
       simple_daily_values = []
       simple_daily_occs = []
-      daily_values.each_with_index do |value, i| 
-        next if value == daily_values[i+1]
-        simple_daily_times << daily_times[i]
-        simple_daily_os_times << daily_os_times[i]
-        simple_daily_values << daily_values[i]
-        simple_daily_occs << daily_occs[i]
+      daily_values.each_with_index do |value, j|
+        next if value == daily_values[j + 1]
+        simple_daily_times << daily_times[j]
+        simple_daily_os_times << daily_os_times[j]
+        simple_daily_values << daily_values[j]
+        simple_daily_occs << daily_occs[j]
       end
-       
-      # Store the daily values
-      yearly_data << {'date'=>os_date,'day_of_week'=>day_of_week,'times'=>simple_daily_times,'values'=>simple_daily_values,'daily_os_times'=>simple_daily_os_times, 'daily_occs'=>simple_daily_occs}
 
+      # Store the daily values
+      yearly_data << { 'date' => os_date, 'day_of_week' => day_of_week, 'times' => simple_daily_times, 'values' => simple_daily_values, 'daily_os_times' => simple_daily_os_times, 'daily_occs' => simple_daily_occs }
     end
-    
+
     # Create a TimeSeries from the data
-    #time_series = OpenStudio::TimeSeries.new(times, values, 'unitless')
+    # time_series = OpenStudio::TimeSeries.new(times, values, 'unitless')
 
     # Make a schedule ruleset
-    sch_name = "#{self.name} Occ Sch"
-    sch_ruleset = OpenStudio::Model::ScheduleRuleset.new(self.model)
-    sch_ruleset.setName("#{sch_name}")  
+    sch_name = "#{name} Occ Sch"
+    sch_ruleset = OpenStudio::Model::ScheduleRuleset.new(model)
+    sch_ruleset.setName(sch_name.to_s)
 
     # Default - All Occupied
     day_sch = sch_ruleset.defaultDaySchedule
@@ -251,84 +273,81 @@ class OpenStudio::Model::ThermalZone
     day_sch.addValue(OpenStudio::Time.new(0, 24, 0, 0), 1)
 
     # Winter Design Day - All Occupied
-    day_sch = OpenStudio::Model::ScheduleDay.new(self.model)
+    day_sch = OpenStudio::Model::ScheduleDay.new(model)
     sch_ruleset.setWinterDesignDaySchedule(day_sch)
     day_sch = sch_ruleset.winterDesignDaySchedule
     day_sch.setName("#{sch_name} Winter Design Day")
-    day_sch.addValue(OpenStudio::Time.new(0, 24, 0, 0), 1)     
+    day_sch.addValue(OpenStudio::Time.new(0, 24, 0, 0), 1)
 
     # Summer Design Day - All Occupied
-    day_sch = OpenStudio::Model::ScheduleDay.new(self.model)
+    day_sch = OpenStudio::Model::ScheduleDay.new(model)
     sch_ruleset.setSummerDesignDaySchedule(day_sch)
     day_sch = sch_ruleset.summerDesignDaySchedule
     day_sch.setName("#{sch_name} Summer Design Day")
     day_sch.addValue(OpenStudio::Time.new(0, 24, 0, 0), 1)
-    
+
     # Create ruleset schedules, attempting to create
     # the minimum number of unique rules.
-    ['Monday','Tuesday','Wednesday','Thursday','Friday','Saturday','Sunday'].each do |day_of_week|
+    ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday'].each do |weekday|
       end_of_prev_rule = yearly_data[0]['date']
-      yearly_data.each_with_index do |daily_data, i|
+      yearly_data.each_with_index do |daily_data, k|
         # Skip unless it is the day of week
         # currently under inspection
         day = daily_data['day_of_week']
-        next unless day == day_of_week
+        next unless day == weekday
         date = daily_data['date']
         times = daily_data['times']
         values = daily_data['values']
         daily_occs = daily_data['daily_occs']
-        
+
         # If the next (Monday, Tuesday, etc.)
         # is the same as today, keep going.
         # If the next is different, or if
         # we've reached the end of the year,
         # create a new rule
-        if !yearly_data[i+7].nil?
-          next_day_times = yearly_data[i+7]['times']
-          next_day_values = yearly_data[i+7]['values']
+        unless yearly_data[k + 7].nil?
+          next_day_times = yearly_data[k + 7]['times']
+          next_day_values = yearly_data[k + 7]['values']
           next if times == next_day_times && values == next_day_values
         end
-        
+
         daily_os_times = daily_data['daily_os_times']
         daily_occs = daily_data['daily_occs']
-        
+
         # If here, we need to make a rule to cover from the previous
         # rule to today
- 
+
         sch_rule = OpenStudio::Model::ScheduleRule.new(sch_ruleset)
-        sch_rule.setName("#{sch_name} #{day_of_week} Rule")
+        sch_rule.setName("#{sch_name} #{weekday} Rule")
         day_sch = sch_rule.daySchedule
-        day_sch.setName("#{sch_name} #{day_of_week}")
-        daily_os_times.each_with_index do |time, i|
-          value = values[i]
-          next if value == values[i+1] # Don't add breaks if same value
+        day_sch.setName("#{sch_name} #{weekday}")
+        daily_os_times.each_with_index do |time, l|
+          value = values[l]
+          next if value == values[l + 1] # Don't add breaks if same value
           day_sch.addValue(time, value)
         end
-        
+
         # Set the dates when the rule applies
         sch_rule.setStartDate(end_of_prev_rule)
         sch_rule.setEndDate(date)
 
         # Individual Days
-        sch_rule.setApplyMonday(true) if day_of_week == 'Monday'
-        sch_rule.setApplyTuesday(true) if day_of_week == 'Tuesday'
-        sch_rule.setApplyWednesday(true) if day_of_week == 'Wednesday'
-        sch_rule.setApplyThursday(true) if day_of_week == 'Thursday'
-        sch_rule.setApplyFriday(true) if day_of_week == 'Friday'
-        sch_rule.setApplySaturday(true) if day_of_week == 'Saturday'
-        sch_rule.setApplySunday(true) if day_of_week == 'Sunday'
-      
+        sch_rule.setApplyMonday(true) if weekday == 'Monday'
+        sch_rule.setApplyTuesday(true) if weekday == 'Tuesday'
+        sch_rule.setApplyWednesday(true) if weekday == 'Wednesday'
+        sch_rule.setApplyThursday(true) if weekday == 'Thursday'
+        sch_rule.setApplyFriday(true) if weekday == 'Friday'
+        sch_rule.setApplySaturday(true) if weekday == 'Saturday'
+        sch_rule.setApplySunday(true) if weekday == 'Sunday'
+
         # Reset the previous rule end date
         end_of_prev_rule = date + OpenStudio::Time.new(0, 24, 0, 0)
-      
       end
-      
     end
 
     return sch_ruleset
-      
-  end  
-  
+  end
+
   # Determine if the thermal zone is residential based on the
   # space type properties for the spaces in the zone.
   # If there are both residential and nonresidential spaces
@@ -337,52 +356,49 @@ class OpenStudio::Model::ThermalZone
   # it will be assumed nonresidential.
   #
   # return [Bool] true if residential, false if nonresidential
-  def is_residential(standard)
-  
+  def residential?(template)
     # Determine the respective areas
     res_area_m2 = 0
     nonres_area_m2 = 0
-    self.spaces.each do |space|
+    spaces.each do |space|
       # Ignore space if not part of total area
-      next if !space.partofTotalFloorArea
-      if space.is_residential(standard)
+      next unless space.partofTotalFloorArea
+      if space.residential?(template)
         res_area_m2 += space.floorArea
       else
         nonres_area_m2 += space.floorArea
       end
     end
-      
+
     # Determine which is larger
     is_res = false
     if res_area_m2 > nonres_area_m2
       is_res = true
-    end 
+    end
 
     return is_res
-  
-  end  
- 
-  # Determine if the thermal zone is a Fossil Fuel, 
+  end
+
+  # Determine if the thermal zone is a Fossil Fuel,
   # Fossil/Electric Hybrid, and Purchased Heat zone.
   # If not, it is an Electric or Other Zone.
   # This is as-defined by 90.1 Appendix G.
   #
-  # return [Bool] true if Fossil Fuel, 
-  # Fossil/Electric Hybrid, and Purchased Heat zone, 
+  # return [Bool] true if Fossil Fuel,
+  # Fossil/Electric Hybrid, and Purchased Heat zone,
   # false if Electric or Other.
   # To-do: It's not doing it properly right now. If you have a zone with a VRF + a DOAS (via an ATU SingleDUct Uncontrolled)
   # it'll pick up both natural gas and electricity and classify it as fossil fuel, when I would definitely classify it as electricity
-  def is_fossil_hybrid_or_purchased_heat
-  
+  def fossil_hybrid_or_purchased_heat?
     is_fossil = false
-  
+
     # Get an array of the heating fuels
     # used by the zone.  Possible values are
     # Electricity, NaturalGas, PropaneGas, FuelOil#1, FuelOil#2,
-    # Coal, Diesel, Gasoline, DistrictHeating, 
+    # Coal, Diesel, Gasoline, DistrictHeating,
     # and SolarEnergy.
-    htg_fuels = self.heating_fuels
-    
+    htg_fuels = heating_fuels
+
     if htg_fuels.include?('NaturalGas') ||
        htg_fuels.include?('PropaneGas') ||
        htg_fuels.include?('FuelOil#1') ||
@@ -391,46 +407,167 @@ class OpenStudio::Model::ThermalZone
        htg_fuels.include?('Diesel') ||
        htg_fuels.include?('Gasoline') ||
        htg_fuels.include?('DistrictHeating')
-       
+
       is_fossil = true
     end
-  
-    #OpenStudio::logFree(OpenStudio::Debug, "openstudio.Standards.Model", "For #{self.name}, heating fuels = #{htg_fuels.join(', ')}; is_fossil_hybrid_or_purchased_heat = #{is_fossil}.")
-  
+
+    # OpenStudio::logFree(OpenStudio::Debug, "openstudio.Standards.Model", "For #{self.name}, heating fuels = #{htg_fuels.join(', ')}; fossil_hybrid_or_purchased_heat? = #{is_fossil}.")
+
     return is_fossil
-  
   end
-  
+
+  # Determine if the thermal zone's fuel type category.
+  # Options are:
+  # fossil, electric, unconditioned
+  # If a customization is passed, additional categories may
+  # be returned.
+  # If 'Xcel Energy CO EDA', the type fossilandelectric is added.
+  # DistrictHeating is considered a fossil fuel since it is
+  # typically created by natural gas boilers.
+  #
+  # @return [String] the fuel type category
+  def fossil_or_electric_type(custom)
+    fossil = false
+    electric = false
+
+    # Fossil heating
+    htg_fuels = heating_fuels
+    if htg_fuels.include?('NaturalGas') ||
+       htg_fuels.include?('PropaneGas') ||
+       htg_fuels.include?('FuelOil#1') ||
+       htg_fuels.include?('FuelOil#2') ||
+       htg_fuels.include?('Coal') ||
+       htg_fuels.include?('Diesel') ||
+       htg_fuels.include?('Gasoline') ||
+       htg_fuels.include?('DistrictHeating')
+      fossil = true
+    end
+
+    # Electric heating
+    if htg_fuels.include?('Electricity')
+      electric = true
+    end
+
+    # Cooling fuels, for determining
+    # unconditioned zones
+    clg_fuels = cooling_fuels
+
+    # Categorize
+    fuel_type = nil
+    if fossil
+      # If uses any fossil, counts as fossil even if electric is present too
+      fuel_type = 'fossil'
+    elsif electric
+      fuel_type = 'electric'
+    elsif htg_fuels.size.zero? && clg_fuels.size.zero?
+      fuel_type = 'unconditioned'
+    else
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.Standards.Model', "For #{name}, could not determine fuel type, assuming fossil.  Heating fuels = #{htg_fuels.join(', ')}; cooling fuels = #{clg_fuels.join(', ')}.")
+      fuel_type = 'fossil'
+    end
+
+    # Customization for Xcel.
+    # Likely useful for other utility
+    # programs where fuel switching is important.
+    # This is primarily for systems where Gas is
+    # used at the central AHU and electric is
+    # used at the terminals/zones.  Examples
+    # include zone VRF/PTHP with gas-heated DOAS,
+    # and gas VAV with electric reheat
+    case custom
+    when 'Xcel Energy CO EDA'
+      if fossil && electric
+        fuel_type = 'fossilandelectric'
+      end
+    end
+
+    # OpenStudio::logFree(OpenStudio::Info, "openstudio.Standards.Model", "For #{self.name}, fuel type = #{fuel_type}.")
+
+    return fuel_type
+  end
+
+  # Determine if the thermal zone is
+  # Fossil/Purchased Heat/Electric Hybrid
+  #
+  # return [Bool] true if mixed
+  # Fossil/Electric Hybrid, and Purchased Heat zone
+  def mixed_heating_fuel?
+    is_mixed = false
+
+    # Get an array of the heating fuels
+    # used by the zone.  Possible values are
+    # Electricity, NaturalGas, PropaneGas, FuelOil#1, FuelOil#2,
+    # Coal, Diesel, Gasoline, DistrictHeating,
+    # and SolarEnergy.
+    htg_fuels = heating_fuels
+
+    # Includes fossil
+    fossil = false
+    if htg_fuels.include?('NaturalGas') ||
+       htg_fuels.include?('PropaneGas') ||
+       htg_fuels.include?('FuelOil#1') ||
+       htg_fuels.include?('FuelOil#2') ||
+       htg_fuels.include?('Coal') ||
+       htg_fuels.include?('Diesel') ||
+       htg_fuels.include?('Gasoline')
+
+      fossil = true
+    end
+
+    # Electric and fossil and district
+    if htg_fuels.include?('Electricity') && htg_fuels.include?('DistrictHeating') && fossil
+      is_mixed = true
+      OpenStudio.logFree(OpenStudio::Debug, 'openstudio.Standards.Model', "For #{name}, heating mixed electricity, fossil, and district.")
+    end
+
+    # Electric and fossil
+    if htg_fuels.include?('Electricity') && fossil
+      is_mixed = true
+      OpenStudio.logFree(OpenStudio::Debug, 'openstudio.Standards.Model', "For #{name}, heating mixed electricity and fossil.")
+    end
+
+    # Electric and district
+    if htg_fuels.include?('Electricity') && htg_fuels.include?('DistrictHeating')
+      is_mixed = true
+      OpenStudio.logFree(OpenStudio::Debug, 'openstudio.Standards.Model', "For #{name}, heating mixed electricity and district.")
+    end
+
+    # Fossil and district
+    if fossil && htg_fuels.include?('DistrictHeating')
+      is_mixed = true
+      OpenStudio.logFree(OpenStudio::Debug, 'openstudio.Standards.Model', "For #{name}, heating mixed fossil and district.")
+    end
+
+    return is_mixed
+  end
+
   # Determine the net area of the zone
   # Loops on each space, and checks if part of total floor area or not
   # If not part of total floor area, it is not added to the zone floor area
   # Will multiply it by the ZONE MULTIPLIER as well!
   #
   # @return [Double] the zone net floor area in m^2 (with multiplier taken into account)
-  #   @units square meters (m^2)
-  def get_net_area
+  def floor_area_with_zone_multipliers
     area_m2 = 0
-    zone_mult = self.multiplier
-    self.spaces.each do |space|
+    zone_mult = multiplier
+    spaces.each do |space|
       # If space is not part of floor area, we don't add it
-      next if !space.partofTotalFloorArea
+      next unless space.partofTotalFloorArea
       area_m2 += space.floorArea
     end
-    
+
     return area_m2 * zone_mult
-    
   end
-  
+
   # Infers the baseline system type based on the equipment
   # serving the zone and their heating/cooling fuels.
   # Only does a high-level inference; does not look for the
   # presence/absence of required controls, etc.
   #
-  # @return [String] Possible system types are 
-  # PTHP, PTAC, PSZ_AC, PSZ_HP, PVAV_Reheat, PVAV_PFP_Boxes, 
+  # @return [String] Possible system types are
+  # PTHP, PTAC, PSZ_AC, PSZ_HP, PVAV_Reheat, PVAV_PFP_Boxes,
   # VAV_Reheat, VAV_PFP_Boxes, Gas_Furnace, Electric_Furnace
   def infer_system_type
-
     # Determine the characteristics
     # of the equipment serving the zone
     has_air_loop = false
@@ -440,7 +577,7 @@ class OpenStudio::Model::ThermalZone
     has_ptac = false
     has_pthp = false
     has_unitheater = false
-    self.equipment.each do |equip|
+    equipment.each do |equip|
       # Skip HVAC components
       next unless equip.to_HVACComponent.is_initialized
       equip = equip.to_HVACComponent.get
@@ -463,15 +600,15 @@ class OpenStudio::Model::ThermalZone
         has_unitheater = true
       end
     end
-  
+
     # Get the zone heating and cooling fuels
-    htg_fuels = self.heating_fuels
-    clg_fuels = self.cooling_fuels
-    is_fossil = self.is_fossil_hybrid_or_purchased_heat
-  
+    htg_fuels = heating_fuels
+    clg_fuels = cooling_fuels
+    is_fossil = fossil_hybrid_or_purchased_heat?
+
     # Infer the HVAC type
     sys_type = 'Unknown'
-  
+
     # Single zone
     if air_loop_num_zones < 2
       # Gas
@@ -479,12 +616,12 @@ class OpenStudio::Model::ThermalZone
         # Air Loop
         if has_air_loop
           # Gas_Furnace (as air loop)
-          if cooling_fuels.size == 0
-            sys_type = 'Gas_Furnace'
-          # PSZ_AC 
-          else
-            sys_type = 'PSZ_AC'
-          end
+          sys_type = if cooling_fuels.size.zero?
+                       'Gas_Furnace'
+                     # PSZ_AC
+                     else
+                       'PSZ_AC'
+                     end
         # Zone Equipment
         else
           # Gas_Furnace (as unit heater)
@@ -495,18 +632,18 @@ class OpenStudio::Model::ThermalZone
           if has_ptac
             sys_type = 'PTAC'
           end
-        end 
+        end
       # Electric
       else
         # Air Loop
         if has_air_loop
           # Electric_Furnace (as air loop)
-          if cooling_fuels.size == 0
-            sys_type = 'Electric_Furnace'
-          # PSZ_HP
-          else
-            sys_type = 'PSZ_HP'
-          end
+          sys_type = if cooling_fuels.size.zero?
+                       'Electric_Furnace'
+                     # PSZ_HP
+                     else
+                       'PSZ_HP'
+                     end
         # Zone Equipment
         else
           # Electric_Furnace (as unit heater)
@@ -520,7 +657,7 @@ class OpenStudio::Model::ThermalZone
         end
       end
     # Multi-zone
-    else    
+    else
       # Gas
       if is_fossil
         # VAV_Reheat
@@ -543,27 +680,615 @@ class OpenStudio::Model::ThermalZone
         end
       end
     end
-  
+
     # Report out the characteristics for debugging if
     # the system type cannot be inferred.
     if sys_type == 'Unknown'
-      OpenStudio::logFree(OpenStudio::Warn, "openstudio.Standards.ThermalZone", "For #{self.name}, the baseline system type could not be inferred.")
-      OpenStudio::logFree(OpenStudio::Debug, "openstudio.Standards.ThermalZone", "***#{self.name}***")
-      OpenStudio::logFree(OpenStudio::Debug, "openstudio.Standards.ThermalZone", "system type = #{sys_type}")
-      OpenStudio::logFree(OpenStudio::Debug, "openstudio.Standards.ThermalZone", "has_air_loop = #{has_air_loop}")
-      OpenStudio::logFree(OpenStudio::Debug, "openstudio.Standards.ThermalZone", "air_loop_num_zones = #{air_loop_num_zones}")
-      OpenStudio::logFree(OpenStudio::Debug, "openstudio.Standards.ThermalZone", "air_loop_is_vav = #{air_loop_is_vav}")
-      OpenStudio::logFree(OpenStudio::Debug, "openstudio.Standards.ThermalZone", "air_loop_has_chw = #{air_loop_has_chw}")
-      OpenStudio::logFree(OpenStudio::Debug, "openstudio.Standards.ThermalZone", "has_ptac = #{has_ptac}")
-      OpenStudio::logFree(OpenStudio::Debug, "openstudio.Standards.ThermalZone", "has_pthp = #{has_pthp}")
-      OpenStudio::logFree(OpenStudio::Debug, "openstudio.Standards.ThermalZone", "has_unitheater = #{has_unitheater}")
-      OpenStudio::logFree(OpenStudio::Debug, "openstudio.Standards.ThermalZone", "htg_fuels = #{htg_fuels}")
-      OpenStudio::logFree(OpenStudio::Debug, "openstudio.Standards.ThermalZone", "clg_fuels = #{clg_fuels}")
-      OpenStudio::logFree(OpenStudio::Debug, "openstudio.Standards.ThermalZone", "is_fossil = #{is_fossil}")
-    end
-  
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.Standards.ThermalZone', "For #{name}, the baseline system type could not be inferred.")
+      OpenStudio.logFree(OpenStudio::Debug, 'openstudio.Standards.ThermalZone', "***#{name}***")
+      OpenStudio.logFree(OpenStudio::Debug, 'openstudio.Standards.ThermalZone', "system type = #{sys_type}")
+      OpenStudio.logFree(OpenStudio::Debug, 'openstudio.Standards.ThermalZone', "has_air_loop = #{has_air_loop}")
+      OpenStudio.logFree(OpenStudio::Debug, 'openstudio.Standards.ThermalZone', "air_loop_num_zones = #{air_loop_num_zones}")
+      OpenStudio.logFree(OpenStudio::Debug, 'openstudio.Standards.ThermalZone', "air_loop_is_vav = #{air_loop_is_vav}")
+      OpenStudio.logFree(OpenStudio::Debug, 'openstudio.Standards.ThermalZone', "air_loop_has_chw = #{air_loop_has_chw}")
+      OpenStudio.logFree(OpenStudio::Debug, 'openstudio.Standards.ThermalZone', "has_ptac = #{has_ptac}")
+      OpenStudio.logFree(OpenStudio::Debug, 'openstudio.Standards.ThermalZone', "has_pthp = #{has_pthp}")
+      OpenStudio.logFree(OpenStudio::Debug, 'openstudio.Standards.ThermalZone', "has_unitheater = #{has_unitheater}")
+      OpenStudio.logFree(OpenStudio::Debug, 'openstudio.Standards.ThermalZone', "htg_fuels = #{htg_fuels}")
+      OpenStudio.logFree(OpenStudio::Debug, 'openstudio.Standards.ThermalZone', "clg_fuels = #{clg_fuels}")
+      OpenStudio.logFree(OpenStudio::Debug, 'openstudio.Standards.ThermalZone', "is_fossil = #{is_fossil}")
+    end
+
     return sys_type
+  end
+
+  # Determines heating status.  If the zone has a thermostat
+  # with a maximum heating setpoint above 5C (41F),
+  # counts as heated.  Plenums are also assumed to be heated.
+  #
+  # @author Andrew Parker, Julien Marrec
+  # @return [Bool] true if heated, false if not
+  def heated?
+    temp_f = 41
+    temp_c = OpenStudio.convert(temp_f, 'F', 'C').get
+
+    htd = false
+
+    # Consider plenum zones heated
+    area_plenum = 0
+    area_non_plenum = 0
+    spaces.each do |space|
+      if space.plenum?
+        area_plenum += space.floorArea
+      else
+        area_non_plenum += space.floorArea
+      end
+    end
+
+    # Majority
+    if area_plenum > area_non_plenum
+      htd = true
+      return htd
+    end
+
+    # Unheated if no thermostat present
+    if thermostat.empty?
+      return htd
+    end
+
+    # Check the heating setpoint
+    tstat = thermostat.get
+    if tstat.to_ThermostatSetpointDualSetpoint
+      tstat = tstat.to_ThermostatSetpointDualSetpoint.get
+      htg_sch = tstat.getHeatingSchedule
+      if htg_sch.is_initialized
+        htg_sch = htg_sch.get
+        if htg_sch.to_ScheduleRuleset.is_initialized
+          htg_sch = htg_sch.to_ScheduleRuleset.get
+          max_c = htg_sch.annual_min_max_value['max']
+          if max_c > temp_c
+            htd = true
+          end
+        elsif htg_sch.to_ScheduleConstant.is_initialized
+          htg_sch = htg_sch.to_ScheduleConstant.get
+          max_c = htg_sch.annual_min_max_value['max']
+          if max_c > temp_c
+            htd = true
+          end
+        elsif htg_sch.to_ScheduleCompact.is_initialized
+          htg_sch = htg_sch.to_ScheduleCompact.get
+          max_c = htg_sch.annual_min_max_value['max']
+          if max_c > temp_c
+            htd = true
+          end
+        else
+          OpenStudio.logFree(OpenStudio::Debug, 'openstudio.Standards.ThermalZone', "Zone #{name} used an unknown schedule type for the heating setpoint; assuming heated.")
+          htd = true
+        end
+      end
+    elsif tstat.to_ZoneControlThermostatStagedDualSetpoint
+      tstat = tstat.to_ZoneControlThermostatStagedDualSetpoint.get
+      htg_sch = tstat.heatingTemperatureSetpointSchedule
+      if htg_sch.is_initialized
+        htg_sch = htg_sch.get
+        if htg_sch.to_ScheduleRuleset.is_initialized
+          htg_sch = htg_sch.to_ScheduleRuleset.get
+          max_c = htg_sch.annual_min_max_value['max']
+          if max_c > temp_c
+            htd = true
+          end
+        end
+      end
+    end
+
+    return htd
+  end
+
+  # Determines cooling status.  If the zone has a thermostat
+  # with a minimum cooling setpoint below 33C (91F),
+  # counts as cooled.  Plenums are also assumed to be cooled.
+  #
+  # @author Andrew Parker, Julien Marrec
+  # @return [Bool] true if cooled, false if not
+  def cooled?
+    temp_f = 91
+    temp_c = OpenStudio.convert(temp_f, 'F', 'C').get
+
+    cld = false
+
+    # Consider plenum zones cooled
+    area_plenum = 0
+    area_non_plenum = 0
+    spaces.each do |space|
+      if space.plenum?
+        area_plenum += space.floorArea
+      else
+        area_non_plenum += space.floorArea
+      end
+    end
+
+    # Majority
+    if area_plenum > area_non_plenum
+      cld = true
+      return cld
+    end
+
+    # Unheated if no thermostat present
+    if thermostat.empty?
+      return cld
+    end
+
+    # Check the cooling setpoint
+    tstat = thermostat.get
+    if tstat.to_ThermostatSetpointDualSetpoint
+      tstat = tstat.to_ThermostatSetpointDualSetpoint.get
+      clg_sch = tstat.getCoolingSchedule
+      if clg_sch.is_initialized
+        clg_sch = clg_sch.get
+        if clg_sch.to_ScheduleRuleset.is_initialized
+          clg_sch = clg_sch.to_ScheduleRuleset.get
+          min_c = clg_sch.annual_min_max_value['min']
+          if min_c < temp_c
+            cld = true
+          end
+        elsif clg_sch.to_ScheduleConstant.is_initialized
+          clg_sch = clg_sch.to_ScheduleConstant.get
+          min_c = clg_sch.annual_min_max_value['min']
+          if min_c < temp_c
+            cld = true
+          end
+        elsif clg_sch.to_ScheduleCompact.is_initialized
+          clg_sch = clg_sch.to_ScheduleCompact.get
+          min_c = clg_sch.annual_min_max_value['min']
+          if min_c < temp_c
+            cld = true
+          end
+        else
+          OpenStudio.logFree(OpenStudio::Debug, 'openstudio.Standards.ThermalZone', "Zone #{name} used an unknown schedule type for the cooling setpoint; assuming cooled.")
+          cld = true
+        end
+      end
+    elsif tstat.to_ZoneControlThermostatStagedDualSetpoint
+      tstat = tstat.to_ZoneControlThermostatStagedDualSetpoint.get
+      clg_sch = tstat.coolingTemperatureSetpointSchedule
+      if clg_sch.is_initialized
+        clg_sch = clg_sch.get
+        if clg_sch.to_ScheduleRuleset.is_initialized
+          clg_sch = clg_sch.to_ScheduleRuleset.get
+          min_c = clg_sch.annual_min_max_value['min']
+          if min_c < temp_c
+            cld = true
+          end
+        end
+      end
+    end
+
+    return cld
+  end
+
+  # Determine if the thermal zone is a plenum
+  # based on whether a majority of the spaces
+  # in the zone are plenums or not.
+  # @return [Bool] true if majority plenum, false if not
+  def plenum?
+    plenum_status = false
+
+    area_plenum = 0
+    area_non_plenum = 0
+    spaces.each do |space|
+      if space.plenum?
+        area_plenum += space.floorArea
+      else
+        area_non_plenum += space.floorArea
+      end
+    end
+
+    # Majority
+    if area_plenum > area_non_plenum
+      plenum_status = true
+    end
+
+    return plenum_status
+  end
+
+  # Determines whether the zone is conditioned per 90.1,
+  # which is based on heating and cooling loads.
+  #
+  # @param climate_zone [String] climate zone
+  # @return [String] NonResConditioned, ResConditioned, Semiheated, Unconditioned
+  # @todo add logic to detect indirectly-conditioned spaces
+  def conditioning_category(template, climate_zone)
+    # Get the heating load
+    htg_load_btu_per_ft2 = 0.0
+    htg_load_w_per_m2 = heatingDesignLoad
+    if htg_load_w_per_m2.is_initialized
+      htg_load_btu_per_ft2 = OpenStudio.convert(htg_load_w_per_m2.get, 'W/m^2', 'Btu/hr*ft^2').get
+    end
+
+    # Get the cooling load
+    clg_load_btu_per_ft2 = 0.0
+    clg_load_w_per_m2 = coolingDesignLoad
+    if clg_load_w_per_m2.is_initialized
+      clg_load_btu_per_ft2 = OpenStudio.convert(clg_load_w_per_m2.get, 'W/m^2', 'Btu/hr*ft^2').get
+    end
+
+    # Determine the heating limit based on climate zone
+    # From Table 3.1 Heated Space Criteria
+    htg_lim_btu_per_ft2 = 0.0
+    case climate_zone
+    when 'ASHRAE 169-2006-1A',
+        'ASHRAE 169-2006-1B',
+        'ASHRAE 169-2006-2A',
+        'ASHRAE 169-2006-2B'
+      htg_lim_btu_per_ft2 = 5
+    when 'ASHRAE 169-2006-3A',
+        'ASHRAE 169-2006-3B',
+        'ASHRAE 169-2006-3C'
+      htg_lim_btu_per_ft2 = 10
+    when 'ASHRAE 169-2006-4A',
+        'ASHRAE 169-2006-4B',
+        'ASHRAE 169-2006-4C',
+        'ASHRAE 169-2006-5A',
+        'ASHRAE 169-2006-5B',
+        'ASHRAE 169-2006-5C',
+      htg_lim_btu_per_ft2 = 15
+    when 'ASHRAE 169-2006-6A',
+        'ASHRAE 169-2006-6B',
+        'ASHRAE 169-2006-7A',
+        'ASHRAE 169-2006-7B',
+      htg_lim_btu_per_ft2 = 20
+    when
+        'ASHRAE 169-2006-8A',
+        'ASHRAE 169-2006-8B'
+      htg_lim_btu_per_ft2 = 25
+    end
+
+    # Cooling limit is climate-independent
+    clg_lim_btu_per_ft2 = 5
+
+    # Semiheated limit is climate-independent
+    semihtd_lim_btu_per_ft2 = 3.4
+
+    # Determine if residential
+    res = false
+    if residential?(template)
+      res = true
+    end
+
+    cond_cat = 'Unconditioned'
+    if htg_load_btu_per_ft2 > htg_lim_btu_per_ft2
+      OpenStudio.logFree(OpenStudio::Debug, 'openstudio.Standards.ThermalZone', "Zone #{name} is conditioned because heating load of #{htg_load_btu_per_ft2.round} Btu/hr*ft^2 exceeds minimum of #{htg_lim_btu_per_ft2.round} Btu/hr*ft^2.")
+      cond_cat = if res
+                   'ResConditioned'
+                 else
+                   'NonResConditioned'
+                 end
+    elsif clg_load_btu_per_ft2 > clg_lim_btu_per_ft2
+      OpenStudio.logFree(OpenStudio::Debug, 'openstudio.Standards.ThermalZone', "Zone #{name} is conditioned because cooling load of #{clg_load_btu_per_ft2.round} Btu/hr*ft^2 exceeds minimum of #{clg_lim_btu_per_ft2.round} Btu/hr*ft^2.")
+      cond_cat = if res
+                   'ResConditioned'
+                 else
+                   'NonResConditioned'
+                 end
+    elsif htg_load_btu_per_ft2 > semihtd_lim_btu_per_ft2
+      cond_cat = 'Semiheated'
+      OpenStudio.logFree(OpenStudio::Debug, 'openstudio.Standards.ThermalZone', "Zone #{name} is semiheated because heating load of #{htg_load_btu_per_ft2.round} Btu/hr*ft^2 exceeds minimum of #{semihtd_lim_btu_per_ft2.round} Btu/hr*ft^2.")
+    end
+
+    return cond_cat
+  end
+
+  # Calculate the heating supply temperature based on the
+  # specified delta-T. Delta-T is calculated based on the
+  # highest value found in the heating setpoint schedule.
+  #
+  # @return [Double] the design heating supply temperature, in C
+  # @todo Exception: 17F delta-T for labs
+  def prm_baseline_heating_design_supply_temperature
+    setpoint_c = nil
+
+    # Setpoint schedule
+    tstat = thermostatSetpointDualSetpoint
+    if tstat.is_initialized
+      tstat = tstat.get
+      setpoint_sch = tstat.heatingSetpointTemperatureSchedule
+      if setpoint_sch.is_initialized
+        setpoint_sch = setpoint_sch.get
+        if setpoint_sch.to_ScheduleRuleset.is_initialized
+          setpoint_sch = setpoint_sch.to_ScheduleRuleset.get
+          setpoint_c = setpoint_sch.annual_min_max_value['max']
+        elsif setpoint_sch.to_ScheduleConstant.is_initialized
+          setpoint_sch = setpoint_sch.to_ScheduleConstant.get
+          setpoint_c = setpoint_sch.annual_min_max_value['max']
+        elsif setpoint_sch.to_ScheduleCompact.is_initialized
+          setpoint_sch = setpoint_sch.to_ScheduleCompact.get
+          setpoint_c = setpoint_sch.annual_min_max_value['max']
+        end
+      end
+    end
+
+    # If the heating setpoint could not be determined
+    # return the current design heating temperature
+    if setpoint_c.nil?
+      setpoint_c = sizingZone.zoneHeatingDesignSupplyAirTemperature
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.Standards.ThermalZone', "For #{name}: could not determine max heating setpoint.  Design heating SAT will be #{OpenStudio.convert(setpoint_c, 'C', 'F').get.round} F from proposed model.")
+      return setpoint_c
+    end
+
+    # If the heating setpoint was set very low so that
+    # heating equipment never comes on
+    # return the current design heating temperature
+    if setpoint_c < OpenStudio.convert(41, 'F', 'C').get
+      setpoint_f = OpenStudio.convert(setpoint_c, 'C', 'F').get
+      new_setpoint_c = sizingZone.zoneHeatingDesignSupplyAirTemperature
+      new_setpoint_f = OpenStudio.convert(new_setpoint_c, 'C', 'F').get
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.Standards.ThermalZone', "For #{name}: max heating setpoint in proposed model was #{setpoint_f.round} F.  20 F SAT delta-T from this point is unreasonable. Design heating SAT will be #{new_setpoint_f.round} F from proposed model.")
+      return new_setpoint_c
+    end
+
+    # Add 20F delta-T
+    delta_t_r = 20
+    delta_t_k = OpenStudio.convert(delta_t_r, 'R', 'K').get
+
+    sat_c = setpoint_c + delta_t_k # Add for heating
 
+    return sat_c
   end
 
+  # Calculate the cooling supply temperature based on the
+  # specified delta-T. Delta-T is calculated based on the
+  # highest value found in the cooling setpoint schedule.
+  #
+  # @return [Double] the design heating supply temperature, in C
+  # @todo Exception: 17F delta-T for labs
+  def prm_baseline_cooling_design_supply_temperature
+    setpoint_c = nil
+
+    # Setpoint schedule
+    tstat = thermostatSetpointDualSetpoint
+    if tstat.is_initialized
+      tstat = tstat.get
+      setpoint_sch = tstat.coolingSetpointTemperatureSchedule
+      if setpoint_sch.is_initialized
+        setpoint_sch = setpoint_sch.get
+        if setpoint_sch.to_ScheduleRuleset.is_initialized
+          setpoint_sch = setpoint_sch.to_ScheduleRuleset.get
+          setpoint_c = setpoint_sch.annual_min_max_value['min']
+        elsif setpoint_sch.to_ScheduleConstant.is_initialized
+          setpoint_sch = setpoint_sch.to_ScheduleConstant.get
+          setpoint_c = setpoint_sch.annual_min_max_value['min']
+        elsif setpoint_sch.to_ScheduleCompact.is_initialized
+          setpoint_sch = setpoint_sch.to_ScheduleCompact.get
+          setpoint_c = setpoint_sch.annual_min_max_value['min']
+        end
+      end
+    end
+
+    # If the cooling setpoint could not be determined
+    # return the current design cooling temperature
+    if setpoint_c.nil?
+      setpoint_c = sizingZone.zoneCoolingDesignSupplyAirTemperature
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.Standards.ThermalZone', "For #{name}: could not determine min cooling setpoint.  Design cooling SAT will be #{OpenStudio.convert(setpoint_c, 'C', 'F').get.round} F from proposed model.")
+      return setpoint_c
+    end
+
+    # If the cooling setpoint was set very high so that
+    # cooling equipment never comes on
+    # return the current design cooling temperature
+    if setpoint_c > OpenStudio.convert(91, 'F', 'C').get
+      setpoint_f = OpenStudio.convert(setpoint_c, 'C', 'F').get
+      new_setpoint_c = sizingZone.zoneCoolingDesignSupplyAirTemperature
+      new_setpoint_f = OpenStudio.convert(new_setpoint_c, 'C', 'F').get
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.Standards.ThermalZone', "For #{name}: max cooling setpoint in proposed model was #{setpoint_f.round} F.  20 F SAT delta-T from this point is unreasonable. Design cooling SAT will be #{new_setpoint_f.round} F from proposed model.")
+      return new_setpoint_c
+    end
+
+    # Subtract 20F delta-T
+    delta_t_r = 20
+    delta_t_k = OpenStudio.convert(delta_t_r, 'R', 'K').get
+
+    sat_c = setpoint_c - delta_t_k # Subtract for cooling
+
+    return sat_c
+  end
+
+  # Set the design delta-T for zone heating and cooling sizing
+  # supply air temperatures.  This value determines zone
+  # air flows, which will be summed during system
+  # design airflow calculation.
+  #
+  # @return [Bool] true if successful, false if not
+  def apply_prm_baseline_supply_temperatures
+    # Skip spaces that aren't heated or cooled
+    return true unless heated? || cooled?
+
+    # Heating
+    htg_sat_c = prm_baseline_heating_design_supply_temperature
+    htg_success = sizingZone.setZoneHeatingDesignSupplyAirTemperature(htg_sat_c)
+
+    # Cooling
+    clg_sat_c = prm_baseline_cooling_design_supply_temperature
+    clg_success = sizingZone.setZoneCoolingDesignSupplyAirTemperature(clg_sat_c)
+
+    htg_sat_f = OpenStudio.convert(htg_sat_c, 'C', 'F').get
+    clg_sat_f = OpenStudio.convert(clg_sat_c, 'C', 'F').get
+    OpenStudio.logFree(OpenStudio::Debug, 'openstudio.Standards.ThermalZone', "For #{name}, Htg SAT = #{htg_sat_f.round(1)}F, Clg SAT = #{clg_sat_f.round(1)}F.")
+
+    result = false
+    if htg_success && clg_success
+      result = true
+    end
+
+    return result
+  end
+
+  def add_unconditioned_thermostat
+    # Heated to 0F (below heated? threshold)
+    htg_t_f = 0
+    htg_t_c = OpenStudio.convert(htg_t_f, 'F', 'C').get
+    htg_stpt_sch = OpenStudio::Model::ScheduleRuleset.new(model)
+    htg_stpt_sch.setName('Unconditioned Minimal Heating')
+    htg_stpt_sch.defaultDaySchedule.setName('Unconditioned Minimal Heating Default')
+    htg_stpt_sch.defaultDaySchedule.addValue(OpenStudio::Time.new(0, 24, 0, 0), htg_t_c)
+
+    # Cooled to 120F (above cooled? threshold)
+    clg_t_f = 120
+    clg_t_c = OpenStudio.convert(clg_t_f, 'F', 'C').get
+    clg_stpt_sch = OpenStudio::Model::ScheduleRuleset.new(model)
+    clg_stpt_sch.setName('Unconditioned Minimal Heating')
+    clg_stpt_sch.defaultDaySchedule.setName('Unconditioned Minimal Heating Default')
+    clg_stpt_sch.defaultDaySchedule.addValue(OpenStudio::Time.new(0, 24, 0, 0), clg_t_c)
+
+    # Thermostat
+    thermostat = OpenStudio::Model::ThermostatSetpointDualSetpoint.new(model)
+    thermostat.setName("#{name} Unconditioned Thermostat")
+    thermostat.setHeatingSetpointTemperatureSchedule(htg_stpt_sch)
+    thermostat.setCoolingSetpointTemperatureSchedule(clg_stpt_sch)
+
+    return true
+  end
+
+  # Determine the design internal load (W) for
+  # this zone without space multipliers.
+  # This include People, Lights, Electric Equipment,
+  # and Gas Equipment in all spaces in this zone.
+  # It assumes 100% of the wattage
+  # is converted to heat, and that the design peak
+  # schedule value is 1 (100%).
+  #
+  # @return [Double] the design internal load, in W
+  def design_internal_load
+    load_w = 0.0
+
+    spaces.each do |space|
+      load_w += space.design_internal_load
+    end
+
+    return load_w
+  end
+
+  # Returns the space type that represents a majority
+  # of the floor area.
+  #
+  # @return [Boost::Optional<OpenStudio::Model::SpaceType>] an optional SpaceType
+  def majority_space_type
+    space_type_to_area = Hash.new(0.0)
+
+    spaces.each do |space|
+      if space.spaceType.is_initialized
+        space_type = space.spaceType.get
+        space_type_to_area[space_type] += space.floorArea
+      end
+    end
+
+    # If no space types, return empty optional SpaceType
+    if space_type_to_area.size.zero?
+      return OpenStudio::Model::OptionalSpaceType.new
+    end
+
+    # Sort by area
+    biggest_space_type = space_type_to_area.sort_by { |st, area| area }.reverse[0][0]
+
+    return OpenStudio::Model::OptionalSpaceType.new(biggest_space_type)
+  end
+
+  # Determine if the thermal zone's occupancy type category.
+  # Options are:
+  # residential, nonresidential
+  # 90.1-2013 adds additional Options:
+  # publicassembly, retail
+  #
+  # @return [String] the occupancy type category
+  # @todo Add public assembly building types
+  def occupancy_type(template)
+    occ_type = if residential?(template)
+                 'residential'
+               else
+                 'nonresidential'
+               end
+
+    # Based on the space type that
+    # represents a majority of the zone.
+    if template == '90.1-2013'
+      space_type = majority_space_type
+      if space_type.is_initialized
+        space_type = space_type.get
+        bldg_type = space_type.standardsBuildingType
+        if bldg_type.is_initialized
+          bldg_type = bldg_type.get
+          case bldg_type
+          when 'Retail', 'StripMall', 'SuperMarket'
+            occ_type = 'retail'
+            # when 'SomeBuildingType' # TODO add publicassembly building types
+            # occ_type = 'publicassembly'
+          end
+        end
+      end
+    end
+
+    # OpenStudio::logFree(OpenStudio::Info, "openstudio.Standards.ThermalZone", "For #{self.name}, occupancy type = #{occ_type}.")
+
+    return occ_type
+  end
+
+  # Determine if demand control ventilation (DCV) is
+  # required for this zone based on area and occupant density.
+  # Does not account for System requirements like ERV, economizer, etc.
+  # Those are accounted for in the AirLoopHVAC method of the same name.
+  #
+  # @return [Bool] Returns true if required, false if not.
+  # @todo Add exception logic for 90.1-2013
+  #   for cells, sickrooms, labs, barbers, salons, and bowling alleys
+  def demand_control_ventilation_required?(template, climate_zone)
+    dcv_required = false
+
+    # Not required by the old vintages
+    if template == 'DOE Ref Pre-1980' || template == 'DOE Ref 1980-2004' || template == 'NECB 2011'
+      return dcv_required
+    end
+
+    # Area and occupant density limits
+    min_area_ft2 = 0
+    min_occ_per_1000_ft2 = 0
+    case template
+    when '90.1-2004'
+      min_area_ft2 = 0
+      min_occ_per_1000_ft2 = 100
+    when '90.1-2007', '90.1-2010'
+      min_area_ft2 = 500
+      min_occ_per_1000_ft2 = 40
+    when '90.1-2013'
+      min_area_ft2 = 500
+      min_occ_per_1000_ft2 = 25
+    end
+
+    # Get the area served and the number of occupants
+    area_served_m2 = 0
+    num_people = 0
+    spaces.each do |space|
+      area_served_m2 += space.floorArea
+      num_people += space.numberOfPeople
+    end
+
+    # Check the minimum area
+    area_served_ft2 = OpenStudio.convert(area_served_m2, 'm^2', 'ft^2').get
+    if area_served_ft2 < min_area_ft2
+      OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.ThermalZone', "For #{name}: DCV is not required since the area is #{area_served_ft2.round} ft2, but the minimum size is #{min_area_ft2.round} ft2.")
+      return dcv_required
+    end
+
+    # Check the minimum occupancy density
+    occ_per_ft2 = num_people / area_served_ft2
+    occ_per_1000_ft2 = occ_per_ft2 * 1000
+
+    if occ_per_1000_ft2 < min_occ_per_1000_ft2
+      OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.ThermalZone', "For #{name}: DCV is not required since the occupant density is #{occ_per_1000_ft2.round} people/1000 ft2, but the minimum occupant density is #{min_occ_per_1000_ft2.round} people/1000 ft2.")
+      return dcv_required
+    end
+
+    # If here, DCV is required
+    dcv_required = true
+
+    return dcv_required
+  end
 end