openstudio-standards 0.4.0 → 0.5.0.rc1

data/lib/openstudio-standards/standards/ashrae_90_1_prm/ashrae_90_1_prm.PlanarSurface.rb

@@ -13,6 +13,9 @@ class ASHRAE901PRM < Standard
   #   [template, climate_zone, intended_surface_type, standards_construction_type, occ_type]
   #   and the values are the constructions.  If supplied, constructions will be pulled
   #   from this hash if already created to avoid creating duplicate constructions.
+  # @param wwr_building_type [String | Nil] building type that identifies the prescribed window to wall ratio
+  # @param wwr_info [Hash] A map that maps the building area type to window to wall ratio
+  # @param surface_category [String] surface category e.g., 'ExteriorSubSurface'
   # @return [Hash] returns a hash where the key is an array of inputs
   #   [template, climate_zone, intended_surface_type, standards_construction_type, occ_type]
   #   and the value is the newly created construction.
@@ -54,8 +57,11 @@ class ASHRAE901PRM < Standard
         cons_set = space.model.building.get.defaultConstructionSet.get
         construction = get_default_surface_cons_from_surface_type(surface_category, surface_type, cons_set)
       end
-
-      return previous_construction_map if construction.nil?
+      OpenStudio.logFree(OpenStudio::Error, 'prm.log',
+                         "Surface #{planar_surface.name.get} does not have a construction. Failed to find defaultConstructionSet for #{planar_surface.name.get}. Add a construction for the surface or add a defaultConstructionSet to Space #{space.name.get} or SpaceType #{space_type.name.get}.")
+      prm_raise(construction,
+                @sizing_run_dir,
+                "Failed to find defaultConstructionSet for #{planar_surface.name.get}. Check inputs.")
     end
 
     # Determine if residential or nonresidential

data/lib/openstudio-standards/standards/ashrae_90_1_prm/ashrae_90_1_prm.PlantLoop.rb

@@ -2,7 +2,7 @@ class ASHRAE901PRM < Standard
   # Keep only one cooling tower, but use one condenser pump per chiller
 
   # @param plant_loop [OpenStudio::Model::PlantLoop] plant loop
-  # @return [Bool] returns true if successful, false if not
+  # @return [Boolean] returns true if successful, false if not
   def plant_loop_apply_prm_number_of_cooling_towers(plant_loop)
     # Skip non-cooling plants
     return true unless plant_loop.sizingPlant.loopType == 'Condenser'
@@ -90,70 +90,12 @@ class ASHRAE901PRM < Standard
     end
   end
 
-  # Get the total cooling capacity for the plant loop
-  #
-  # @param plant_loop [OpenStudio::Model::PlantLoop] plant loop
-  # @param [String] sizing_run_dir
-  # @return [Double] total cooling capacity in watts
-  def plant_loop_total_cooling_capacity(plant_loop, sizing_run_dir = Dir.pwd)
-    # Sum the cooling capacity for all cooling components
-    # on the plant loop.
-    total_cooling_capacity_w = 0
-    sizing_run_ran = false
-
-    plant_loop.supplyComponents.each do |sc|
-      # ChillerElectricEIR
-      if sc.to_ChillerElectricEIR.is_initialized
-        chiller = sc.to_ChillerElectricEIR.get
-
-        # If chiller is autosized, check sizing run results. If sizing run not ran, run it first
-        if chiller.isReferenceCapacityAutosized
-          model = chiller.model
-          sizing_run_ran = model_run_sizing_run(model, "#{sizing_run_dir}/SR_cooling_plant") if !sizing_run_ran
-
-          if sizing_run_ran
-            if model.version <= OpenStudio::VersionString.new('3.2.1')
-              sizing_run_capacity = model.getAutosizedValueFromEquipmentSummary(chiller, 'Central Plant', 'Nominal Capacity', 'W').get
-            else
-              sizing_run_capacity = model.getAutosizedValueFromEquipmentSummary(chiller, 'Central Plant', 'Rated Capacity', 'W').get
-            end
-            chiller.setReferenceCapacity(sizing_run_capacity)
-            total_cooling_capacity_w += sizing_run_capacity
-          else
-            OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.PlantLoop', "For #{plant_loop.name} capacity of #{chiller.name} is not available due to a sizing run failure, total cooling capacity of plant loop will be incorrect when applying standard.")
-          end
-
-        elsif chiller.referenceCapacity.is_initialized
-          total_cooling_capacity_w += chiller.referenceCapacity.get
-        elsif chiller.autosizedReferenceCapacity.is_initialized
-          total_cooling_capacity_w += chiller.autosizedReferenceCapacity.get
-        else
-          OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.PlantLoop', "For #{plant_loop.name} capacity of #{chiller.name} is not available, total cooling capacity of plant loop will be incorrect when applying standard.")
-        end
-        # DistrictCooling
-      elsif sc.to_DistrictCooling.is_initialized
-        dist_clg = sc.to_DistrictCooling.get
-        if dist_clg.nominalCapacity.is_initialized
-          total_cooling_capacity_w += dist_clg.nominalCapacity.get
-        elsif dist_clg.autosizedNominalCapacity.is_initialized
-          total_cooling_capacity_w += dist_clg.autosizedNominalCapacity.get
-        else
-          OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.PlantLoop', "For #{plant_loop.name} capacity of DistrictCooling #{dist_clg.name} is not available, total heating capacity of plant loop will be incorrect when applying standard.")
-        end
-      end
-    end
-
-    total_cooling_capacity_tons = OpenStudio.convert(total_cooling_capacity_w, 'W', 'ton').get
-    OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.PlantLoop', "For #{plant_loop.name}, cooling capacity is #{total_cooling_capacity_tons.round} tons of refrigeration.")
-
-    return total_cooling_capacity_w
-  end
-
   # Splits the single chiller used for the initial sizing run
   # into multiple separate chillers based on Appendix G.
   #
