openstudio-standards 0.1.11 → 0.1.12

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

@@ -342,6 +342,12 @@ class OpenStudio::Model::AirLoopHVAC
 
     # Calculate and report the total area for debugging/testing
     floor_area_served_m2 = floor_area_served
+
+    if floor_area_served_m2 == 0
+      OpenStudio.logFree(OpenStudio::Warn,'openstudio.standards.AirLoopHVAC', "AirLoopHVAC #{self.name.to_s} serves zero floor area. Check that it has thermal zones attached to it, and that they have non-zero floor area'.")
+      return allowable_fan_bhp
+    end
+
     floor_area_served_ft2 = OpenStudio.convert(floor_area_served_m2, 'm^2', 'ft^2').get
     cfm_per_ft2 = dsn_air_flow_cfm / floor_area_served_ft2
     cfm_per_hp = dsn_air_flow_cfm / allowable_fan_bhp

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

@@ -26,6 +26,9 @@ def load_openstudio_standards_json
   standards_files << 'OpenStudio_Standards_templates.json'
   standards_files << 'OpenStudio_Standards_unitary_acs.json'
   standards_files << 'OpenStudio_Standards_heat_rejection.json'
+  standards_files << 'OpenStudio_Standards_exterior_lighting.json'
+  standards_files << 'OpenStudio_Standards_parking.json'
+  standards_files << 'OpenStudio_Standards_entryways.json'
   #    standards_files << 'OpenStudio_Standards_unitary_hps.json'
 
   # Combine the data from the JSON files into a single hash
@@ -2316,6 +2319,22 @@ class OpenStudio::Model::Model
     return desired_object
   end
 
+  # Create constant ScheduleRuleset
+  #
+  # @param [double] constant value
+  # @param [string] name
+  # @return schedule
+  def add_constant_schedule_ruleset(value,name = nil)
+    schedule = OpenStudio::Model::ScheduleRuleset.new(self)
+    if not name.nil?
+      schedule.setName(name)
+      schedule.defaultDaySchedule.setName("#{name} Default")
+    end
+    schedule.defaultDaySchedule.addValue(OpenStudio::Time.new(0, 24, 0, 0), value)
+
+    return schedule
+  end
+
   # Create a schedule from the openstudio standards dataset and
   # add it to the model.
   #
@@ -3137,19 +3156,10 @@ class OpenStudio::Model::Model
       building_type = getBuilding.standardsBuildingType.get
     end
 
-    # prototype small office approx 500 m^2
-    # prototype medium office approx 5000 m^2
-    # prototype large office approx 50,000 m^2
     # map office building type to small medium or large
     if building_type == 'Office' && remap_office
       open_studio_area = getBuilding.floorArea
-      building_type = if open_studio_area < 2750
-                        'SmallOffice'
-                      elsif open_studio_area < 25_250
-                        'MediumOffice'
-                      else
-                        'LargeOffice'
-                      end
+      building_type = self.remap_office(open_studio_area)
     end
 
     results = {}
@@ -3159,6 +3169,23 @@ class OpenStudio::Model::Model
     return results
   end
 
+  # remap office to one of the protptye buildings
+  # @param [Double] floor area
+  # @return [String] SmallOffice, MediumOffice, LargeOffice
+  def remap_office(floor_area)
+    # prototype small office approx 500 m^2
+    # prototype medium office approx 5000 m^2
+    # prototype large office approx 50,000 m^2
+    # map office building type to small medium or large
+    building_type = if floor_area < 2750
+                      'SmallOffice'
+                    elsif floor_area < 25_250
+                      'MediumOffice'
+                    else
+                      'LargeOffice'
+                    end
+  end
+
   # user needs to pass in template as string. The building type and climate zone will come from the model.
   # If the building type or ASHRAE climate zone is not set in the model this will return nil
   # If the lookup doesn't find matching simulation results this wil return nil
