openstudio-standards 0.8.5 → 0.8.7

data/lib/openstudio-standards/constructions/materials/information.rb

@@ -28,7 +28,7 @@ module OpenstudioStandards
         # Gas
         # Convert C to K
         temperature_k = temperature + 273.0
-        conductance = material.to_Gas.get.getThermalConductivity(temperature_k) unless material.to_Gas.empty?
+        conductance = material.to_Gas.get.getThermalConductance(temperature_k) unless material.to_Gas.empty?
         conductance = material.to_GasMixture.get.getThermalConductance(temperature_k) unless material.to_GasMixture.empty?
 
         if conductance.nil?

data/lib/openstudio-standards/create_typical/create_typical.rb

@@ -992,7 +992,7 @@ module OpenstudioStandards
         end
 
         # set climate zone
-        os_climate_zone = climate_zone.gsub('ASHRAE 169-2013-', '')
+        os_climate_zone = climate_zone.gsub(/ASHRAE .*-.*-/, '')
         # trim off letter from climate zone 7 or 8
         if (os_climate_zone[0] == '7') || (os_climate_zone[0] == '8')
           os_climate_zone = os_climate_zone[0]

data/lib/openstudio-standards/exterior_lighting/create.rb

@@ -178,26 +178,45 @@ module OpenstudioStandards
         end
 
         # create exterior lights
-        OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.ExteriorLighting', "Added #{power.round(2)} W/ft^2 of lighting for #{multiplier} ft^2 of parking area.")
-        ext_lights = OpenstudioStandards::ExteriorLighting.model_create_exterior_lights(model,
-                                                                                        name: 'Parking Areas and Drives',
-                                                                                        power: power,
-                                                                                        units: 'W/ft^2',
-                                                                                        multiplier: multiplier,
-                                                                                        schedule: ext_lights_sch_other,
-                                                                                        control_option: control_option)
-        exterior_lights << ext_lights
-        installed_power += power * multiplier
+        if power > 0
+          ext_lights = OpenstudioStandards::ExteriorLighting.model_create_exterior_lights(model,
+                                                                                          name: 'Parking Areas and Drives',
+                                                                                          power: power,
+                                                                                          units: 'W/ft^2',
+                                                                                          multiplier: multiplier,
+                                                                                          schedule: ext_lights_sch_other,
+                                                                                          control_option: control_option)
+          exterior_lights << ext_lights
+          installed_power += power * multiplier
+          OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.ExteriorLighting', "Added #{power.round(2)} W/ft^2 of lighting for #{multiplier} ft^2 of parking area.")
+        else
+          OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.ExteriorLighting', "No lighting added for parking area, as power is 0 W/ft^2.")
+        end
       end
 
       # add exterior lights for facades
-      if !area_length_count_hash[:building_facades].nil? && area_length_count_hash[:building_facades] > 0
-        # lighting values
-        multiplier = area_length_count_hash[:building_facades]
-
-        # get power
-        if exterior_lighting_properties.key?('building_facades')
+      if !area_length_count_hash[:building_facades_area].nil? && area_length_count_hash[:building_facades_area] > 0
+        # determine power and multiplier based on available data
+        # use per permimter values if available, otherwise fall back to area based values
+        if exterior_lighting_properties.key?('building_facades_per_perimeter') &&
+           !area_length_count_hash[:building_perimeter].nil? && area_length_count_hash[:building_perimeter] > 0
+          # perimeter-based approach with building-type differentiation
+          perimeter_rates = exterior_lighting_properties['building_facades_per_perimeter']
+          bldg_type = area_length_count_hash[:largest_building_type]
+          power = if !bldg_type.nil? && perimeter_rates.key?(bldg_type)
+                    perimeter_rates[bldg_type]
+                  else
+                    perimeter_rates['default']
+                  end
+          multiplier = area_length_count_hash[:building_perimeter]
+          units = 'W/ft'
+          OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.ExteriorLighting', "Added #{power.round(2)} W/ft of lighting for #{multiplier.round(1)} ft of building perimeter (building type: #{bldg_type}).")
+        elsif exterior_lighting_properties.key?('building_facades')
+          # area-based fallback
           power = exterior_lighting_properties['building_facades']
+          multiplier = area_length_count_hash[:building_facades_area]
+          units = 'W/ft^2'
+          OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.ExteriorLighting', "Added #{power.round(2)} W/ft^2 of lighting for #{multiplier} ft^2 of building facade area.")
         else
           search_criteria = {
             'template' => lookup_key,
@@ -207,19 +226,26 @@ module OpenstudioStandards
           }
           exterior_lighting_facade_req = standard.standards_lookup_table_first(table_name: 'exterior_lighting', search_criteria: search_criteria)
           power = exterior_lighting_facade_req['allowance']