-  # @param plant_loop_args [Array] chilled water loop (OpenStudio::Model::PlantLoop), sizing run directory
-  # @return [Bool] returns true if successful, false if not
+  # @param plant_loop [OpenStudio::Model::PlantLoop] chilled water loop
+  # @param sizing_run_dir [String] sizing run directory
+  # @return [Boolean] returns true if successful, false if not
   def plant_loop_apply_prm_number_of_chillers(plant_loop, sizing_run_dir = nil)
     # Skip non-cooling plants & secondary cooling loop
     return true unless plant_loop.sizingPlant.loopType == 'Cooling'
@@ -173,7 +115,7 @@ class ASHRAE901PRM < Standard
     end
 
     # Determine the capacity of the loop
-    cap_w = plant_loop_total_cooling_capacity(plant_loop, sizing_run_dir)
+    cap_w = plant_loop_total_cooling_capacity(plant_loop)
     cap_tons = OpenStudio.convert(cap_w, 'W', 'ton').get
     if cap_tons <= 300
       num_chillers = 1
@@ -309,7 +251,7 @@ class ASHRAE901PRM < Standard
   #   you could set at 0.9 and just calculate the pressure rise to have your 19 W/GPM or whatever
   #
   # @param plant_loop [OpenStudio::Model::PlantLoop] plant loop
-  # @return [Bool] returns true if successful, false if not
+  # @return [Boolean] returns true if successful, false if not
   def plant_loop_apply_prm_baseline_pump_power(plant_loop)
     hot_water_pump_power = 19 # W/gpm
     hot_water_district_pump_power = 14 # W/gpm
@@ -330,7 +272,7 @@ class ASHRAE901PRM < Standard
 
       has_district_heating = false
       plant_loop.supplyComponents.each do |sc|
-        if sc.to_DistrictHeating.is_initialized
+        if sc.iddObjectType.valueName.to_s.include?('DistrictHeating')
           has_district_heating = true
         end
       end
@@ -394,9 +336,8 @@ class ASHRAE901PRM < Standard
   # @param chilled_water_loop [OpenStudio::Model::PlantLoop] chilled water loop
   # @param dsgn_sup_wtr_temp [Double] design chilled water supply T
   # @param dsgn_sup_wtr_temp_delt [Double] design chilled water supply delta T
-  # @return [Bool] returns true if successful, false if not
+  # @return [Boolean] returns true if successful, false if not
   def chw_sizing_control(model, chilled_water_loop, dsgn_sup_wtr_temp, dsgn_sup_wtr_temp_delt)
-
     design_chilled_water_temperature = 44 # Loop design chilled water temperature (F)
     design_chilled_water_temperature_delta = 10.1 # Loop design chilled water temperature  (deltaF)
     chw_outdoor_temperature_high = 80 # Chilled water temperature reset at high outdoor air temperature (F)
@@ -406,7 +347,7 @@ class ASHRAE901PRM < Standard
     chiller_chw_low_temp_limit = 36 # Chiller leaving chilled water lower temperature limit (F)
     chiller_chw_cond_temp = 95 # Chiller entering condenser fluid temperature (F)
     primary_pump_power = 9 # primary pump power (W/gpm)
- 
+
     if dsgn_sup_wtr_temp.nil?
       dsgn_sup_wtr_temp_c = OpenStudio.convert(design_chilled_water_temperature, 'F', 'C').get
     else
@@ -425,17 +366,17 @@ class ASHRAE901PRM < Standard
     sizing_plant.setDesignLoopExitTemperature(dsgn_sup_wtr_temp_c)
     sizing_plant.setLoopDesignTemperatureDifference(dsgn_sup_wtr_temp_delt_k)
     # Use OA reset setpoint manager