@@ -4297,6 +4324,217 @@ class OpenStudio::Model::Model
     end
   end
 
+  # Create sorted hash of stories with data need to determine effective number of stories above and below grade
+  # the key should be the story object, which would allow other measures the ability to for example loop through spaces of the bottom story
+  #
+  # @return [hash] hash of space types with data in value necessary to determine effective number of stories above and below grade
+  def create_story_hash
+
+    story_hash = {}
+
+    # loop through stories
+    self.getBuildingStorys.each do |story|
+
+      # skip of story doesn't have any spaces
+      next if story.spaces.size == 0
+
+      story_min_z = nil
+      story_zone_multipliers = []
+      story_spaces_part_of_floor_area = []
+      story_spaces_not_part_of_floor_area = []
+      story_ext_wall_area = 0.0
+      story_ground_wall_area = 0.0
+
+      # loop through space surfaces to find min z value
+      story.spaces.each do |space|
+
+        # skip of space doesn't have any geometry
+        next if space.surfaces.size == 0
+
+        # get space multiplier
+        story_zone_multipliers << space.multiplier
+
+        # space part of floor area check
+        if space.partofTotalFloorArea
+          story_spaces_part_of_floor_area << space
+        else
+          story_spaces_not_part_of_floor_area << space
+        end
+
+        # update exterior wall area (not sure if this is net or gross)
+        story_ext_wall_area += space.exteriorWallArea
+
+        space_min_z = nil
+        z_points = []
+        space.surfaces.each do |surface|
+          surface.vertices.each do |vertex|
+            z_points << vertex.z
+          end
+
+          # update count of ground wall areas
+          next if not surface.surfaceType == "Wall"
+          next if not surface.outsideBoundaryCondition == "Ground" # todo - make more flexible for slab/basement modeling
+          story_ground_wall_area += surface.grossArea
+
+        end
+
+        # skip if surface had no vertices
+        next if z_points.size == 0
+
+        # update story min_z
+        space_min_z = z_points.min + space.zOrigin
+        if story_min_z.nil? or story_min_z > space_min_z
+          story_min_z = space_min_z
+        end
+
+      end
+
+      # update story hash
+      story_hash[story] = {}
+      story_hash[story][:min_z] = story_min_z
+      story_hash[story][:multipliers] = story_zone_multipliers
+      story_hash[story][:part_of_floor_area] = story_spaces_part_of_floor_area
+      story_hash[story][:not_part_of_floor_area] = story_spaces_not_part_of_floor_area
+      story_hash[story][:ext_wall_area] = story_ext_wall_area
+      story_hash[story][:ground_wall_area] = story_ground_wall_area
+
+    end
+
+    # sort hash by min_z low to high
+    story_hash = story_hash.sort_by{|k,v| v[:min_z]}
+
+    # reassemble into hash after sorting
+    hash = {}
+    story_hash.each do |story, props|
+      hash[story] = props
+    end
+
+    return hash
+
+  end
+
+  # populate this method
+  # Determine the effective number of stories above and below grade
+  #
+  # @return hash with effective_num_stories_below_grade and effective_num_stories_above_grade
+  def effective_num_stories
+
+    below_grade = 0
+    above_grade = 0
+
+    # call create_story_hash
+    story_hash = self.create_story_hash
+
+    story_hash.each do |story,hash|
+
+      # skip if no spaces in story are included in the building area
+      next if hash[:part_of_floor_area].size == 0
+
+      # only count as below grade if ground wall area is greater than ext wall area and story below is also below grade
+      if above_grade == 0 and hash[:ground_wall_area] > hash[:ext_wall_area]
+        below_grade += 1 * hash[:multipliers].min
+      else
+        above_grade += 1 * hash[:multipliers].min
+      end
+
+    end
+
+    # populate hash
+    effective_num_stories = {}
+    effective_num_stories[:below_grade] = below_grade
+    effective_num_stories[:above_grade] = above_grade
+    effective_num_stories[:story_hash] = story_hash
+
+    return effective_num_stories
+
+  end
+
+  # create space_type_hash with info such as effective_num_spaces, num_units, num_meds, num_meals
+  #
+  # @param template [String]
+  # @param trust_effective_num_spaces [Bool] defaults to false - set to true if modeled every space as a real rpp, vs. space as collection of rooms
+  # @return [hash] hash of space types with misc information
+  # @todo - add code when determining number of units to makeuse of trust_effective_num_spaces arg
+  def create_space_type_hash(template,trust_effective_num_spaces = false)
+
+    # assumed class size to deduct teachers from occupant count for classrooms
+    typical_class_size = 20.0
+
+    space_type_hash = {}
+    self.getSpaceTypes.each do |space_type|
+
+      # get standards info
+      stds_bldg_type = space_type.standardsBuildingType
+      stds_space_type = space_type.standardsSpaceType
+      if stds_bldg_type.is_initialized and stds_space_type.is_initialized and space_type.spaces.size > 0
+        stds_bldg_type = stds_bldg_type.get
+        stds_space_type = stds_space_type.get
+        effective_num_spaces = 0
+        floor_area = 0.0
+        num_people = 0.0
+        num_students = 0.0
+        num_units = 0.0
+        num_beds = 0.0
+        num_people_bldg_total = nil # may need this in future, not same as sumo of people for all space types.
+        num_meals = nil
+        # determine num_elevators in another method
+        # determine num_parking_spots in another method
+
+        # loop through spaces to get mis values
+        space_type.spaces.each do |space|
+          next if not space.partofTotalFloorArea
+          effective_num_spaces += space.multiplier
+          floor_area += space.floorArea * space.multiplier
+          num_people += space.numberOfPeople * space.multiplier
+
+        end
+
+        # determine number of units
+        if stds_bldg_type == "SmallHotel" && stds_space_type.include?("GuestRoom") # doesn't always == GuestRoom so use include?
+          avg_unit_size = OpenStudio::convert(354.2,"ft^2","m^2").get # calculated from prototype
+          num_units = floor_area / avg_unit_size
+        elsif stds_bldg_type == "LargeHotel" && stds_space_type.include?("GuestRoom")
+          avg_unit_size = OpenStudio::convert(279.7,"ft^2","m^2").get # calculated from prototype
+          num_units = floor_area / avg_unit_size
+        elsif stds_bldg_type == "MidriseApartment" && stds_space_type.include?("Apartment")
+          avg_unit_size = OpenStudio::convert(949.9,"ft^2","m^2").get # calculated from prototype
+          num_units = floor_area / avg_unit_size
+        elsif stds_bldg_type == "HighriseApartment" && stds_space_type.include?("Apartment")
+          avg_unit_size = OpenStudio::convert(949.9,"ft^2","m^2").get # calculated from prototype
+          num_units = floor_area / avg_unit_size
+        elsif stds_bldg_type == "StripMall"
+          avg_unit_size = OpenStudio::convert(22500.0/10.0,"ft^2","m^2").get # calculated from prototype
+          num_units = floor_area / avg_unit_size
+        end
+
+        # determine number of beds
+        if stds_bldg_type == "Hospital" && ["PatRoom","ICU_PatRm","ICU_Open"].include?(stds_space_type)
+          num_beds = num_people
+        end
+
+        # determine number of students
+        if ["PrimarySchool","SecondarySchool"].include?(stds_bldg_type) && stds_space_type == "Classroom"
+          num_students += num_people * ((typical_class_size - 1.0)/typical_class_size)
+        end
+
+        space_type_hash[space_type] = {}
+        space_type_hash[space_type][:stds_bldg_type] = stds_bldg_type
+        space_type_hash[space_type][:stds_space_type] = stds_space_type
+        space_type_hash[space_type][:effective_num_spaces] = effective_num_spaces
+        space_type_hash[space_type][:floor_area] = floor_area
+        space_type_hash[space_type][:num_people] = num_people
+        space_type_hash[space_type][:num_students] = num_students
+        space_type_hash[space_type][:num_units] = num_units
+        space_type_hash[space_type][:num_beds] = num_beds
+
+      else
+        OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.Model', "Cannot identify standards buidling type and space type for #{space_type.name}, it won't be added to space_type_hash.")
+      end
+    end
+
+    return space_type_hash
+  end
+
   private
 
   # Helper method to fill in hourly values