+          multiplier = area_length_count_hash[:building_facades_area]
+          units = 'W/ft^2'
+          OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.ExteriorLighting', "Added #{power.round(2)} W/ft^2 of lighting for #{multiplier} ft^2 of building facade area.")
         end
 
         # create exterior lights
-        OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.ExteriorLighting', "Added #{power.round(2)} W/ft^2 of lighting for #{multiplier} ft^2 of building facade area.")
-        ext_lights = OpenstudioStandards::ExteriorLighting.model_create_exterior_lights(model,
-                                                                                        name: 'Building Facades',
-                                                                                        power: power,
-                                                                                        units: 'W/ft^2',
-                                                                                        multiplier: multiplier,
-                                                                                        schedule: ext_lights_sch_facade_and_landscape,
-                                                                                        control_option: 'ScheduleNameOnly')
-        exterior_lights << ext_lights
-        installed_power += power * multiplier
+        if power > 0
+          ext_lights = OpenstudioStandards::ExteriorLighting.model_create_exterior_lights(model,
+                                                                                          name: 'Building Facades',
+                                                                                          power: power,
+                                                                                          units: units,
+                                                                                          multiplier: multiplier,
+                                                                                          schedule: ext_lights_sch_facade_and_landscape,
+                                                                                          control_option: 'ScheduleNameOnly')
+          exterior_lights << ext_lights
+          installed_power += power * multiplier
+          OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.ExteriorLighting', "Added #{power.round(2)} #{units} of lighting for #{multiplier} #{units == 'W/ft' ? 'ft perimeter' : 'ft^2 area'} of building facade.")
+        else
+          OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.ExteriorLighting', "No lighting added for building facades, as power is 0 #{units}.")
+        end
       end
 
       # add exterior lights for main entries
@@ -250,16 +276,20 @@ module OpenstudioStandards
         end
 
         # create exterior lights
-        OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.ExteriorLighting', "Added #{power.round(2)} W/ft of lighting for #{multiplier} ft of main entry length.")
-        ext_lights = OpenstudioStandards::ExteriorLighting.model_create_exterior_lights(model,
-                                                                                        name: 'Main Entries',
-                                                                                        power: power,
-                                                                                        units: 'W/ft',
-                                                                                        multiplier: multiplier,
-                                                                                        schedule: ext_lights_sch_other,
-                                                                                        control_option: control_option)
-        exterior_lights << ext_lights
-        installed_power += power * multiplier
+        if power > 0
+          ext_lights = OpenstudioStandards::ExteriorLighting.model_create_exterior_lights(model,
+                                                                                          name: 'Main Entries',
+                                                                                          power: power,
+                                                                                          units: 'W/ft',
+                                                                                          multiplier: multiplier,
+                                                                                          schedule: ext_lights_sch_other,
+                                                                                          control_option: control_option)
+          exterior_lights << ext_lights
+          installed_power += power * multiplier
+          OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.ExteriorLighting', "Added #{power.round(2)} W/ft of lighting for #{multiplier} ft of main entry length.")
+        else
+          OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.ExteriorLighting', "No lighting added for main entries, as power is 0 W/ft.")
+        end
       end
 
       # add exterior lights for other doors
@@ -290,16 +320,20 @@ module OpenstudioStandards
         end
 
         # create exterior lights
-        OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.ExteriorLighting', "Added #{power.round(2)} W/ft of lighting for #{multiplier} ft of other doors.")
-        ext_lights = OpenstudioStandards::ExteriorLighting.model_create_exterior_lights(model,
-                                                                                        name: 'Other Doors',
-                                                                                        power: power,
-                                                                                        units: 'W/ft',
-                                                                                        multiplier: multiplier,
-                                                                                        schedule: ext_lights_sch_other,
-                                                                                        control_option: control_option)
-        exterior_lights << ext_lights
-        installed_power += power * multiplier
+        if power > 0
+          ext_lights = OpenstudioStandards::ExteriorLighting.model_create_exterior_lights(model,
+                                                                                          name: 'Other Doors',
+                                                                                          power: power,
+                                                                                          units: 'W/ft',
+                                                                                          multiplier: multiplier,
+                                                                                          schedule: ext_lights_sch_other,
+                                                                                          control_option: control_option)
+          exterior_lights << ext_lights
+          installed_power += power * multiplier
+          OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.ExteriorLighting', "Added #{power.round(2)} W/ft of lighting for #{multiplier} ft of other doors.")
+        else
+          OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.ExteriorLighting', "No lighting added for other doors, as power is 0 W/ft.")
+        end
       end
 
       # add exterior lights for entry canopies