-    outdoor_low_temperature_C = OpenStudio.convert(chw_outdoor_temperature_low, 'F', 'C').get.round(1)
-    outdoor_high_temperature_C = OpenStudio.convert(chw_outdoor_temperature_high, 'F', 'C').get.round(1)
-    setpoint_temperature_outdoor_high_C = OpenStudio.convert(chw_outdoor_high_setpoint, 'F', 'C').get.round(1)
-    setpoint_temperature_outdoor_low_C = OpenStudio.convert(chw_outdoor_low_setpoint, 'F', 'C').get.round(1)
+    outdoor_low_temperature_c = OpenStudio.convert(chw_outdoor_temperature_low, 'F', 'C').get.round(1)
+    outdoor_high_temperature_c = OpenStudio.convert(chw_outdoor_temperature_high, 'F', 'C').get.round(1)
+    setpoint_temperature_outdoor_high_c = OpenStudio.convert(chw_outdoor_high_setpoint, 'F', 'C').get.round(1)
+    setpoint_temperature_outdoor_low_c = OpenStudio.convert(chw_outdoor_low_setpoint, 'F', 'C').get.round(1)
 
     chw_stpt_manager = OpenStudio::Model::SetpointManagerOutdoorAirReset.new(model)
     chw_stpt_manager.setName("#{chilled_water_loop.name} Setpoint Manager")
-    chw_stpt_manager.setOutdoorHighTemperature(outdoor_high_temperature_C) # Degrees Celsius
-    chw_stpt_manager.setSetpointatOutdoorHighTemperature(setpoint_temperature_outdoor_high_C) # Degrees Celsius
-    chw_stpt_manager.setOutdoorLowTemperature(outdoor_low_temperature_C) # Degrees Celsius
-    chw_stpt_manager.setSetpointatOutdoorLowTemperature(setpoint_temperature_outdoor_low_C) # Degrees Celsius
+    chw_stpt_manager.setOutdoorHighTemperature(outdoor_high_temperature_c) # Degrees Celsius
+    chw_stpt_manager.setSetpointatOutdoorHighTemperature(setpoint_temperature_outdoor_high_c) # Degrees Celsius
+    chw_stpt_manager.setOutdoorLowTemperature(outdoor_low_temperature_c) # Degrees Celsius
+    chw_stpt_manager.setSetpointatOutdoorLowTemperature(setpoint_temperature_outdoor_low_c) # Degrees Celsius
     chw_stpt_manager.addToNode(chilled_water_loop.supplyOutletNode)
 
     return true
@@ -450,5 +391,4 @@ class ASHRAE901PRM < Standard
     pri_sec_config = 'heat_exchanger'
     return pri_sec_config
   end
-
 end

data/lib/openstudio-standards/standards/ashrae_90_1_prm/ashrae_90_1_prm.Space.rb

@@ -1,41 +1,45 @@
 class ASHRAE901PRM < Standard
   # @!group Space
 
-  # Set the infiltration rate for this space to include
-  # the impact of air leakage requirements in the standard.
+  # Set the infiltration rate for this space to include the impact of air leakage requirements in the standard.
   #
-  # @return [Double] true if successful, false if not
+  # @param space [OpenStudio::Model::Space] space object
+  # @param tot_infil_m3_per_s [Float] total infiltration in m3/s
+  # @param infil_method [String] infiltration method
+  # @param infil_coefficients [Array] Array of 4 items
+  #       [Constant Term Coefficient, Temperature Term Coefficient,
+  #         Velocity Term Coefficient, Velocity Squared Term Coefficient]
+  # @return [Boolean] returns true if successful, false if not
   def space_apply_infiltration_rate(space, tot_infil_m3_per_s, infil_method, infil_coefficients)
-    # get the climate zone
-    climate_zone = model_standards_climate_zone(space.model)
-
     # Calculate infiltration rate
     case infil_method.to_s
       when 'Flow/ExteriorWallArea'
         # Spread the total infiltration rate
         total_exterior_wall_area = 0
-        space.model.getSpaces.sort.each do |spc|
+        space.model.getSpaces.each do |spc|
           # Get the space conditioning type
           space_cond_type = space_conditioning_category(spc)
-          total_exterior_wall_area += spc.exteriorWallArea unless space_cond_type == 'Unconditioned'
+          total_exterior_wall_area += spc.exteriorWallArea * spc.multiplier unless space_cond_type == 'Unconditioned'
         end
+        prm_raise(total_exterior_wall_area > 0, @sizing_run_dir, 'Total exterior wall area in the model is 0. Check your model inputs')
         adj_infil_flow_ext_wall_area = tot_infil_m3_per_s / total_exterior_wall_area
-        OpenStudio.logFree(OpenStudio::Debug, 'openstudio.standards.Space', "For #{space.name}, adj infil = #{adj_infil_flow_ext_wall_area.round(8)} m^3/s*m^2 of above grade wall area.")
+        OpenStudio.logFree(OpenStudio::Debug, 'prm.log', "For #{space.name}, adj infil = #{adj_infil_flow_ext_wall_area.round(8)} m^3/s*m^2 of above grade wall area.")
       when 'Flow/Area'
         # Spread the total infiltration rate
         total_floor_area = 0
