openstudio-standards 0.2.14 → 0.2.15.pre.rc1

data/lib/openstudio-standards/standards/necb/NECB2015/hvac_systems.rb

@@ -1,5 +1,4 @@
 class NECB2015
-
   # Applies the standard efficiency ratings and typical performance curves to this object.
   #
   # @return [Bool] true if successful, false if not
@@ -107,8 +106,10 @@ class NECB2015
   def apply_maximum_loop_pump_power(model)
     plant_loops = model.getPlantLoops
     return model if plant_loops.nil?
+
     plant_loops.each do |plantloop|
       next if plant_loop_swh_loop?(plantloop) == true
+
       pumps = []
       max_powertoload = 0
       total_pump_power = 0
@@ -119,8 +120,9 @@ class NECB2015
       max_total_loop_pump_power_table = @standards_data['max_total_loop_pump_power']
       plantloop.supplyComponents.each do |supplycomp|
         case supplycomp.iddObjectType.valueName.to_s
-          when 'OS_CentralHeatPumpSystem', 'OS_Coil_Heating_WaterToAirHeatPump_EquationFit','OS_Coil_Heating_WaterToAirHeatPump_VariableSpeedEquationFit','OS_Coil_Heating_WaterToAirHeatPump_VariableSpeedEquationFit_SpeedData','OS_HeatPump_WaterToWater_EquationFit_Cooling','OS_HeatPump_WaterToWater_EquationFit_Heating'
-            max_powertoload = model_find_object(max_total_loop_pump_power_table, {'hydronic_system_type' => 'WSHP'})['total_normalized_pump_power_wperkw']
+          when 'OS_CentralHeatPumpSystem', 'OS_Coil_Heating_WaterToAirHeatPump_EquationFit', 'OS_Coil_Heating_WaterToAirHeatPump_VariableSpeedEquationFit', 'OS_Coil_Heating_WaterToAirHeatPump_VariableSpeedEquationFit_SpeedData', 'OS_HeatPump_WaterToWater_EquationFit_Cooling', 'OS_HeatPump_WaterToWater_EquationFit_Heating'
+            search_hash = { 'hydronic_system_type' => 'WSHP' }
+            max_powertoload = model_find_object(max_total_loop_pump_power_table, search_hash)['total_normalized_pump_power_wperkw']
           when 'OS_Pump_VariableSpeed'
             pumps << supplycomp.to_PumpVariableSpeed.get
             total_pump_power += model.getAutosizedValue(supplycomp, 'Design Power Consumption', 'W').to_f
@@ -128,50 +130,55 @@ class NECB2015
             pumps << supplycomp.to_PumpConstantSpeed.get
             total_pump_power += model.getAutosizedValue(supplycomp, 'Design Power Consumption', 'W').to_f
           when 'OS_HeaderedPumps_ConstantSpeed'
-            OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.PlantLoop', "A pump used in the plant loop named #{plantloop.name.to_s} is headered.  This may result in an error and cause a failure.")
+            OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.PlantLoop', "A pump used in the plant loop named #{plantloop.name} is headered.  This may result in an error and cause a failure.")
             pumps << supplycomp.to_HeaderedPumpsConstantSpeed.get
             total_pump_power += model.getAutosizedValue(supplycomp, 'Design Power Consumption', 'W').to_f
           when 'OS_HeaderedPumps_VariableSpeed'
-            OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.PlantLoop', "A pump used in the plant loop named #{plantloop.name.to_s} is headered.  This may result in an error and cause a failure.")
+            OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.PlantLoop', "A pump used in the plant loop named #{plantloop.name} is headered.  This may result in an error and cause a failure.")
             pumps << supplycomp.to_HeaderedPumpsVariableSpeed.get
             total_pump_power += model.getAutosizedValue(supplycomp, 'Design Power Consumption', 'W').to_f
         end
       end
       # If no pumps were found then there is nothing to set so go to the next plant loop
-      next if pumps.length == 0
+      next if pumps.empty?
+
       # If a heat pump was found then the pump power to total demand ratio should have been set to what NECB 2015 table 5.2.6.3 says.
       # If the pump power to total demand ratio was not set then no heat pump was present so set according to if the plant loop is
       # used for heating, cooling, or heat rejection (condeser as OpenStudio calls it).
       unless max_powertoload > 0
         case plantloop.sizingPlant.loopType
