openstudio-standards 0.1.11 → 0.1.12

data/lib/openstudio-standards/btap/schedules.rb

@@ -318,13 +318,13 @@ module BTAP
               #Get the occupancy schedule.
               occ_schedule = people.numberofPeopleSchedule.get
               #Convert schedule to timeseries and sum up timeseries objects for this space / zone.
-              occ_time_series = OsLib_Schedules.create_timeseries_from_schedule_ruleset(model,occ_schedule)
+              occ_time_series = create_timeseries_from_schedule_ruleset(model,occ_schedule)
               timeseries = timeseries + occ_time_series
             end
           end
         end
         #return the timeseries converted to
-        return OsLib_Schedules.create_schedule_variable_interval_from_time_series(model,timeseries)
+        return create_schedule_variable_interval_from_time_series(model,timeseries)
       end
 
 
@@ -897,6 +897,39 @@ module BTAP
         return create_annual_ruleset_schedule(model, name,type, [Array.new(24){value}, Array.new(24){value},Array.new(24){value}])
       end
 
+      # Creates TimeSeries from ScheduleRuleset
+      # @author david.goldwasser@nrel.gov
+      # @param model [OpenStudio::Model::Model] A model object
+      # @param schedule_ruleset [OpenStudio::Model::ScheduleRuleset] A schedule ruleset
+      # @return [OpenStudio::TimeSeries] A TimeSeries object
+      def self.create_timeseries_from_schedule_ruleset(model, schedule_ruleset)
+        yd = model.getYearDescription
+        start_date = yd.makeDate(1, 1)
+        end_date = yd.makeDate(12, 31)
+
+        values = OpenStudio::DoubleVector.new
+        day = OpenStudio::Time.new(1.0)
+        interval = OpenStudio::Time.new(1.0 / 48.0)
+        day_schedules = schedule_ruleset.to_ScheduleRuleset.get.getDaySchedules(start_date, end_date)
+        day_schedules.each do |day_schedule|
+          time = interval
+          while time < day
+            values << day_schedule.getValue(time)
+            time += interval
+          end
+        end
+        time_series = OpenStudio::TimeSeries.new(start_date, interval, OpenStudio.createVector(values), "")
+      end
+
+      # Creates ScheduleVariableInterval from TimeSeries
+      # @author david.goldwasser@nrel.gov
+      # @param model [OpenStudio::model::Model] A model object
+      # @param time_series [OpenStudio::TimeSeries] A TimeSeries object
+      # @return [OpenStudio::Model::ScheduleInterval] An interval schedule
+      def self.create_schedule_variable_interval_from_time_series(model, time_series)
+        result = OpenStudio::Model::ScheduleInterval.fromTimeSeries(time_series, model).get
+      end
+
     end #module Schedules
 
   end #module Resources

data/lib/openstudio-standards/btap/simmanager.rb

@@ -231,7 +231,7 @@ module BTAP
       #@return [String] self
       def addModel(model, folder = @analysisFolder  )
 
-        run_name = model.building.get.getAttribute("name").get.valueAsString
+        run_name = model.building.get.name.get.to_s
         working_folder = OpenStudio::Path.new(folder.to_s + "\\simulations\\" + run_name )
         osm_save_path = OpenStudio::Path.new(folder.to_s + "\\simulations\\" + run_name + "\\" + run_name + ".osm" )
         model.save(OpenStudio::Path.new(osm_save_path), true);

data/lib/openstudio-standards/btap/spaceloads.rb

@@ -187,7 +187,7 @@ module BTAP
             infiltration_load.setDesignFlowRate( setDesignFlowRate ) unless setDesignFlowRate.nil?
             infiltration_load.setFlowperSpaceFloorArea(setFlowperSpaceFloorArea ) unless setFlowperSpaceFloorArea.nil?
             infiltration_load.setFlowperExteriorSurfaceArea(setFlowperExteriorSurfaceArea ) unless setFlowperExteriorSurfaceArea.nil?
-            table << infiltration_load.getAttribute("name").get.valueAsString << ","
+            table << infiltration_load.name.get.to_s << ","
             table << infiltration_load.designFlowRateCalculationMethod << ","
             infiltration_load.airChangesperHour.empty? ? ach = "NA" : ach = infiltration_load.airChangesperHour.get
             infiltration_load.designFlowRate.empty? ? dfr = "NA" :  dfr = infiltration_load.designFlowRate.get

data/lib/openstudio-standards/btap/vintagizer.rb

@@ -96,7 +96,7 @@ class Vintagizer
     #Remove all existing constructions from model.
     BTAP::Resources::Envelope::remove_all_envelope_information( constructions_model )
     #Save to model.