-        space.model.getSpaces.sort.each do |spc|
+        space.model.getSpaces.each do |spc|
           # Get the space conditioning type
           space_cond_type = space_conditioning_category(spc)
-          total_floor_area += spc.floorArea unless space_cond_type == 'Unconditioned' || space.exteriorArea == 0
+          total_floor_area += spc.floorArea * spc.multipler unless space_cond_type == 'Unconditioned' || space.exteriorArea == 0
         end
+        prm_raise(total_floor_area > 0, @sizing_run_dir, 'Sum of the floor area in exterior spaces in the model is 0. Check your model inputs')
         adj_infil_flow_area = tot_infil_m3_per_s / total_floor_area
-        OpenStudio.logFree(OpenStudio::Debug, 'openstudio.standards.Space', "For #{space.name}, adj infil = #{adj_infil_flow_area.round(8)} m^3/s*m^2 of space floor area.")
+        OpenStudio.logFree(OpenStudio::Debug, 'prm.log', "For #{space.name}, adj infil = #{adj_infil_flow_area.round(8)} m^3/s*m^2 of space floor area.")
     end
 
     # Get any infiltration schedule already assigned to this space or its space type
     # If not, the always on schedule will be applied.
-    # TODO-PRM: Infiltration schedules should be based on HVAC operation
+    # @todo Infiltration schedules should be based on HVAC operation
     infil_sch = nil
     unless space.spaceInfiltrationDesignFlowRates.empty?
       old_infil = space.spaceInfiltrationDesignFlowRates[0]
@@ -96,11 +100,65 @@ class ASHRAE901PRM < Standard
 
   # For stable baseline, remove all daylighting controls (sidelighting and toplighting)
   # @param space [OpenStudio::Model::Space] the space with daylighting
-  # @param remove_existing_controls [Bool] if true, will remove existing controls then add new ones
-  # @param draw_daylight_areas_for_debugging [Bool] If this argument is set to true,
-  # @return [boolean] true if successful
+  # @param remove_existing [Boolean] if true, will remove existing controls then add new ones
+  # @param draw_areas_for_debug [Boolean] If this argument is set to true,
+  # @return [Boolean] returns true if successful, false if not
   def space_set_baseline_daylighting_controls(space, remove_existing = false, draw_areas_for_debug = false)
     removed = space_remove_daylighting_controls(space)
     return removed
   end
+
+  # Create and assign PRM computer room electric equipment schedule
+  #
+  # @param space [OpenStudio::Model::Space] OpenStudio Space object
+  # @return [Boolean] returns true if successful, false if not
+  def space_add_prm_computer_room_equipment_schedule(space)
+    # Get proposed or baseline model
+    model = space.model
+
+    # Get space type associated with the space
+    standard_space_type = prm_get_optional_handler(space, @sizing_run_dir, 'spaceType', 'standardsSpaceType').delete(' ').downcase
+
+    # Check if the PRM computer room schedule is already in the model
+    schedule_name = 'ASHRAE 90.1 Appendix G - Computer Room Equipment Schedule'
+    schedule_found = model.getScheduleRulesetByName(schedule_name)
+
+    # Create and assign the the electric equipment schedule
+    if standard_space_type == 'computerroom'
+      space.spaceType.get.electricEquipment.each do |elec_equipment|
+        # Only create the schedule if it could not be found
+        if !schedule_found.is_initialized
+          computer_room_equipment_schedule_ruleset = OpenStudio::Model::ScheduleRuleset.new(model)
+          computer_room_equipment_schedule_ruleset.setName(schedule_name)
+          schedule_fractions = [0.25, 0.5, 0.75, 1.0, 0.25, 0.5, 0.75, 1.0, 0.25, 0.5, 0.75, 1.0]
+          # Weekdays and weekends schedules
+          schedule_fractions.each_with_index do |frac, i|
+            sch_rule = OpenStudio::Model::ScheduleRule.new(computer_room_equipment_schedule_ruleset)
+            sch_rule.setStartDate(OpenStudio::Date.new(OpenStudio::MonthOfYear.new(i.to_i + 1), 1))
+            # No leap year according to PRM-RM
+            sch_rule.setEndDate(OpenStudio::Date.new(OpenStudio::MonthOfYear.new(i.to_i + 1), Date.new(2006, i.to_i + 1, -1).day))
+            day_sch = sch_rule.daySchedule
+            day_sch.setName("#{schedule_name} - Month #{i + 1} - Fraction #{frac}")
+            model_add_vals_to_sch(model, day_sch, 'Constant', [frac])
+            sch_rule.setApplyAllDays(true)
+          end
+          # Special days schedules
+          equipment_on = OpenStudio::Model::ScheduleDay.new(model)
+          model_add_vals_to_sch(model, equipment_on, 'Constant', [1])
+          equipment_off = OpenStudio::Model::ScheduleDay.new(model)
+          model_add_vals_to_sch(model, equipment_off, 'Constant', [0])
+          computer_room_equipment_schedule_ruleset.setHolidaySchedule(equipment_on)
+          computer_room_equipment_schedule_ruleset.setCustomDay1Schedule(equipment_on)
+          computer_room_equipment_schedule_ruleset.setCustomDay2Schedule(equipment_on)
+          computer_room_equipment_schedule_ruleset.setSummerDesignDaySchedule(equipment_on)
+          computer_room_equipment_schedule_ruleset.setWinterDesignDaySchedule(equipment_off)
+        else
+          computer_room_equipment_schedule_ruleset = model.getScheduleRulesetByName(schedule_name).get
+        end
+        elec_equipment.setSchedule(computer_room_equipment_schedule_ruleset)
+      end
+    end
+
+    return true
+  end
 end

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