-          when 'Heating'
-            max_powertoload = model_find_object(max_total_loop_pump_power_table, {'hydronic_system_type' => 'Heating'})['total_normalized_pump_power_wperkw']
-          when 'Cooling'
-            max_powertoload = model_find_object(max_total_loop_pump_power_table, {'hydronic_system_type' => 'Cooling'})['total_normalized_pump_power_wperkw']
-          when 'Condenser'
-            max_powertoload = model_find_object(max_total_loop_pump_power_table, {'hydronic_system_type' => 'Heat_rejection'})['total_normalized_pump_power_wperkw']
+        when 'Heating'
+          search_hash = { 'hydronic_system_type' => 'Heating' }
+          max_powertoload = model_find_object(max_total_loop_pump_power_table, search_hash)['total_normalized_pump_power_wperkw']
+        when 'Cooling'
+          search_hash = { 'hydronic_system_type' => 'Cooling' }
+          max_powertoload = model_find_object(max_total_loop_pump_power_table, search_hash)['total_normalized_pump_power_wperkw']
+        when 'Condenser'
+          search_hash = { 'hydronic_system_type' => 'Heat_rejection' }
+          max_powertoload = model_find_object(max_total_loop_pump_power_table, search_hash)['total_normalized_pump_power_wperkw']
         end
       end
       # If nothing was found then do nothing (though by this point if nothing was found then an error should have been thrown).
       next if max_powertoload == 0
+
       # Get the capacity of the loop (using the more general method of calculating via maxflow*temp diff*density*heat capacity)
       # This is more general than the other method in Standards.PlantLoop.rb which only looks at heat and cooling.  Also,
       # that method looks for spceific equipment and would be thrown if other equipment was present.  However my method
       # only works for water for now.
-      plantloop_capacity = plant_loop_capacity_W_by_maxflow_and_deltaT_forwater (plantloop)
+      plantloop_capacity = plant_loop_capacity_w_by_maxflow_and_delta_t_forwater(plantloop)
       # Sizing factor is pump power (W)/ zone demand (in kW, as approximated using plant loop capacity).
-      necb_pump_power_cap = plantloop_capacity*max_powertoload/1000
-      pump_power_adjustment = necb_pump_power_cap/total_pump_power
+      necb_pump_power_cap = plantloop_capacity * max_powertoload / 1000
+      pump_power_adjustment = necb_pump_power_cap / total_pump_power
       # Multiply the factor EnergyPlus uses to calculate the pump power by the sizing factor to make pump power in line with NECB 2015.
       pumps.each do |pump|
         case pump.designPowerSizingMethod
           when 'PowerPerFlowPerPressure'
-            pump.setDesignShaftPowerPerUnitFlowRatePerUnitHead(pump.designShaftPowerPerUnitFlowRatePerUnitHead.to_f*pump_power_adjustment)
+            pump.setDesignShaftPowerPerUnitFlowRatePerUnitHead(pump.designShaftPowerPerUnitFlowRatePerUnitHead.to_f * pump_power_adjustment)
           when 'PowerPerFlow'
-            pump.setDesignElectricPowerPerUnitFlowRate(pump.designElectricPowerPerUnitFlowRate.to_f*pump_power_adjustment)
+            pump.setDesignElectricPowerPerUnitFlowRate(pump.designElectricPowerPerUnitFlowRate.to_f * pump_power_adjustment)
         end
       end
     end
     return model
   end
-end
+end

data/lib/openstudio-standards/standards/necb/NECB2015/lighting.rb

@@ -1,22 +1,26 @@
 class NECB2015
-  def set_lighting_per_area(space_type, definition, lighting_per_area)
-    definition.setWattsperSpaceFloorArea(OpenStudio.convert(lighting_per_area.to_f, 'W/ft^2', 'W/m^2').get)
+  def set_lighting_per_area(space_type:,
+                            definition:,
+                            lighting_per_area:,
+                            lights_scale:)
+    definition.setWattsperSpaceFloorArea(OpenStudio.convert(lighting_per_area.to_f * lights_scale, 'W/ft^2', 'W/m^2').get)
     OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.SpaceType', "#{space_type.name} set LPD to #{lighting_per_area} W/ft^2.")
   end