@@ -4401,4 +4639,5 @@ class OpenStudio::Model::Model
     return true
     
   end
+
 end

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

@@ -125,7 +125,7 @@ class OpenStudio::Model::SpaceType
       end
 
       # Modify the definition of the instance
-      instances.each do |inst|
+      people.sort.each do |inst|
         definition = inst.peopleDefinition
         unless occupancy_per_area.zero?
           definition.setPeopleperSpaceFloorArea(OpenStudio.convert(occupancy_per_area / 1000, 'people/ft^2', 'people/m^2').get)
@@ -207,7 +207,7 @@ class OpenStudio::Model::SpaceType
       end
 
       # Modify the definition of the instance
-      instances.each do |inst|
+      lights.sort.each do |inst|
         definition = inst.lightsDefinition
         unless lighting_per_area.zero?
           definition.setWattsperSpaceFloorArea(OpenStudio.convert(lighting_per_area.to_f, 'W/ft^2', 'W/m^2').get)
@@ -276,7 +276,7 @@ class OpenStudio::Model::SpaceType
       end
 
       # Modify the definition of the instance
-      instances.each do |inst|
+      electricEquipment.sort.each do |inst|
         definition = inst.electricEquipmentDefinition
         unless elec_equip_per_area.zero?
           definition.setWattsperSpaceFloorArea(OpenStudio.convert(elec_equip_per_area.to_f, 'W/ft^2', 'W/m^2').get)