@@ -1,4 +1,4 @@
-class ASHRAE901PRM2019 < ASHRAE901PRM
+class ASHRAE901PRM < Standard
   # @!group SpaceType
 
   # Sets the selected internal loads to standards-based or typical values.
@@ -9,16 +9,16 @@ class ASHRAE901PRM2019 < ASHRAE901PRM
   # loads directly assigned to spaces.  This method skips plenums.
   #
   # @param space_type [OpenStudio::Model::SpaceType] space type object
-  # @param set_people [Bool] if true, set the people density.
+  # @param set_people [Boolean] if true, set the people density.
   #   Also, assign reasonable clothing, air velocity, and work efficiency inputs
   #   to allow reasonable thermal comfort metrics to be calculated.
-  # @param set_lights [Bool] if true, set the lighting density, lighting fraction
+  # @param set_lights [Boolean] if true, set the lighting density, lighting fraction
   #   to return air, fraction radiant, and fraction visible.
-  # @param set_electric_equipment [Bool] if true, set the electric equipment density
-  # @param set_gas_equipment [Bool] if true, set the gas equipment density
-  # @param set_ventilation [Bool] if true, set the ventilation rates (per-person and per-area)
-  # @param set_infiltration [Bool] if true, set the infiltration rates
-  # @return [Bool] returns true if successful, false if not
+  # @param set_electric_equipment [Boolean] if true, set the electric equipment density
+  # @param set_gas_equipment [Boolean] if true, set the gas equipment density
+  # @param set_ventilation [Boolean] if true, set the ventilation rates (per-person and per-area)
+  # @param set_infiltration [Boolean] if true, set the infiltration rates
+  # @return [Boolean] returns true if successful, false if not
   def space_type_apply_internal_loads(space_type, set_people, set_lights, set_electric_equipment, set_gas_equipment, set_ventilation, set_infiltration)
     # Skip plenums
     # Check if the space type name
@@ -154,10 +154,12 @@ class ASHRAE901PRM2019 < ASHRAE901PRM
   # @param power_schedule_hash [Hash] equipment operation schedule hash
   # @param space_type [OpenStudio::Model:SpaceType] space type
   # @param user_space_data [Hash] user space data
+  # @return [Boolean] returns true if successful, false if not
   def calculate_electric_value_by_userdata(user_equip_data, power_equipment, power_schedule_hash, space_type, user_space_data = nil)
     # Check if the plug load represents a motor (check if motorhorsepower exist), if so, record the motor HP and efficiency.
     if !user_equip_data['motor_horsepower'].nil?
       # Pre-processing will ensure these three user data are added correctly (float, float, boolean)
+      # @todo move this part to user data processing.
       power_equipment.additionalProperties.setFeature('motor_horsepower', user_equip_data['motor_horsepower'].to_f)
       power_equipment.additionalProperties.setFeature('motor_efficiency', user_equip_data['motor_efficiency'].to_f)
       power_equipment.additionalProperties.setFeature('motor_is_exempt', user_equip_data['motor_is_exempt'])
@@ -168,12 +170,20 @@ class ASHRAE901PRM2019 < ASHRAE901PRM
     else
       # The electric equipment is either an elevator or refrigeration
       OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.ElectricEquipment', "#{power_equipment.name} is an elevator or refrigeration according to the user data provided. Skip receptacle power credit.")
+      return false
     end
+    return true
   end
 
+  # Apply power equipment to space type
+  # This is utility function for applying user data to space type
+  #
+  # @param space_type [OpenStudio::Model:SpaceType]
+  # @return [Boolean] returns true if successful, false if not
   def space_type_apply_power_equipment(space_type)
     # save schedules in a hash in case it is needed for new electric equipment
     power_schedule_hash = {}
+    # @todo move this part to user data processing
     user_electric_equipment_data = @standards_data.key?('userdata_electric_equipment') ? @standards_data['userdata_electric_equipment'] : nil
     user_gas_equipment_data = @standards_data.key?('userdata_gas_equipment') ? @standards_data['userdata_gas_equipment'] : nil
     if user_electric_equipment_data && user_electric_equipment_data.length >= 1
@@ -198,6 +208,7 @@ class ASHRAE901PRM2019 < ASHRAE901PRM
         end
       end
     end
+    return true
   end
 
   # Apply space to space type power equipment adjustment.