@@ -330,16 +364,20 @@ module OpenstudioStandards
         end
 
         # create exterior lights
-        OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.ExteriorLighting', "Added #{power} W/ft^2 of lighting for #{multiplier} ft^2 of building entry canopies.")
-        ext_lights = OpenstudioStandards::ExteriorLighting.model_create_exterior_lights(model,
-                                                                                        name: 'Entry Canopies',
-                                                                                        power: power,
-                                                                                        units: 'W/ft^2',
-                                                                                        multiplier: multiplier,
-                                                                                        schedule: ext_lights_sch_other,
-                                                                                        control_option: control_option)
-        exterior_lights << ext_lights
-        installed_power += power * multiplier
+        if power > 0
+          ext_lights = OpenstudioStandards::ExteriorLighting.model_create_exterior_lights(model,
+                                                                                          name: 'Entry Canopies',
+                                                                                          power: power,
+                                                                                          units: 'W/ft^2',
+                                                                                          multiplier: multiplier,
+                                                                                          schedule: ext_lights_sch_other,
+                                                                                          control_option: control_option)
+          exterior_lights << ext_lights
+          installed_power += power * multiplier
+          OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.ExteriorLighting', "Added #{power} W/ft^2 of lighting for #{multiplier} ft^2 of building entry canopies.")
+        else
+          OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.ExteriorLighting', "No lighting added for entry canopies, as power is 0 W/ft^2.")
+        end
       end
 
       # add exterior lights for emergency canopies
@@ -361,16 +399,20 @@ module OpenstudioStandards
         end
 
         # create exterior lights
-        OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.ExteriorLighting', "Added #{power} W/ft^2 of lighting for #{multiplier} ft^2 of building emergency canopies.")
-        ext_lights = OpenstudioStandards::ExteriorLighting.model_create_exterior_lights(model,
-                                                                                        name: 'Emergency Canopies',
-                                                                                        power: power,
-                                                                                        units: 'W/ft^2',
-                                                                                        multiplier: multiplier,
-                                                                                        schedule: ext_lights_sch_other,
-                                                                                        control_option: control_option)
-        exterior_lights << ext_lights
-        installed_power += power * multiplier
+        if power > 0
+          ext_lights = OpenstudioStandards::ExteriorLighting.model_create_exterior_lights(model,
+                                                                                          name: 'Emergency Canopies',
+                                                                                          power: power,
+                                                                                          units: 'W/ft^2',
+                                                                                          multiplier: multiplier,
+                                                                                          schedule: ext_lights_sch_other,
+                                                                                          control_option: control_option)
+          exterior_lights << ext_lights
+          installed_power += power * multiplier
+          OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.ExteriorLighting', "Added #{power} W/ft^2 of lighting for #{multiplier} ft^2 of building emergency canopies.")
+        else
+          OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.ExteriorLighting', "No lighting added for emergency canopies, as power is 0 W/ft^2.")
+        end
       end
 
       # add exterior lights for drive through windows
@@ -392,16 +434,20 @@ module OpenstudioStandards
         end
 
         # create exterior lights
-        OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.ExteriorLighting', "Added #{power} W/drive through window of lighting for #{multiplier} drive through windows.")
-        ext_lights = OpenstudioStandards::ExteriorLighting.model_create_exterior_lights(model,
-                                                                                        name: 'Drive Through Windows',
-                                                                                        power: power,
-                                                                                        units: 'W/ft^2',
-                                                                                        multiplier: multiplier,
-                                                                                        schedule: ext_lights_sch_other,
-                                                                                        control_option: control_option)
-        exterior_lights << ext_lights
-        installed_power += power * multiplier
+        if power > 0
+          ext_lights = OpenstudioStandards::ExteriorLighting.model_create_exterior_lights(model,
+                                                                                          name: 'Drive Through Windows',
+                                                                                          power: power,
+                                                                                          units: 'W/ft^2',
+                                                                                          multiplier: multiplier,
+                                                                                          schedule: ext_lights_sch_other,
+                                                                                          control_option: control_option)
+          exterior_lights << ext_lights
+          installed_power += power * multiplier
+          OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.ExteriorLighting', "Added #{power} W/drive through window of lighting for #{multiplier} drive through windows.")
+        else
+          OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.ExteriorLighting', "No lighting added for drive through windows, as power is 0 W/ft^2.")
+        end
       end
 
       # add base site allowance