-    new_construction_set.setAttribute("name",construction_id)
+    new_construction_set.setName(construction_id)
     constructions_model.building.get.setDefaultConstructionSet( new_construction_set.clone( constructions_model ).to_DefaultConstructionSet.get )
 
     #Give adiabatic surfaces a construction. Does not matter what. This is a bug in Openstudio that leave these surfaces unassigned by the default construction set.

data/lib/openstudio-standards/prototypes/Prototype.Model.elevators.rb

@@ -0,0 +1,218 @@
+# open the class to add methods to add elevators
+class OpenStudio::Model::Model
+
+  # Add elevators to the model
+  #
+  # @param template [String] Valid choices are
+  # @return [OpenStudio::Model::ElectricEquipment] the resulting elevator
+  def add_elevators(template)
+
+    # determine effective number of stories
+    effective_num_stories = self.effective_num_stories
+
+    # determine elevator type
+    # todo - add logic here or upstream to have some multi-story buildings without elevators (e.g. small multi-family and small hotels)
+    elevator_type = nil
+    if effective_num_stories[:below_grade] + effective_num_stories[:above_grade] < 2
+      return nil # don't add elevators
+    elsif effective_num_stories[:below_grade] + effective_num_stories[:above_grade] < 6
+      elevator_type = "Hydraulic"
+    else
+      elevator_type = "Traction"
+    end
+
+    # determine space to put elevator load in
+    # largest bottom story (including basement) space that has multiplier of 1
+    bottom_spaces = {}
+    bottom_story = effective_num_stories[:story_hash].keys.first
+    bottom_story.spaces.each do |space|
+      next if space.multiplier > 1
+      bottom_spaces[space] = space.floorArea
+    end
+    target_space = bottom_spaces.key(bottom_spaces.values.max)
+
+    # determine number of elevators
+    number_of_pass_elevators = 0.0
+    number_of_freight_elevators = 0.0
+    building_type_hash = {}
+
+    # apply building type specific log to add to number of elevators based on Beyer (2009) rules of thumb
+    space_type_hash = self.create_space_type_hash(template)
+    space_type_hash.each do |space_type,hash|
+
+      # update building_type_hash
+      if building_type_hash.has_key?(hash[:stds_bldg_type])
+        building_type_hash[hash[:stds_bldg_type]] += hash[:floor_area]
+      else
+        building_type_hash[hash[:stds_bldg_type]] = hash[:floor_area]
+      end
+
+      # building type specific notes; prototype uses Beyer (2009) rules fo thumb
+      if ["Office","SmallOffice","MediumOffice","LargeOffice"].include?(hash[:stds_bldg_type])
+        # The office buildings have one elevator for every 45,000 ft2 (4,181 m2),
+        # plus one service elevator for the large office building.
+        pass_elevator_per_area = OpenStudio::convert(45000.0,"ft^2","m^2").get
+        number_of_pass_elevators += hash[:floor_area]/pass_elevator_per_area
+        # add freight elevators as separate step 1 if over 5k m^2 but more than one if over 50k m^2
+        if self.getBuilding.floorArea > 45000.0 # m^2
+          number_of_freight_elevators += self.getBuilding.floorArea/500000.0 # m^2
+        end
+      elsif["SmallHotel","LargeHotel"].include?(hash[:stds_bldg_type]) && hash[:stds_space_type].include?("GuestRoom")
+        # The hotels have one elevator for every 75 rooms, and the large hotel includes one service elevator for every two public elevators,
+        # plus one additional elevator for the dining and banquet facilities on the top floor.
+        units_per_pass_elevator = 75.0
+        freight_elevators_per_unit = units_per_pass_elevator/2.0
+        number_of_pass_elevators += hash[:num_units]/units_per_pass_elevator
+        number_of_freight_elevators += hash[:num_units]/freight_elevators_per_unit
+      elsif["LargeHotel"].include?(hash[:stds_bldg_type]) && ["Banquet","Cafe"].include?(hash[:stds_space_type])
+        pass_elevator_per_area = OpenStudio::convert(10000.0,"ft^2","m^2").get
+        number_of_pass_elevators += hash[:floor_area]/pass_elevator_per_area
+      elsif["MidriseApartment","HighriseApartment"].include?(hash[:stds_bldg_type]) && hash[:stds_space_type].include?("Apartment")
+        # The apartment building has one elevator for every 90 units
+        units_per_pass_elevator = 90.0
+        number_of_pass_elevators += hash[:num_units]/units_per_pass_elevator
+      elsif["Hospital"].include?(hash[:stds_bldg_type]) && ["PatRoom","ICU_PatRm","ICU_Open"].include?(hash[:stds_space_type])
+        # The hospital has one public and one service elevator for every 100 beds (250 total),
+        # plus two elevators for the offices and cafeteria on the top floor.
+        beds_per_pass_elevator = 100.0
+        number_of_pass_elevators += hash[:num_beds]/beds_per_pass_elevator
+        number_of_freight_elevators += hash[:num_beds]/beds_per_pass_elevator
+      elsif["Hospital"].include?(hash[:stds_bldg_type]) && ["Dining","Kitchen","Office"].include?(hash[:stds_space_type])
+        pass_elevator_per_area = OpenStudio::convert(12500.0,"ft^2","m^2").get
+        number_of_pass_elevators += hash[:floor_area]/pass_elevator_per_area
+      elsif ["PrimarySchool","SecondarySchool"].include?(hash[:stds_bldg_type])
+        # 210,887 ft^2 secondary school prototype has 2 elevators
+        pass_elevator_per_area = OpenStudio::convert(100000.0,"ft^2","m^2").get
+        number_of_pass_elevators += hash[:floor_area]/(pass_elevator_per_area) # freight and passenger combined
+      elsif ["Outpatient"].include?(hash[:stds_bldg_type])
+        # 210,887 ft^2 secondary school prototype has 2 elevators
+        #pass_elevator_per_area = OpenStudio::convert(15000.0,"ft^2","m^2").get
+        #number_of_pass_elevators += hash[:floor_area]/(pass_elevator_per_area) # freight and passenger combined
+      elsif ["Warehouse"].include?(hash[:stds_bldg_type])
+        freight_elevator_per_area = OpenStudio::convert(250000.0,"ft^2","m^2").get
+        number_of_freight_elevators += hash[:floor_area]/freight_elevator_per_area
+      else
+        # todo - improve catchall for building types without elevator data, using same value as what Outpatient would be if not already in space type
+        # includes RetailStandalone, RetailStripmall, QuickServiceRestaurant, FullServiceRestaurant, SuperMarket (made unique logic above for warehouse)
+
+        pass_elevator_per_area = OpenStudio::convert(15000.0,"ft^2","m^2").get
+        number_of_pass_elevators += hash[:floor_area]/pass_elevator_per_area
+      end
+
+    end
+
+    # adjust number of elevators (can be double but if not 0 must be at least 1.0)
+    if number_of_pass_elevators > 0.0 and number_of_pass_elevators < 1.0
+      number_of_pass_elevators = 1.0
+    end
+    if number_of_freight_elevators > 0.0 and number_of_freight_elevators < 1.0
+      number_of_freight_elevators = 1.0
+    end
+    number_of_elevators = number_of_pass_elevators + number_of_freight_elevators
+
+
+    building_type = building_type_hash.key(building_type_hash.values.max)
+    # rename space types as needed
+    if building_type == "Office"
+      building_type = self.remap_office(building_type_hash["Office"])
+    end
+    if building_type == "SmallHotel" then building_type = "LargeHotel" end # no elevator schedules for SmallHotel
+    if building_type == "PrimarySchool" then building_type = "SecondarySchool" end # no elevator schedules for PrimarySchool
+    if building_type == "Retail" then building_type = "RetailStandalone" end # no elevator schedules for PrimarySchool
+    if building_type == "StripMall" then building_type = "RetailStripmall" end # no elevator schedules for PrimarySchool
+    if building_type == "Outpatient"
+      OpenStudio.logFree(OpenStudio::Info, 'Prototype.Model.elevators', "Outpatient ElevatorPumpRoom plug loads contain the elevator loads. Not adding extra elevator loads on top of it.")
+    end
+
+    # Retrieve the Prototype Inputs from JSON
+    search_criteria = {
+        'template' => template,
+        'building_type' => building_type
+    }
+
+    prototype_input = find_object($os_standards['prototype_inputs'], search_criteria, nil)
+    if prototype_input.nil?
+      OpenStudio.logFree(OpenStudio::Error, 'Prototype.Model.elevators', "Could not find prototype inputs for #{search_criteria}.")
+      return false
+    end
+
+    # assign schedules
+    if ["Office","SmallOffice","MediumOffice","LargeOffice","MidriseApartment","HighriseApartment","SecondarySchool"].include?(building_type)
+      elevator_schedule = prototype_input['elevator_schedule']
+      elevator_fan_schedule = prototype_input['elevator_fan_schedule']
+      elevator_lights_schedule = prototype_input['elevator_fan_schedule']
+    elsif ["LargeHotel","Hospital"].include?(building_type)
+      elevator_schedule = prototype_input['exterior_fuel_equipment1_schedule']
+      elevator_fan_schedule = prototype_input['exterior_fuel_equipment2_schedule']
+      elevator_lights_schedule = prototype_input['exterior_fuel_equipment2_schedule']
+    else
+
+      # identify occupancy schedule from largest space type of this building type
+      space_type_size = {}
+      space_type_hash.each do |space_type,hash|
+        next if not building_type.include?(hash[:stds_bldg_type])
+        space_type_size[space_type] = hash[:floor_area]
+      end
+      occ_sch = space_type_size.key(space_type_size.values.max).defaultScheduleSet.get.numberofPeopleSchedule.get
+
+      # clone and assign to elevator
+      elev_sch = occ_sch.clone(self)
+      elevator_schedule = elev_sch.name.to_s
+      elevator_fan_schedule = elev_sch.name.to_s
+      elevator_lights_schedule = elev_sch.name.to_s
+
+      # todo - scale down peak value based on building type lookup, or make parametric schedule based on hours of operation
+      # includes RetailStandalone, RetailStripmall, QuickServiceRestaurant, FullServiceRestaurant, SuperMarket (made unique logic above for warehouse)
+
+      if building_type == "Warehouse"
+        # alter default profile, summer, winter, and rules
+        max_value = 0.2
+        elev_sch = elev_sch.to_ScheduleRuleset.get
+        day_schedules = []
+        elev_sch.scheduleRules.each do |rule|
+          day_schedules << rule.daySchedule
+        end
+        day_schedules << elev_sch.defaultDaySchedule
+        day_schedules << elev_sch.summerDesignDaySchedule
+        day_schedules << elev_sch.winterDesignDaySchedule
+
+        day_schedules.each do |day_schedule|
+          values = day_schedule.values
+          times = day_schedule.times
+          values.each_with_index do |value,i|
+            if value > max_value
+              day_schedule.addValue(times[i],max_value)
+            end
+          end
+        end
+      end
+
+    end
+
+    # todo - currently add elevator doesn't allow me to choose the size of the elevator?
+    # ref bldg pdf has formula for motor hp based on weight, speed, counterweight fraction and mech eff (in 5.1.4)
+
+    # todo - should schedules change based on traction vs. hydraulic vs. just taking what is in prototype.
+
+    # call add_elevator in Prototype.hvac_systems.rb to create elevator objects
+    elevator = self.add_elevator(template,
+                       target_space,
+                       number_of_elevators,
+                       elevator_type,
+                       elevator_schedule,
+                       elevator_fan_schedule,
+                       elevator_lights_schedule,
+                       building_type)
+
+    OpenStudio.logFree(OpenStudio::Info, 'Prototype.Model.elevators', "Adding #{elevator.multiplier} #{elevator_type} elevators to the model in #{target_space.name}.")
+
+    # check fraction lost on heat from elevator if traction, change to 100% lost if not setup that way.
+    if elevator_type == "Traction"
+      elevator.definition.to_ElectricEquipmentDefinition.get.setFractionLost(1.0)
+    end
+
+    return elevator
+
+  end
+
+end