@@ -207,7 +218,8 @@ class ASHRAE901PRM2019 < ASHRAE901PRM
   #
   # @param user_spacetypes [Hash] spacetype user data
   # @param user_spaces [Hash] space user data
-  # @param space_array [OpenStudio::Model:Space] list of spaces need for process
+  # @param space_array [Array OpenStudio::Model:Space] list of spaces need for process
+  # @return [Boolean] returns true if successful, false if not
   def space_to_space_type_apply_power_equipment(user_spacetypes, user_spaces, space_array)
     # Step 1: Set electric / gas equipment
     # save schedules in a hash in case it is needed for new electric equipment
@@ -265,17 +277,19 @@ class ASHRAE901PRM2019 < ASHRAE901PRM
         end
       end
     end
+    return true
   end
 
   # Function update a power equipment schedule based on user data.
   # This function works with both electric equipment and gas equipment and applies the ruleset on power equipment
   # The function process user data including the fraction of controlled receptacles and receptacle power savings.
   #
-  # @parma power_equipment [OpenStudio::Model::ElectricEquipment] or [OpenStudio::Model:GasEquipment]
+  # @param power_equipment [OpenStudio::Model::ElectricEquipment] or [OpenStudio::Model:GasEquipment]
   # @param user_power_equipment [Hash] user data for the power equipment
   # @param schedule_hash [Hash] power equipment operation schedules in a hash
   # @param space_type [OpenStudio::Model:SpaceType] space type
   # @param user_data [Hash] user space data