-  def apply_lighting_schedule(space_type, space_type_properties,default_sch_set)
+
+  def apply_lighting_schedule(space_type, space_type_properties, default_sch_set)
     require 'date'
     lighting_per_area = space_type_properties['lighting_per_area'].to_f
     lights_rel_absence_occ = space_type_properties['rel_absence_occ'].to_f
     lights_personal_control = space_type_properties['personal_control'].to_f
     lights_occ_sense = space_type_properties['occ_sense'].to_f
-    occupancy_schedule =space_type_properties['occupancy_schedule'].to_s
+    occupancy_schedule = space_type_properties['occupancy_schedule'].to_s
     orig_lighting_sch = space_type_properties['lighting_schedule'].to_s
 
     schedule_table = @standards_data['schedules']
 
-    #checks which rules to apply based on LPD
-    if lighting_per_area <= 0.799256505 #8.6 W/m2
-      #do not apply occupancy sensor control
+    # checks which rules to apply based on LPD
+    if lighting_per_area <= 0.799256505 # 8.6 W/m2
+      # do not apply occupancy sensor control
       orig_lighting_sch = space_type_properties['lighting_schedule']
       unless orig_lighting_sch.nil?
         default_sch_set.setLightingSchedule(model_add_schedule(space_type.model, orig_lighting_sch))
@@ -25,103 +29,102 @@ class NECB2015
 
     else # LPD > 8.6 W/m2
 
-      #apply occupancy sensor control
-      #get occupancy schedule's day rules
-      rules = model_find_objects(schedule_table, {'name' => occupancy_schedule}) # returns all schedules with schedule name entered
-      #check if it exists
-      if rules.size.zero? #does not exist -apply default lighting sched
+      # apply occupancy sensor control
+      # get occupancy schedule's day rules
+      rules = model_find_objects(schedule_table, 'name' => occupancy_schedule) # returns all schedules with schedule name entered
+      # check if it exists
+      if rules.size.zero? # does not exist -apply default lighting sched
         OpenStudio.logFree(OpenStudio::Error, 'openstudio.standards.Model', "Cannot find data for schedule: #{occupancy_schedule}. Cannot apply occupancy sensor control for lighting for space: #{space_type.name} ")
         orig_lighting_sch = space_type_properties['lighting_schedule']
         unless orig_lighting_sch.nil?
           default_sch_set.setLightingSchedule(model_add_schedule(space_type.model, orig_lighting_sch))
           OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.SpaceType', "#{space_type.name} set lighting schedule to #{orig_lighting_sch}.")
         end
-      else #exists
+      else # exists
 
-        #check if schedule exists already . # First check model and return schedule if it already exists
+        # check if schedule exists already . # First check model and return schedule if it already exists
         space_type.model.getSchedules.sort.each do |exisiting_light_ruleset|
           if exisiting_light_ruleset.name.get.to_s == "#{occupancy_schedule}-#{orig_lighting_sch}-#{lights_rel_absence_occ}-#{lights_personal_control}-#{lights_occ_sense}-Light Ruleset"
-            OpenStudio.logFree(OpenStudio::Debug, 'openstudio.standards.Model', "Already added schedule: #{exisiting_light_ruleset.name.get.to_s}")
-            #set the lighting schedule
+            OpenStudio.logFree(OpenStudio::Debug, 'openstudio.standards.Model', "Already added schedule: #{exisiting_light_ruleset.name.get}")
+            # set the lighting schedule
             unless exisiting_light_ruleset.nil?
               default_sch_set.setLightingSchedule(exisiting_light_ruleset)
-              OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.SpaceType', "#{space_type.name.to_s} set lighting schedule to #{exisiting_light_ruleset}.")
+              OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.SpaceType', "#{space_type.name} set lighting schedule to #{exisiting_light_ruleset}.")
               return true
             end
           end
         end
 
-        #Create new lighting schedule
+        # Create new lighting schedule
         lighting_sch_ruleset = OpenStudio::Model::ScheduleRuleset.new(space_type.model)
         lighting_sch_ruleset.setName("#{occupancy_schedule}-#{orig_lighting_sch}-#{lights_rel_absence_occ}-#{lights_personal_control}-#{lights_occ_sense}-Light Ruleset")