@@ -324,7 +324,7 @@ class OpenStudio::Model::SpaceType
       end
 
       # Modify the definition of the instance
-      instances.each do |inst|
+      gasEquipment.sort.each do |inst|
         definition = inst.gasEquipmentDefinition
         unless gas_equip_per_area.zero?
           definition.setWattsperSpaceFloorArea(OpenStudio.convert(gas_equip_per_area.to_f, 'Btu/hr*ft^2', 'W/m^2').get)
@@ -419,7 +419,7 @@ class OpenStudio::Model::SpaceType
       end
 
       # Modify each instance
-      instances.each do |inst|
+      spaceInfiltrationDesignFlowRates.sort.each do |inst|
         unless infiltration_per_area_ext.zero?
           inst.setFlowperExteriorSurfaceArea(OpenStudio.convert(infiltration_per_area_ext.to_f, 'ft^3/min*ft^2', 'm^3/s*m^2').get)
           OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.SpaceType', "#{name} set infiltration to #{ventilation_ach} per ft^2 exterior surface area.")

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

@@ -1401,4 +1401,165 @@ class OpenStudio::Model::ThermalZone
 
     return dcv_required
   end
+
+  # Add Exhaust Fans based on space type lookup
+  # This measure doesn't look if DCV is needed. Others methods can check if DCV needed and add it
+  #
+  # @param template [String] Valid choices are
+  # @return [Hash] Hash of newly made exhaust fan objects along with secondary exhaust and zone mixing objects
+  # @todo - Combine availability and fraction flow schedule to make zone mixing schedule
+  def add_exhaust(template,exhaust_makeup_inputs = {})
+
+    exhaust_fans = {} # key is primary exhaust value is hash of arrays of secondary objects
+
+    # hash to store space type information
+    space_type_hash = {} # key is space type value is floor_area_si
+
+    # get space type ratio for spaces in zone, making more than one exhaust fan if necessary
+    self.spaces.each do |space|
+      next if not space.spaceType.is_initialized
+      next if not space.partofTotalFloorArea
+      space_type = space.spaceType.get
+      if space_type_hash.has_key?(space_type)
+        space_type_hash[space_type] += space.floorArea # excluding space.multiplier since used to calc loads in zone
+      else
+        next if not space_type.standardsBuildingType.is_initialized
+        next if not space_type.standardsSpaceType.is_initialized
+        space_type_hash[space_type] = space.floorArea # excluding space.multiplier since used to calc loads in zone
+      end
+
+    end
+
+    # loop through space type hash and add exhaust as needed
+    space_type_hash.each do |space_type,floor_area|
+
+      # get floor custom or calculated floor area for max flow rate calculation
+      makeup_target = [space_type.standardsBuildingType.get,space_type.standardsSpaceType.get]
+      if exhaust_makeup_inputs.has_key?(makeup_target) and exhaust_makeup_inputs[makeup_target].has_key?(:target_effective_floor_area)
+        # pass in custom floor area
+        floor_area_si = exhaust_makeup_inputs[makeup_target][:target_effective_floor_area] / self.multiplier.to_f
+        floor_area_ip = OpenStudio.convert(floor_area_si,'m^2','ft^2').get
+      else
+        floor_area_ip = OpenStudio.convert(floor_area,'m^2','ft^2').get
+      end
+
+      space_type_properties = space_type.get_standards_data(template)
+      exhaust_per_area = space_type_properties['exhaust_per_area']
+      next if exhaust_per_area.nil?
+      maximum_flow_rate_ip = exhaust_per_area * floor_area_ip
+      maximum_flow_rate_si = OpenStudio.convert(maximum_flow_rate_ip,'cfm','m^3/s').get
+      if space_type_properties['exhaust_schedule'].nil?
+        exhaust_schedule = model.alwaysOnDiscreteSchedule
+      else
+        sch_name = space_type_properties['exhaust_schedule']
+        exhaust_schedule = model.add_schedule(sch_name)
+      end
+
+      # add exhaust fans
+      zone_exhaust_fan = OpenStudio::Model::FanZoneExhaust.new(model)
+      zone_exhaust_fan.setName(self.name.to_s + ' Exhaust Fan')
+      zone_exhaust_fan.setAvailabilitySchedule(exhaust_schedule)
+      # not using zone_exhaust_fan.setFlowFractionSchedule. Exhaust fans are on when available
+      zone_exhaust_fan.setMaximumFlowRate(maximum_flow_rate_si)
+      zone_exhaust_fan.setEndUseSubcategory('Zone Exhaust Fans')
+      zone_exhaust_fan.addToThermalZone(self)
+      exhaust_fans[zone_exhaust_fan] = {} # keys are :zone_mixing and :transfer_air_source_zone_exhaust
+
+      # set fan pressure rise
+      zone_exhaust_fan.apply_prototype_fan_pressure_rise
+
+      # update efficiency and pressure rise
+      zone_exhaust_fan.apply_prototype_fan_efficiency(template)
+
+      # add and alter objectxs related to zone exhaust makeup air
+      if exhaust_makeup_inputs.has_key?(makeup_target) and exhaust_makeup_inputs[makeup_target][:source_zone]
+
+        # add balanced schedule to zone_exhaust_fan
+        balanced_sch_name = space_type_properties['balanced_exhaust_fraction_schedule']
+        balanced_exhaust_schedule = model.add_schedule(balanced_sch_name).to_ScheduleRuleset.get
+        zone_exhaust_fan.setBalancedExhaustFractionSchedule(balanced_exhaust_schedule)
+
+        # use max value of balanced exhaust fraction schedule for maximum flow rate
+        max_sch_val = balanced_exhaust_schedule.annual_min_max_value['max']
+        transfer_air_zone_mixing_si = maximum_flow_rate_si * max_sch_val
+
+        # add dummy exhaust fan to a transfer_air_source_zones
+        transfer_air_source_zone_exhaust = OpenStudio::Model::FanZoneExhaust.new(model)
+        transfer_air_source_zone_exhaust.setName(self.name.to_s + ' Transfer Air Source')
+        transfer_air_source_zone_exhaust.setAvailabilitySchedule(exhaust_schedule)
+        # not using zone_exhaust_fan.setFlowFractionSchedule. Exhaust fans are on when available
+        transfer_air_source_zone_exhaust.setMaximumFlowRate(transfer_air_zone_mixing_si)
+        transfer_air_source_zone_exhaust.setFanEfficiency(1.0)
+        transfer_air_source_zone_exhaust.setPressureRise(0.0)
+        transfer_air_source_zone_exhaust.setEndUseSubcategory('Zone Exhaust Fans')
+        transfer_air_source_zone_exhaust.addToThermalZone(exhaust_makeup_inputs[makeup_target][:source_zone])
+        exhaust_fans[zone_exhaust_fan][:transfer_air_source_zone_exhaust] = transfer_air_source_zone_exhaust
+
+        # todo - make zone mixing schedule by combining exhaust availability and fraction flow
+        zone_mixing_schedule = exhaust_schedule
+
+        # add zone mixing
+        zone_mixing = OpenStudio::Model::ZoneMixing.new(self)
+        zone_mixing.setSchedule(zone_mixing_schedule)
+        zone_mixing.setSourceZone(exhaust_makeup_inputs[makeup_target][:source_zone])
+        zone_mixing.setDesignFlowRate(transfer_air_zone_mixing_si)
+        exhaust_fans[zone_exhaust_fan][:zone_mixing] = zone_mixing
+
+      end
+
+    end
+
+    return exhaust_fans
+
+  end
+
+  # returns adjacant_zones_with_shared_wall_areas
+  #
+  # @param [Bool] same_floor (only valid option for now is true)
+  # @return [Array] adjacent zones
+  def get_adjacent_zones_with_shared_wall_areas(same_floor = true)
+
+    adjacent_zones = []
+
+    self.spaces.each do |space|
+      adj_spaces = space.get_adjacent_spaces_with_shared_wall_areas
+      adj_spaces.each do |k,v|
+        # skip if space is in current thermal zone.
+        next if not space.thermalZone.is_initialized
+        next if k.thermalZone.get == self
+        adjacent_zones << k.thermalZone.get
+      end
+    end
+
+    adjacent_zones = adjacent_zones.uniq
+
+    return adjacent_zones
+
+  end
+
+  # returns true if DCV is required for exhaust fan for specified tempate
+  #
+  # @param template [String] Valid choices are
+  # @return [Bool] returns true if DCV is required for exhaust fan for specified tempate
+  def exhaust_fan_dcv_required?(template)
+
+  end
+
+  # Add DCV to exhaust fan and if requsted to related objects
+  #
+  # @param template [Bool] defaults to true to change associated objects
+  # @param template [Array] related zone mixing objects
+  # @param template [Array] related transfer_air_source_zones
+  # @param template [Bool] defaults to true to change associated objects
+  # @return [Bool] not sure if there is anything to turn here other than if it was sucessful, no new objects made?
+  def add_exhaust_fan_dcv(change_related_objects = true,zone_mixing_objects = [],transfer_air_source_zones = [])
+
+    # set flow fraction schedule for all zone exhaust fans and then set zone mixing schedule to the intersection of exhaust avaialability and exhaust fractional schedule
+
+    # are there associated zone mixing or dummy exhaust objects that need to change when this changes?
+    # How are these ojects identifed?
+    # If this is run directly after add_exhaust it will return a hash where each key is an exhaust object and hash is a hash of related zone mizing and dummy exhaust from the source zone
+
+  end
+
 end