+  # @return [Boolean] returns true it adjusted, false if not
   def update_power_equipment_credits(power_equipment, user_power_equipment, schedule_hash, space_type, user_data = nil)
     exception_list = ['office - enclosed <= 250 sf', 'conference/meeting/multipurpose', 'copy/print',
                       'lounge/breakroom - all other', 'lounge/breakroom - healthcare facility', 'classroom/lecture/training - all other',
@@ -319,28 +333,36 @@ class ASHRAE901PRM2019 < ASHRAE901PRM
       end
     end
 
+    # return false if no receptacle power credits
+    unless receptacle_power_credits > 0.0
+      return false
+    end
+
     # Step 2: check if need to adjust the electric equipment schedule. - apply credit if needed.
-    if receptacle_power_credits > 0.0
-      # get current schedule
-      power_schedule = power_equipment.schedule.get
-      power_schedule_name = power_schedule.name.get
-      new_power_schedule_name = format("#{power_schedule_name}_%.4f", receptacle_power_credits)
-      if schedule_hash.key?(new_power_schedule_name)
-        # In this case, there is a schedule created, can retrieve the schedule object and reset in this space type.
-        schedule_rule = schedule_hash[new_power_schedule_name]
-        power_equipment.setSchedule(schedule_rule)
-      else
-        # In this case, create a new schedule
-        # 1. Clone the existing schedule
-        new_rule_set_schedule = deep_copy_schedule(new_power_schedule_name, power_schedule, receptacle_power_credits, space_type.model)
-        if power_equipment.setSchedule(new_rule_set_schedule)
-          schedule_hash[new_power_schedule_name] = new_rule_set_schedule
-        end
+    # get current schedule
+    power_schedule = power_equipment.schedule.get
+    power_schedule_name = power_schedule.name.get
+    new_power_schedule_name = format("#{power_schedule_name}_%.4f", receptacle_power_credits)
+    if schedule_hash.key?(new_power_schedule_name)
+      # In this case, there is a schedule created, can retrieve the schedule object and reset in this space type.
+      schedule_rule = schedule_hash[new_power_schedule_name]
+      power_equipment.setSchedule(schedule_rule)
+    else
+      # In this case, create a new schedule
+      # 1. Clone the existing schedule
+      new_rule_set_schedule = deep_copy_schedule(new_power_schedule_name, power_schedule, receptacle_power_credits, space_type.model)
+      if power_equipment.setSchedule(new_rule_set_schedule)
+        schedule_hash[new_power_schedule_name] = new_rule_set_schedule
       end
     end
+    return true
   end
 
-  # Function to tset LPD on default space type
+  # Function to test LPD on default space type. The function assigns lighting power density to an light object.
+  # @param space_type [OpenStudio::Model::SpaceType]
+  # @param user_spaces [Hash]
+  # @param user_spacetypes [Hash]
+  # @return [Boolean] returns true if successful, false if not
   def set_lpd_on_space_type(space_type, user_spaces, user_spacetypes)
     if has_multi_lpd_values_space_type(space_type)
       # If multiple LPD value exist - then enforce space-space_type one on one relationship
@@ -355,18 +377,21 @@ class ASHRAE901PRM2019 < ASHRAE901PRM
       if space_type.hasAdditionalProperties && space_type.additionalProperties.hasFeature('regulated_lights_name')
         lights_name = space_type.additionalProperties.getFeatureAsString('regulated_lights_name').to_s
         lights_obj = space_type.model.getLightsByName(lights_name).get
+        OpenStudio.logFree(OpenStudio::Info, 'prm.log', "Setting lighting object #{lights_obj.name.get} lighting per area to #{space_type_lighting_per_area} W/ft^2")
         lights_obj.lightsDefinition.setWattsperSpaceFloorArea(OpenStudio.convert(space_type_lighting_per_area.to_f, 'W/ft^2', 'W/m^2').get)
       end
     end
+    return true
   end
 
   # Function that applies user LPD to each space by duplicating space types
   # This function is used when there are user space data available or
   # the spaces under space type has lighting per length value which may cause multiple
   # lighting power densities under one space_type.
-  # @param user_spaces hash data contained in the user space
-  # @param user_spacetypes hash data contained in the user spacetypes
-  # @param space_type OpenStudio::Model::SpaceType object
+  # @param user_spaces [Hash] hash data contained in the user space
+  # @param user_spacetypes [Hash] hash data contained in the user spacetypes
+  # @param space_type [OpenStudio::Model::SpaceType] object
+  # @return [ArrayOpenStudio::Model::Space] List of Spaces
   def space_to_space_type_apply_lighting(user_spaces, user_spacetypes, space_type)
     space_lighting_per_area_hash = {}
     # first priority - user_space data
@@ -426,7 +451,7 @@ class ASHRAE901PRM2019 < ASHRAE901PRM
           new_definition = definition.clone.to_LightsDefinition.get
           new_definition.setWattsperSpaceFloorArea(OpenStudio.convert(lighting_per_area.to_f, 'W/ft^2', 'W/m^2').get)
           inst.setLightsDefinition(new_definition)
-          OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.SpaceType', "#{space_type.name} set LPD to #{lighting_per_area} W/ft^2.")
+          OpenStudio.logFree(OpenStudio::Info, 'log.prm', "#{space_type.name} set LPD to #{lighting_per_area} W/ft^2.")
         end
       end
       space_array.push(space)
@@ -441,22 +466,38 @@ class ASHRAE901PRM2019 < ASHRAE901PRM
     # set schedule for lighting
     schedule_hash = {}
     model.getSpaces.each do |space|
-      space_type = space.spaceType.get
+      space_type = prm_get_optional_handler(space, @sizing_run_dir, 'spaceType')
       if space_type.hasAdditionalProperties && space_type.additionalProperties.hasFeature('regulated_lights_name')
         lights_name = space_type.additionalProperties.getFeatureAsString('regulated_lights_name').to_s
-        ltg = space_type.model.getLightsByName(lights_name).get
+        ltg_option = space_type.model.getLightsByName(lights_name)
+        if ltg_option.is_initialized
+          ltg = ltg_option.get
+        else
+          # raise exception if we cannot find the lights in the model
+          prm_raise(false, @sizing_run_dir, "Cannot find the lights #{lights_name} in the model")
+        end
+        # this will raise exception if the ltg has no schedule assigned.
         if ltg.schedule.is_initialized
           ltg_schedule = ltg.schedule.get
-          ltg_schedule_name = ltg_schedule.name
-          occupancy_sensor_credit = space.additionalProperties.getFeatureAsDouble('occ_control_credit')
-          new_ltg_schedule_name = format("#{ltg_schedule_name}_%.4f", occupancy_sensor_credit)
-          if schedule_hash.key?(new_ltg_schedule_name)
+        else
+          # case such as Attic may have light object but no light schedule assigned
+          # Eplus use default 0 so in here we raise Error but continue processing.
+          ltg_schedule = nil
+          OpenStudio.logFree(OpenStudio::Warn, 'prm.log',
+                             "schedule is not available in component #{ltg.name.get}. Skip processing")
+        end
+
+        if ltg_schedule
+          ltg_schedule_name = ltg_schedule.name.get
+          occupancy_sensor_credit = get_additional_property_as_double(space, 'occ_control_credit', 0.0)
+          if schedule_hash.key?(ltg_schedule_name)
             # In this case, there is a schedule created, can retrieve the schedule object and reset in this space type
-            schedule_rule = schedule_hash[new_ltg_schedule_name]
+            schedule_rule = schedule_hash[ltg_schedule_name]
             ltg.setSchedule(schedule_rule)
           else
             # In this case, create a new schedule
             # 1. Clone the existing schedule
+            new_ltg_schedule_name = format("#{ltg_schedule_name}_%.4f", occupancy_sensor_credit)
             new_rule_set_schedule = deep_copy_schedule(new_ltg_schedule_name, ltg_schedule, occupancy_sensor_credit, model)
             if ltg.setSchedule(new_rule_set_schedule)
               schedule_hash[new_ltg_schedule_name] = new_rule_set_schedule
@@ -468,21 +509,21 @@ class ASHRAE901PRM2019 < ASHRAE901PRM
   end
 
   def deep_copy_schedule(new_schedule_name, schedule, adjustment_factor, model)
-    OpenStudio.logFree(OpenStudio::Info, 'openstudio.model.ScheduleRuleset', "Creating a new lighting schedule that applies occupancy sensor adjustment factor: #{adjustment_factor} based on #{schedule.name.get} schedule")
+    OpenStudio.logFree(OpenStudio::Info, 'prm.log', "Creating a new lighting schedule that applies occupancy sensor adjustment factor: #{adjustment_factor} based on #{schedule.name.get} schedule")
     ruleset = OpenStudio::Model::ScheduleRuleset.new(model)
     ruleset.setName(new_schedule_name)
 
     # schedule types limits and default day schedule - keep the copy
-    schedule_ruleset = schedule.to_ScheduleRuleset.get
-    schedule_type_limit = schedule_ruleset.scheduleTypeLimits.get
+    schedule_ruleset = prm_get_optional_handler(schedule, @sizing_run_dir, 'to_ScheduleRuleset')
+    schedule_type_limit = prm_get_optional_handler(schedule, @sizing_run_dir, 'scheduleTypeLimits')
     default_day_schedule = schedule_ruleset.defaultDaySchedule
     default_winter_design_day_schedule = schedule_ruleset.winterDesignDaySchedule
     default_summer_design_day_schedule = schedule_ruleset.summerDesignDaySchedule
 
     schedule_ruleset.scheduleRules.each do |week_rule|
       day_rule = week_rule.daySchedule
-      start_date = week_rule.startDate.get
-      end_date = week_rule.endDate.get
+      start_date = prm_get_optional_handler(week_rule, @sizing_run_dir, 'startDate')
+      end_date = prm_get_optional_handler(week_rule, @sizing_run_dir, 'endDate')
 
       # create a new day rule - copy and apply the ajustment factor
       new_day_rule = OpenStudio::Model::ScheduleDay.new(model)
@@ -532,11 +573,13 @@ class ASHRAE901PRM2019 < ASHRAE901PRM
   # calculate the lighting power density per area based on space type
   # The function will calculate the LPD based on the space type (STRING)
   # It considers lighting per area, lighting per length as well as occupancy factors in the database.
-  # @param space_type [String]
+  # @param space_type [OpenStudio::Model::SpaceType]
   # @param space [OpenStudio::Model::Space]
+  # @return [Double] lighting power density in the space
   def calculate_lpd_by_space(space_type, space)
     # get interior lighting data
     space_type_properties = interior_lighting_get_prm_data(space_type)
+    OpenStudio.logFree(OpenStudio::Info, 'prm.log', "The lighting properties for space: #{space.name.get} is based on lighting_space_type: #{space_type_properties['lighting_space_type']}, primary_space_type: #{space_type_properties['primary_space_type']}, secondary_space_type: #{space_type_properties['secondary_space_type']}.")
     space_lighting_per_area = 0.0
     # Assign data
     lights_have_info = false
@@ -567,6 +610,8 @@ class ASHRAE901PRM2019 < ASHRAE901PRM
   end
 
   # Function checks whether the user data contains lighting data
+  # @param user_space_data [Hash] space data extracted from user csv.
+  # @return [Boolean] True if there are user lpd values, False otherwise.
   def has_user_lpd_values(user_space_data)
     user_space_data.each do |user_data|
       if user_data.key?('num_std_ltg_types') && user_data['num_std_ltg_types'].to_f > 0
@@ -578,15 +623,21 @@ class ASHRAE901PRM2019 < ASHRAE901PRM
 
   # Function checks whether there are multi lpd values in the space type
   # multi-lpd value means there are multiple spaces and the lighting_per_length > 0
+  # @param space_type [OpenStudio::Model::SpaceType]
+  # @return [Boolean] True if there is lighting power defined by w/ft, False otherwise.
   def has_multi_lpd_values_space_type(space_type)
     space_type_properties = interior_lighting_get_prm_data(space_type)
     lighting_per_length = space_type_properties['w/ft'].to_f
+
     return space_type.spaces.size > 1 && lighting_per_length > 0
   end
 
   # Function checks whether there are multi lpd values in the space type from user's data
   # The sum of each space fraction in the user_data is assumed to be 1.0
   # multi-lpd value means lighting per area > 0 and lighting_per_length > 0
+  # @param user_data [Hash] user data from the user csv
+  # @param space_type [OpenStudio::Model::SpaceType]
+  # @return [Boolean]
   def has_multi_lpd_values_user_data(user_data, space_type)
     num_std_ltg_types = user_data['num_std_ltg_types'].to_i
     std_ltg_index = 0 # loop index
@@ -614,6 +665,7 @@ class ASHRAE901PRM2019 < ASHRAE901PRM
   # The sum of each space fraction in the user_data is assumed to be 1.0
   # @param user_data [Hash] user data from the user csv
   # @param space [OpenStudio::Model::Space]
+  # @return [Double] space lighting per area in W per m2
   def calculate_lpd_from_userdata(user_data, space)
     num_std_ltg_types = user_data['num_std_ltg_types'].to_i
     space_lighting_per_area = 0.0