-        #loop through the number of day types (each occupancy schedule day)
-        rules.each do|rule|
-          #get day type, hourly values from the occupancy schedule day
-          day_types = rule['day_types'] #Default Wkdy, Wknd, Mon, Tue, Wed, Thu, Fri, Sat, Sun, WntrDsn, SmrDsn
+        # loop through the number of day types (each occupancy schedule day)
+        rules.each do |rule|
+          # get day type, hourly values from the occupancy schedule day
+          day_types = rule['day_types'] # Default Wkdy, Wknd, Mon, Tue, Wed, Thu, Fri, Sat, Sun, WntrDsn, SmrDsn
           occupancy_value = rule['values']
-          sch_type = rule['type'] #should be 'Hourly'
+          sch_type = rule['type'] # should be 'Hourly'
           start_date = DateTime.parse(rule['start_date'])
           end_date = DateTime.parse(rule['end_date'])
-          #create new array to hold occ_control values for each day-type/schedule day
-          hourly_occ_control = Array.new
-          #loop through hourly values to check if occupancy sensor control should apply and store the new lighting day hourly value
+          # create new array to hold occ_control values for each day-type/schedule day
+          hourly_occ_control = []
+          # loop through hourly values to check if occupancy sensor control should apply and store the new lighting day hourly value
           hourly_index = 0
           for hourly_value in occupancy_value do
-            #default light schedule hourly value
+            # default light schedule hourly value
             lighting_sched_value = 999
-            #get the hourly value from the .json schedule
-            #get lighting schedule
-            orig_lighting_rules = model_find_objects(schedule_table, {'name' => orig_lighting_sch}) # returns all schedules with schedule name
+            # get the hourly value from the .json schedule
+            # get lighting schedule
+            orig_lighting_rules = model_find_objects(schedule_table, 'name' => orig_lighting_sch) # returns all schedules with schedule name
             if orig_lighting_rules.size.zero?
               OpenStudio.logFree(OpenStudio::Error, 'openstudio.standards.Model', "Cannot find data for schedule: #{orig_lighting_sch}.")
             end
-            if hourly_value<lights_rel_absence_occ
-              #occupancy sensor control applies for this hour
-              occ_control = 1-(lights_rel_absence_occ*lights_occ_sense)-lights_personal_control
-              #go through lighitng schedule and adjust the value for the hour
+            if hourly_value < lights_rel_absence_occ
+              # occupancy sensor control applies for this hour
+              occ_control = 1 - (lights_rel_absence_occ * lights_occ_sense) - lights_personal_control
+              # go through lighitng schedule and adjust the value for the hour
               orig_lighting_rules.each do |orig_lighting_rule|
-                if day_types == orig_lighting_rule['day_types'] #if light day schedule type matches occupancy day type
-                  orig_hourly_values =orig_lighting_rule['values']
-                  lighting_sched_value = (orig_hourly_values[hourly_index])*occ_control
-
+                if day_types == orig_lighting_rule['day_types'] # if light day schedule type matches occupancy day type
+                  orig_hourly_values = orig_lighting_rule['values']
+                  lighting_sched_value = (orig_hourly_values[hourly_index]) * occ_control
                 end
               end
-
             else
-              #occupancy sensor control does not apply for this hour. Use default schedule value from .json file
-              #go through each lighting schedule day  to find the one with the matching day type
-              #assuming occupancy schedule day matches lighting schedule day
+              # occupancy sensor control does not apply for this hour. Use default schedule value from .json file
+              # go through each lighting schedule day  to find the one with the matching day type
+              # assuming occupancy schedule day matches lighting schedule day
               orig_lighting_rules.each do |orig_lighting_rule|
-                if day_types == orig_lighting_rule['day_types'] #if light day schedule type matches occupancy day type
-                  orig_hourly_values =orig_lighting_rule['values']
-                  occ_control =1
-                  lighting_sched_value = orig_hourly_values[hourly_index] #set the current hourly_index's original lighting schedule day value to lighting_sched_value
+                if day_types == orig_lighting_rule['day_types'] # if light day schedule type matches occupancy day type
+                  orig_hourly_values = orig_lighting_rule['values']
+                  occ_control = 1
+                  lighting_sched_value = orig_hourly_values[hourly_index] # set the current hourly_index's original lighting schedule day value to lighting_sched_value
 
                 end
-
               end