@@ -437,15 +483,19 @@ module OpenstudioStandards
         end
 
         # create exterior lights
-        OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.ExteriorLighting', "Added #{power} W of non landscape tradable exterior lighting. Will follow occupancy setback reduction.")
-        ext_lights = OpenstudioStandards::ExteriorLighting.model_create_exterior_lights(model,
-                                                                                        name: 'Base Site Allowance',
-                                                                                        power: power,
-                                                                                        units: 'W',
-                                                                                        multiplier: 1.0,
-                                                                                        schedule: ext_lights_sch_other,
-                                                                                        control_option: control_option)
-        exterior_lights << ext_lights
+        if power > 0
+          ext_lights = OpenstudioStandards::ExteriorLighting.model_create_exterior_lights(model,
+                                                                                          name: 'Base Site Allowance',
+                                                                                          power: power,
+                                                                                          units: 'W',
+                                                                                          multiplier: 1.0,
+                                                                                          schedule: ext_lights_sch_other,
+                                                                                          control_option: control_option)
+          exterior_lights << ext_lights
+          OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.ExteriorLighting', "Added #{power} W of non landscape tradable exterior lighting. Will follow occupancy setback reduction.")
+        else
+          OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.ExteriorLighting', "No base site allowance lighting added, as power is 0 W.")
+        end
       end
 
       return exterior_lights

data/lib/openstudio-standards/exterior_lighting/data/typical_exterior_lighting.json

@@ -24,6 +24,26 @@
       "outdoor_sales_street_frontage_for_vehicle_sales": 10.0,
       "building_facades": 0.15,
       "building_facades_alt_perim": 3.75,
+      "building_facades_per_perimeter": {
+        "SmallOffice": 0.84,
+        "MediumOffice": 0.84,
+        "LargeOffice": 0.84,
+        "RetailStandalone": 0.81,
+        "RetailStripmall": 0.81,
+        "Warehouse": 0.97,
+        "FullServiceRestaurant": 1.93,
+        "QuickServiceRestaurant": 1.93,
+        "PrimarySchool": 0.74,
+        "SecondarySchool": 0.74,
+        "Supermarket": 1.19,
+        "Hospital": 0.54,
+        "Outpatient": 0.54,
+        "SmallHotel": 1.05,
+        "LargeHotel": 1.05,
+        "MidriseApartment": 0.51,
+        "HighriseApartment": 0.51,
+        "default": 1.0
+      },
       "automated_teller_machines_per_location": 270.0,
       "automated_teller_machines_per_machine": 90.0,
       "entries_and_gates": 0.75,

data/lib/openstudio-standards/exterior_lighting/information.rb

@@ -76,6 +76,9 @@ module OpenstudioStandards
       canopy_entry_area = 0.0
       canopy_emergency_area = 0.0
       ground_story_ext_wall_area = 0.0
+      building_perimeter_ft = 0.0
+      largest_building_type = nil
+      largest_building_type_area = 0.0
 
       # temporary std for model_effective_num_stories method
       std = Standard.build('90.1-2013')
@@ -155,7 +158,23 @@ module OpenstudioStandards
         # determine effective number of stories to find first above grade story exterior wall area
         ground_story = effective_num_stories[:story_hash].keys[effective_num_stories[:below_grade]]
         ground_story_ext_wall_area_m2 = effective_num_stories[:story_hash][ground_story][:ext_wall_area]
-        ground_story_ext_wall_area += OpenStudio.convert(ground_story_ext_wall_area_m2, 'm^2', 'ft^2').get
+        this_story_ext_wall_area_ft2 = OpenStudio.convert(ground_story_ext_wall_area_m2, 'm^2', 'ft^2').get
+        ground_story_ext_wall_area += this_story_ext_wall_area_ft2
+
+        # compute perimeter from exterior wall area divided by floor-to-floor height
+        story_height_m = if ground_story.nominalFloortoFloorHeight.is_initialized
+                           ground_story.nominalFloortoFloorHeight.get
+                         else
+                           4.0 # default 4m (~13 ft) for commercial buildings
+                         end
+        story_height_ft = OpenStudio.convert(story_height_m, 'm', 'ft').get
+        building_perimeter_ft += this_story_ext_wall_area_ft2 / story_height_ft
+
+        # track dominant building type by floor area
+        if hash[:floor_area] > largest_building_type_area
+          largest_building_type = building_type
+          largest_building_type_area = hash[:floor_area]
+        end
       end
 
       # no source for width of different entry types