data/lib/openstudio-standards/prototypes/Prototype.Model.exterior_lights.rb

@@ -0,0 +1,399 @@
+# open the class to add methods to add exterior lighting
+class OpenStudio::Model::Model
+
+  # Add exterior lighting to the model
+  #
+  # @param template [String] Valid choices are
+  # @param exterior_lighting_zone_number [Integer] Valid choices are
+  # @return [Hash] the resulting exterior lights
+  # @todo - would be nice to add argument for some building types (SmallHotel, MidriseApartment, PrimarySchool, SecondarySchool, RetailStripmall) if it has interior or exterior circulation.
+  def add_typical_exterior_lights(template,exterior_lighting_zone_number,onsite_parking_fraction = 1.0, add_base_site_allowance = false, use_model_for_entries_and_canopies = false)
+
+    exterior_lights = {}
+    installed_power = 0.0
+
+    # populate search hash
+    search_criteria = {
+        'template' => template,
+        'exterior_lighting_zone_number' => exterior_lighting_zone_number,
+    }
+    
+    # load exterior_lighting_properties
+    exterior_lighting_properties = self.find_object($os_standards['exterior_lighting'], search_criteria)
+
+    # get building types and ratio (needed to get correct schedules, parking area, entries, canopies, and drive throughs)
+    space_type_hash = self.create_space_type_hash(template)
+
+    # get model specific values to map to exterior_lighting_properties
+    area_length_count_hash = self.create_exterior_lighting_area_length_count_hash(template,space_type_hash,use_model_for_entries_and_canopies)
+
+    # using midnight to 6am setback or shutdown
+    start_setback_shutoff = {:hr => 24, :min => 0}
+    end_setback_shutoff = {:hr => 6, :min => 0}
+    shuttoff = false
+    setback = false
+    if exterior_lighting_properties["building_facade_and_landscape_automatic_shut_off"] == 1
+      ext_lights_sch_facade_and_landscape = OpenStudio::Model::ScheduleRuleset.new(self)
+      default_day = ext_lights_sch_facade_and_landscape.defaultDaySchedule
+      default_day.addValue(OpenStudio::Time.new(0, end_setback_shutoff[:hr], end_setback_shutoff[:min], 0), 0.0)
+      default_day.addValue(OpenStudio::Time.new(0, start_setback_shutoff[:hr], start_setback_shutoff[:min], 0), 1.0)
+      OpenStudio.logFree(OpenStudio::Info, 'Prototype.Model.exterior_lights', "Facade and Landscape exterior lights shut off from #{start_setback_shutoff} to #{end_setback_shutoff}")
+    else
+      ext_lights_sch_facade_and_landscape = self.alwaysOnDiscreteSchedule
+    end
+    if not exterior_lighting_properties["occupancy_setback_reduction"].nil? and exterior_lighting_properties["occupancy_setback_reduction"] > 0.0
+      ext_lights_sch_other = OpenStudio::Model::ScheduleRuleset.new(self)
+      setback_value = 1.0 - exterior_lighting_properties["occupancy_setback_reduction"]
+      default_day = ext_lights_sch_other.defaultDaySchedule
+      default_day.addValue(OpenStudio::Time.new(0, end_setback_shutoff[:hr], end_setback_shutoff[:min], 0), setback_value)
+      default_day.addValue(OpenStudio::Time.new(0, start_setback_shutoff[:hr], start_setback_shutoff[:min], 0), 1.0)
+      OpenStudio.logFree(OpenStudio::Info, 'Prototype.Model.exterior_lights', "Non Facade and Landscape lights reduce by #{exterior_lighting_properties["occupancy_setback_reduction"]*100} % from #{start_setback_shutoff} to #{end_setback_shutoff}")
+    else
+      ext_lights_sch_other = self.alwaysOnDiscreteSchedule
+    end
+
+    # add exterior lights for parking area
+    if area_length_count_hash[:parking_area_and_drives_area] > 0
+
+      # lighting values
+      multiplier = area_length_count_hash[:parking_area_and_drives_area] * onsite_parking_fraction
+      power = exterior_lighting_properties["parking_areas_and_drives"]
+      name_prefix = "Parking Areas and Drives"
+
+      # create ext light def
+      OpenStudio.logFree(OpenStudio::Info, 'Prototype.Model.exterior_lights', "Added #{power} W/ft^2 of lighting for #{multiplier} ft^2 of parking area.")
+      ext_lights_def = OpenStudio::Model::ExteriorLightsDefinition.new(self)
+      ext_lights_def.setName("#{name_prefix} Def (W/ft^2)")
+      ext_lights_def.setDesignLevel(power)
+
+      # create ext light inst
+      #creating exterior lights object
+      ext_lights = OpenStudio::Model::ExteriorLights.new(ext_lights_def,ext_lights_sch_other)
+      ext_lights.setMultiplier(multiplier)
+      ext_lights.setName(name_prefix)
+      ext_lights.setControlOption(exterior_lighting_properties["control_option"])
+      ext_lights.setEndUseSubcategory(name_prefix)
+      exterior_lights[name_prefix] = ext_lights
+
+      # update installed power
+      installed_power += power * multiplier
+    end
+
+    # add exterior lights for facades
+    if area_length_count_hash[:building_facades] > 0
+
+      # lighting values
+      multiplier = area_length_count_hash[:building_facades]
+      power = exterior_lighting_properties["building_facades"]
+      name_prefix = "Building Facades"
+
+      # create ext light def
+      OpenStudio.logFree(OpenStudio::Info, 'Prototype.Model.exterior_lights', "Added #{power} W/ft^2 of lighting for #{multiplier} ft^2 of building facade area.")
+      ext_lights_def = OpenStudio::Model::ExteriorLightsDefinition.new(self)
+      ext_lights_def.setName("#{name_prefix} Def (W/ft^2)")
+      ext_lights_def.setDesignLevel(power)
+
+      # create ext light inst
+      #creating exterior lights object
+      ext_lights = OpenStudio::Model::ExteriorLights.new(ext_lights_def,ext_lights_sch_facade_and_landscape)
+      ext_lights.setMultiplier(multiplier)
+      ext_lights.setName(name_prefix)
+      ext_lights.setControlOption(exterior_lighting_properties["control_option"])
+      ext_lights.setEndUseSubcategory(name_prefix)
+      exterior_lights[name_prefix] = ext_lights
+
+      # update installed power
+      installed_power += power * multiplier
+    end
+
+    # add exterior lights for main entries
+    if area_length_count_hash[:main_entries] > 0
+
+      # lighting values
+      multiplier = area_length_count_hash[:main_entries]
+      power = exterior_lighting_properties["main_entries"]
+      name_prefix = "Main Entries"
+
+      # create ext light def
+      OpenStudio.logFree(OpenStudio::Info, 'Prototype.Model.exterior_lights', "Added #{power} W/ft of lighting for #{multiplier} ft of main entry length.")
+      ext_lights_def = OpenStudio::Model::ExteriorLightsDefinition.new(self)
+      ext_lights_def.setName("#{name_prefix} Def (W/ft)")
+      ext_lights_def.setDesignLevel(power)
+
+      # create ext light inst
+      #creating exterior lights object
+      ext_lights = OpenStudio::Model::ExteriorLights.new(ext_lights_def,ext_lights_sch_other)
+      ext_lights.setMultiplier(multiplier)
+      ext_lights.setName(name_prefix)
+      ext_lights.setControlOption(exterior_lighting_properties["control_option"])
+      ext_lights.setEndUseSubcategory(name_prefix)
+      exterior_lights[name_prefix] = ext_lights
+
+      # update installed power
+      installed_power += power * multiplier
+    end
+
+    # add exterior lights for other doors
+    if area_length_count_hash[:other_doors] > 0
+
+      # lighting values
+      multiplier = area_length_count_hash[:other_doors]
+      power = exterior_lighting_properties["other_doors"]
+      name_prefix = "Other Doors"
+
+      # create ext light def
+      OpenStudio.logFree(OpenStudio::Info, 'Prototype.Model.exterior_lights', "Added #{power} W/ft of lighting for #{multiplier} ft of other doors.")
+      ext_lights_def = OpenStudio::Model::ExteriorLightsDefinition.new(self)
+      ext_lights_def.setName("#{name_prefix} Def (W/ft)")
+      ext_lights_def.setDesignLevel(power)
+
+      # create ext light inst
+      #creating exterior lights object
+      ext_lights = OpenStudio::Model::ExteriorLights.new(ext_lights_def,ext_lights_sch_other)
+      ext_lights.setMultiplier(multiplier)
+      ext_lights.setName(name_prefix)
+      ext_lights.setControlOption(exterior_lighting_properties["control_option"])
+      ext_lights.setEndUseSubcategory(name_prefix)
+      exterior_lights[name_prefix] = ext_lights
+
+      # update installed power
+      installed_power += power * multiplier
+    end
+
+    # add exterior lights for entry canopies
+    if area_length_count_hash[:canopy_entry_area] > 0
+
+      # lighting values
+      multiplier = area_length_count_hash[:canopy_entry_area]
+      power = exterior_lighting_properties["entry_canopies"]
+      name_prefix = "Entry Canopies"
+
+      # create ext light def
+      OpenStudio.logFree(OpenStudio::Info, 'Prototype.Model.exterior_lights', "Added #{power} W/ft^2 of lighting for #{multiplier} ft^2 of building entry canopies.")
+      ext_lights_def = OpenStudio::Model::ExteriorLightsDefinition.new(self)
+      ext_lights_def.setName("#{name_prefix} Def (W/ft^2)")
+      ext_lights_def.setDesignLevel(power)
+
+      # create ext light inst
+      #creating exterior lights object
+      ext_lights = OpenStudio::Model::ExteriorLights.new(ext_lights_def,ext_lights_sch_other)
+      ext_lights.setMultiplier(multiplier)
+      ext_lights.setName(name_prefix)
+      ext_lights.setControlOption(exterior_lighting_properties["control_option"])
+      ext_lights.setEndUseSubcategory(name_prefix)
+      exterior_lights[name_prefix] = ext_lights
+
+      # update installed power
+      installed_power += power * multiplier
+    end
+
+    # add exterior lights for emergency canopies
+    if area_length_count_hash[:canopy_emergency_area] > 0
+
+      # lighting values
+      multiplier = area_length_count_hash[:canopy_emergency_area]
+      power = exterior_lighting_properties["loading_areas_for_emergency_vehicles"]
+      name_prefix = "Emergency Canopies"
+
+      # create ext light def
+      OpenStudio.logFree(OpenStudio::Info, 'Prototype.Model.exterior_lights', "Added #{power} W/ft^2 of lighting for #{multiplier} ft^2 of building emergency canopies.")
+      ext_lights_def = OpenStudio::Model::ExteriorLightsDefinition.new(self)
+      ext_lights_def.setName("#{name_prefix} Def (W/ft^2)")
+      ext_lights_def.setDesignLevel(power)
+
+      # create ext light inst
+      #creating exterior lights object
+      ext_lights = OpenStudio::Model::ExteriorLights.new(ext_lights_def,ext_lights_sch_other)
+      ext_lights.setMultiplier(multiplier)
+      ext_lights.setName(name_prefix)
+      ext_lights.setControlOption(exterior_lighting_properties["control_option"])
+      ext_lights.setEndUseSubcategory(name_prefix)
+      exterior_lights[name_prefix] = ext_lights
+
+      # update installed power
+      installed_power += power * multiplier
+    end
+
+    # add exterior lights for drive through windows
+    if area_length_count_hash[:drive_through_windows] > 0
+
+      # lighting values
+      multiplier = area_length_count_hash[:drive_through_windows]
+      power = exterior_lighting_properties["drive_through_windows_and_doors"]
+      name_prefix = "Drive Through Windows"
+
+      # create ext light def
+      OpenStudio.logFree(OpenStudio::Info, 'Prototype.Model.exterior_lights', "Added #{power} W/drive through window of lighting for #{multiplier} drie through windows.")
+      ext_lights_def = OpenStudio::Model::ExteriorLightsDefinition.new(self)
+      ext_lights_def.setName("#{name_prefix} Def (W/ft^2)")
+      ext_lights_def.setDesignLevel(power)
+
+      # create ext light inst
+      #creating exterior lights object
+      ext_lights = OpenStudio::Model::ExteriorLights.new(ext_lights_def,ext_lights_sch_other)
+      ext_lights.setMultiplier(multiplier)
+      ext_lights.setName(name_prefix)
+      ext_lights.setControlOption(exterior_lighting_properties["control_option"])
+      ext_lights.setEndUseSubcategory(name_prefix)
+      exterior_lights[name_prefix] = ext_lights
+
+      # update installed power
+      installed_power += power * multiplier
+    end
+
+    # todo - add_base_site_lighting_allowance (non landscaping tradable lighting)
+    # add exterior lights for drive through windows
+    if add_base_site_allowance
+
+      # lighting values
+      if not exterior_lighting_properties["base_site_allowance_power"].nil?
+        power = exterior_lighting_properties["base_site_allowance_power"]
+      elsif not exterior_lighting_properties["base_site_allowance_fraction"].nil?
+        power = exterior_lighting_properties["base_site_allowance_fraction"] * installed_power # shold be of allowed vs. installed, but hard to calculate
+      else
+        OpenStudio.logFree(OpenStudio::Info, 'Prototype.Model.exterior_lights', "Cannot determine target base site allowance power, will set to 0 W.")
+        power = 0.0
+      end
+      name_prefix = "Base Site Allowance"
+
+      # create ext light def
+      OpenStudio.logFree(OpenStudio::Info, 'Prototype.Model.exterior_lights', "Added #{power} W of non landscape tradable exterior lighting. Wil follow occupancy setback reduction.")
+      ext_lights_def = OpenStudio::Model::ExteriorLightsDefinition.new(self)
+      ext_lights_def.setName("#{name_prefix} Def (W)")
+      ext_lights_def.setDesignLevel(power)
+
+      # create ext light inst
+      #creating exterior lights object
+      ext_lights = OpenStudio::Model::ExteriorLights.new(ext_lights_def,ext_lights_sch_other)
+      ext_lights.setName(name_prefix)
+      ext_lights.setControlOption(exterior_lighting_properties["control_option"])
+      ext_lights.setEndUseSubcategory(name_prefix)
+      exterior_lights[name_prefix] = ext_lights
+
+      # don't need to update installed power for this
+    end
+
+    return exterior_lights
+
+  end
+
+  # get exterior lighting area's, distances, and counts
+  #
+  # @return [hash] hash of exterior lighting value types and building type and model specific values
+  # @todo - add code in to determine number of entries and canopy area from model geoemtry
+  # @todo - come up with better logic for entry widths
+  def create_exterior_lighting_area_length_count_hash(template,space_type_hash,use_model_for_entries_and_canopies)
+
+    area_length_count_hash = {}
+
+    # populate building_type_hash, used to remap office
+    building_type_hash = {}
+    space_type_hash.each do |space_type,hash|
+
+      # update building_type_hash
+      if building_type_hash.has_key?(hash[:stds_bldg_type])
+        building_type_hash[hash[:stds_bldg_type]] += hash[:floor_area]
+      else
+        building_type_hash[hash[:stds_bldg_type]] = hash[:floor_area]
+      end
+    end
+    # rename Office to SmallOffice MediumOffice or LargeOffice
+    office_type = nil
+    if building_type_hash.has_key?("Office")
+      office_type = self.remap_office(building_type_hash["Office"])
+    end
+
+    # parking areas and drives area
+    parking_area_and_drives_area = 0.0
+    main_entries = 0.0
+    other_doors = 0.0
+    canopy_entry_area = 0.0
+    canopy_emergency_area = 0.0
+    drive_through_windows = 0.0
+    # run space_type_hash to get number of students and units and building type floor area totals
+    space_type_hash.each do |space_type,hash|
+
+      # rename space types as needed
+      if hash[:stds_bldg_type] == "Office"
+        building_type = office_type
+      else
+        building_type = hash[:stds_bldg_type]
+      end
+
+      # store floor area ip
+      floor_area_ip = OpenStudio::convert(hash[:floor_area],"m^2","ft^2").get
+      num_spots = 0.0
+
+      # load illuminated_parking_area_properties
+      search_criteria = {'building_type' => building_type}
+      illuminated_parking_area_lookup = self.find_object($os_standards['parking'], search_criteria)
+      if not illuminated_parking_area_lookup["building_area_per_spot"].nil?
+        num_spots += floor_area_ip / illuminated_parking_area_lookup["building_area_per_spot"].to_f
+      elsif not illuminated_parking_area_lookup["units_per_spot"].nil?
+        num_spots += hash[:num_units] / illuminated_parking_area_lookup["units_per_spot"].to_f
+      elsif not illuminated_parking_area_lookup["students_per_spot"].nil?
+        num_spots += hash[:num_students] / illuminated_parking_area_lookup["students_per_spot"].to_f
+      elsif not illuminated_parking_area_lookup["beds_per_spot"].nil?
+        num_spots += hash[:num_beds] / illuminated_parking_area_lookup["beds_per_spot"].to_f
+      else
+        OpenStudio.logFree(OpenStudio::Info, 'Prototype.Model.exterior_lights', "Unexpected key, can't calculate number of parking spots from #{illuminated_parking_area_lookup.keys.first}.")
+      end
+      parking_area_and_drives_area += num_spots * illuminated_parking_area_lookup["parking_area_per_spot"]
+
+      # load illuninated_parking_area_properties
+      search_criteria = {'building_type' => building_type}
+      exterior_lighting_assumptions_lookup = self.find_object($os_standards['entryways'], search_criteria)
+
+      # lookup doors
+      if use_model_for_entries_and_canopies
+        # todo - get number of entries and canopy size from model geometry
+      else
+
+        # no source for width of different entry types
+        main_entry_width_ip = 8 # ft
+        other_doors_width_ip = 4 # ft
+
+        # rollup not used
+        main_entries += (floor_area_ip/10000.0) * exterior_lighting_assumptions_lookup["entrance_doors_per_10,000"] * main_entry_width_ip
+        other_doors += (floor_area_ip/10000.0) * exterior_lighting_assumptions_lookup["others_doors_per_10,000"] * other_doors_width_ip
+        if not exterior_lighting_assumptions_lookup["floor_area_per_drive_through_window"].nil?
+          drive_through_windows += floor_area_ip / exterior_lighting_assumptions_lookup["floor_area_per_drive_through_window"].to_f
+        end
+
+
+        # if any space types of building type that has canopy, then use that value, don't add to count for additional space types
+        if not exterior_lighting_assumptions_lookup["entrance_canopies"].nil? and not exterior_lighting_assumptions_lookup["canopy_size"].nil?
+          canopy_entry_area = exterior_lighting_assumptions_lookup["entrance_canopies"] * exterior_lighting_assumptions_lookup["canopy_size"]
+        end
+        if not exterior_lighting_assumptions_lookup["emergency_canopies"].nil? and not exterior_lighting_assumptions_lookup["canopy_size"].nil?
+          canopy_emergency_area = exterior_lighting_assumptions_lookup["emergency_canopies"]* exterior_lighting_assumptions_lookup["canopy_size"]
+        end
+
+      end
+
+    end
+
+    # populate hash
+    area_length_count_hash[:parking_area_and_drives_area] = parking_area_and_drives_area
+    area_length_count_hash[:main_entries] = main_entries
+    area_length_count_hash[:other_doors] = other_doors
+    area_length_count_hash[:canopy_entry_area] = canopy_entry_area
+    area_length_count_hash[:canopy_emergency_area] = canopy_emergency_area
+    area_length_count_hash[:drive_through_windows] = drive_through_windows
+
+    # determine effective number of stories to find first above grade story exterior wall area
+    effective_num_stories = self.effective_num_stories
+    ground_story = effective_num_stories[:story_hash].keys[effective_num_stories[:below_grade]]
+    ground_story_ext_wall_area_si = effective_num_stories[:story_hash][ground_story][:ext_wall_area]
+    ground_story_ext_wall_area_ip = OpenStudio::convert(ground_story_ext_wall_area_si,"m^2","ft^2").get
+
+    # building_facades
+    # reference buildings uses first story and plenum area all around
+    # prototype uses Table 4.19 by building type lit facde vs. total facade.
+    area_length_count_hash[:building_facades] = ground_story_ext_wall_area_ip
+
+    return area_length_count_hash
+
+  end
+
+end