-            end # if hourly_value<lights_rel_absence_occ
-            #store the lighting_sched_value factor for this hour to the array
+              # if hourly_value<lights_rel_absence_occ
+            end
+            # store the lighting_sched_value factor for this hour to the array
             hourly_occ_control << lighting_sched_value
-            #update index
-            hourly_index = hourly_index + 1
-          end #for hourly_value in occupancy_value do
+            # update index
+            hourly_index += 1
+            # for hourly_value in occupancy_value do
+          end
 
-          #for each schedule day, create a new day rule with the new hourly schedule values for lighting
+          # for each schedule day, create a new day rule with the new hourly schedule values for lighting
           if day_types.include?('Default')
             day_sch = lighting_sch_ruleset.defaultDaySchedule
             day_sch.setName("#{occupancy_schedule}-#{orig_lighting_sch}-#{lights_rel_absence_occ}-#{lights_personal_control}-#{lights_occ_sense}-Light Default")
             model_add_vals_to_sch(space_type.model, day_sch, sch_type, hourly_occ_control)
           end
           if day_types.include?('Wknd') ||
-              day_types.include?('Wkdy') ||
-              day_types.include?('Sat') ||
-              day_types.include?('Sun') ||
-              day_types.include?('Mon') ||
-              day_types.include?('Tue') ||
-              day_types.include?('Wed') ||
-              day_types.include?('Thu') ||
-              day_types.include?('Fri')
+             day_types.include?('Wkdy') ||
+             day_types.include?('Sat') ||
+             day_types.include?('Sun') ||
+             day_types.include?('Mon') ||
+             day_types.include?('Tue') ||
+             day_types.include?('Wed') ||
+             day_types.include?('Thu') ||
+             day_types.include?('Fri')
             # Make the Rule
             sch_rule = OpenStudio::Model::ScheduleRule.new(lighting_sch_ruleset)
             day_sch = sch_rule.daySchedule
@@ -167,13 +170,16 @@ class NECB2015
             day_sch.setName("#{occupancy_schedule}-#{orig_lighting_sch}-#{lights_rel_absence_occ}-#{lights_personal_control}-#{lights_occ_sense}-Light Summer Design")
             model_add_vals_to_sch(space_type.model, day_sch, sch_type, hourly_occ_control)
           end
-        end #rules.each do|rule|
-        #set the lighting schedule
+          # rules.each do|rule|
+        end
+        # set the lighting schedule
         unless lighting_sch_ruleset.nil?
           default_sch_set.setLightingSchedule(lighting_sch_ruleset)
-          OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.SpaceType', "#{space_type.name.to_s} set lighting schedule to #{lighting_sch_ruleset}.")
+          OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.SpaceType', "#{space_type.name} set lighting schedule to #{lighting_sch_ruleset}.")
         end
-      end #if rules.size.zero? #does not exist
-    end #if lighting_per_area <= 0.7999256505 #8.6 W/m2
+        # if rules.size.zero? #does not exist
+      end
+      # if lighting_per_area <= 0.7999256505 #8.6 W/m2
+    end
   end
-end
+end

data/lib/openstudio-standards/standards/necb/NECB2015/necb_2015.rb

@@ -1,19 +1,17 @@
 # This class holds methods that apply NECB2011 rules.
 # @ref [References::NECB2011]
 class NECB2015 < NECB2011
-  @template = self.new.class.name # rubocop:disable Style/ClassVars
+  @template = new.class.name
   register_standard(@template)
 
-
   def initialize
     super()
-    @template = self.class.name
-    @standards_data = self.load_standards_database_new()
-    self.corrupt_standards_database()
+    @standards_data = load_standards_database_new
+    corrupt_standards_database
   end
 
-  def load_standards_database_new()
-    #load NECB2011 data.
+  def load_standards_database_new
+    # load NECB2011 data.
     super()
 
     if __dir__[0] == ':' # Running from OpenStudio CLI
@@ -28,7 +26,7 @@ class NECB2015 < NECB2011
         end
       end
     else
-      files = Dir.glob("#{File.dirname(__FILE__)}/data/*.json").select {|e| File.file? e}
+      files = Dir.glob("#{File.dirname(__FILE__)}/data/*.json").select { |e| File.file? e }
       files.each do |file|
         data = JSON.parse(File.read(file))
         if !data['tables'].nil?