@@ -175,7 +194,9 @@ module OpenstudioStandards
       area_length_count_hash[:drive_through_windows] = drive_through_windows
       area_length_count_hash[:canopy_entry_area] = canopy_entry_area
       area_length_count_hash[:canopy_emergency_area] = canopy_emergency_area
-      area_length_count_hash[:building_facades] = ground_story_ext_wall_area
+      area_length_count_hash[:building_facades_area] = ground_story_ext_wall_area
+      area_length_count_hash[:building_perimeter] = building_perimeter_ft
+      area_length_count_hash[:largest_building_type] = largest_building_type
 
       return area_length_count_hash
     end

data/lib/openstudio-standards/geometry/create.rb

@@ -256,7 +256,9 @@ module OpenstudioStandards
           (space_type_hash[:floor_area] < valid_bar_area_min_m2) && (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
+          # only apply test_a when there is more than one space type on this story; if there is only one,
+          # shifting it out would leave space_types_local_count empty and crash create_sliced_bar_simple_polygons
+          if test_a && space_types_local_count.size > 1
 
             # get first/smallest space type to move to another story
             first_space = space_types_local_count.first
@@ -348,6 +350,8 @@ module OpenstudioStandards
 
       # sort array by floor area but shift largest object to front
       space_types = space_types.sort_by { |k, v| v[:floor_area] }
+      # guard against empty space_types (e.g. when all space types were slivers removed by caller)
+      return hash_of_point_vectors if space_types.empty?
       space_types.insert(0, space_types.delete_at(space_types.size - 1)) # .to_h
 
       # min and max bar end values
@@ -362,11 +366,11 @@ module OpenstudioStandards
         start_perimeter_width_deduction = 0.0
         end_perimeter_width_deduction = 0.0
         if space_type == space_types.first[0]
-          if [length, width].max * 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, width].max * 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

data/lib/openstudio-standards/prototypes/ashrae_90_1/ashrae_90_1_2016/ashrae_90_1_2016.Model.rb

@@ -323,10 +323,11 @@ class ASHRAE9012016 < ASHRAE901
         light_id += 1
         # EnergyPlus v9.4 name change for EMS actuators
         # https://github.com/NREL/OpenStudio/pull/4104
+        # Space is passed as the last argument since Lights is a SpaceLoadInstance
         if model.version < OpenStudio::VersionString.new('3.1.0')
-          light_x_actuator = OpenStudio::Model::EnergyManagementSystemActuator.new(light_x, 'Lights', 'Electric Power Level')
+          light_x_actuator = OpenStudio::Model::EnergyManagementSystemActuator.new(light_x, 'Lights', 'Electric Power Level', space)
         else
-          light_x_actuator = OpenStudio::Model::EnergyManagementSystemActuator.new(light_x, 'Lights', 'Electricity Rate')
+          light_x_actuator = OpenStudio::Model::EnergyManagementSystemActuator.new(light_x, 'Lights', 'Electricity Rate', space)
         end
         light_x_actuator_name_ems = "#{OpenstudioStandards::HVAC.ems_friendly_name(key_name)}_Light#{light_id}_Actuator"
         light_x_actuator.setName(light_x_actuator_name_ems)

data/lib/openstudio-standards/prototypes/ashrae_90_1/ashrae_90_1_2019/ashrae_90_1_2019.Model.rb

@@ -323,10 +323,11 @@ class ASHRAE9012019 < ASHRAE901
         light_id += 1
         # EnergyPlus v9.4 name change for EMS actuators
         # https://github.com/NREL/OpenStudio/pull/4104
+        # Space is passed as the last argument since Lights is a SpaceLoadInstance
         if model.version < OpenStudio::VersionString.new('3.1.0')
-          light_x_actuator = OpenStudio::Model::EnergyManagementSystemActuator.new(light_x, 'Lights', 'Electric Power Level')
+          light_x_actuator = OpenStudio::Model::EnergyManagementSystemActuator.new(light_x, 'Lights', 'Electric Power Level', space)
         else
-          light_x_actuator = OpenStudio::Model::EnergyManagementSystemActuator.new(light_x, 'Lights', 'Electricity Rate')
+          light_x_actuator = OpenStudio::Model::EnergyManagementSystemActuator.new(light_x, 'Lights', 'Electricity Rate', space)
         end
         light_x_actuator_name_ems = "#{OpenstudioStandards::HVAC.ems_friendly_name(key_name)}_Light#{light_id}_Actuator"
         light_x_actuator.setName(light_x_actuator_name_ems)