@@ -46,7 +44,7 @@ class NECB2015 < NECB2011
     return @standards_data
   end
 
-  #occupancy sensor control applied using lighting schedule, see apply_lighting_schedule method
+  # occupancy sensor control applied using lighting schedule, see apply_lighting_schedule method
   def set_occ_sensor_spacetypes(model, space_type_map)
     return true
   end
@@ -58,23 +56,22 @@ class NECB2015 < NECB2011
     # the cooling tower loop capacity can be significantly off which will affect the NECB 2015 maximum loop pump capacity.  Found
     # all sizing was off somewhat if the additional sizing run was not done.
     if model_run_sizing_run(model, "#{sizing_run_dir}/SR2") == false
-      raise("sizing run 2 failed!")
+      raise('sizing run 2 failed!')
     end
+
     # Apply maxmimum loop pump power normalized by peak demand by served spaces as per NECB2015 5.2.6.3.(1)
     apply_maximum_loop_pump_power(model)
-    #model = BTAP::FileIO::remove_duplicate_materials_and_constructions(model)
+    # model = BTAP::FileIO::remove_duplicate_materials_and_constructions(model)
     return model
   end
 
-
-
   def set_lighting_per_area_led_lighting(space_type:, definition:, lighting_per_area_led_lighting:, lights_scale:)
     # puts "#{space_type.name.to_s} - 'space_height' - #{space_height.to_s}"
-    #TODO: Note that 'occ_sens_lpd_frac' in this function has been removed for NECB2015 and 2017.
+    # TODO: Note that 'occ_sens_lpd_frac' in this function has been removed for NECB2015 and 2017.
     # ##### Since Atrium's LPD for LED lighting depends on atrium's height, the height of the atrium (if applicable) should be found.
-    standards_space_type = space_type.standardsSpaceType.is_initialized ? space_type.standardsSpaceType.get : nil #Sara
-    if standards_space_type.include? 'Atrium' #TODO: Note that since none of the archetypes has Atrium, this was tested for 'Dining'. #Atrium
-      puts "#{standards_space_type} - has atrium"  #space_type.name.to_s
+    standards_space_type = space_type.standardsSpaceType.is_initialized ? space_type.standardsSpaceType.get : nil # Sara
+    if standards_space_type.include? 'Atrium' # TODO: Note that since none of the archetypes has Atrium, this was tested for 'Dining'. #Atrium
+      puts "#{standards_space_type} - has atrium" # space_type.name.to_s
       # puts space_height
       if get_max_space_height_for_space_type(space_type: space_type) < 12.0
         # TODO: Regarding the below equations, identify which version of ASHRAE 90.1 was used in NECB2015.
@@ -82,18 +79,17 @@ class NECB2015 < NECB2011
         atrium_lpd_eq_smaller_12_slope = 1.06
         atrium_lpd_eq_larger_12_intercept = 4.3
         atrium_lpd_eq_larger_12_slope = 1.06
-        lighting_per_area_led_lighting_atrium = (atrium_lpd_eq_smaller_12_intercept + atrium_lpd_eq_smaller_12_slope* space_height) * 0.092903 # W/ft2
-      else #i.e. space_height >= 12.0
+        lighting_per_area_led_lighting_atrium = (atrium_lpd_eq_smaller_12_intercept + atrium_lpd_eq_smaller_12_slope * space_height) * 0.092903 # W/ft2
+      else # i.e. space_height >= 12.0
         lighting_per_area_led_lighting_atrium = (atrium_lpd_eq_larger_12_intercept + atrium_lpd_eq_larger_12_slope * space_height) * 0.092903 # W/ft2
       end
       puts "#{standards_space_type} - has lighting_per_area_led_lighting_atrium - #{lighting_per_area_led_lighting_atrium}"
       lighting_per_area_led_lighting = lighting_per_area_led_lighting_atrium
     end
-    lighting_per_area_led_lighting = lighting_per_area_led_lighting * lights_scale
+    lighting_per_area_led_lighting *= lights_scale
 
     definition.setWattsperSpaceFloorArea(OpenStudio.convert(lighting_per_area_led_lighting.to_f, 'W/ft^2', 'W/m^2').get)
 
     OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.SpaceType', "#{space_type.name} set LPD to #{lighting_per_area_led_lighting} W/ft^2.")
   end
-
-end
+end