urbanopt-cli 0.6.2 → 0.7.1

data/example_files/resources/hpxml-measures/HPXMLtoOpenStudio/resources/energyplus.rb

@@ -6,6 +6,8 @@ class EPlus
   EMSActuatorOtherEquipmentPower = 'OtherEquipment', 'Power Level'
   EMSActuatorPumpMassFlowRate = 'Pump', 'Pump Mass Flow Rate'
   EMSActuatorPumpPressureRise = 'Pump', 'Pump Pressure Rise'
+  EMSActuatorFanPressureRise = 'Fan', 'Fan Pressure Rise'
+  EMSActuatorFanTotalEfficiency = 'Fan', 'Fan Total Efficiency'
   EMSActuatorScheduleConstantValue = 'Schedule:Constant', 'Schedule Value'
   EMSActuatorSurfaceViewFactorToGround = 'Surface', 'View Factor To Ground'
   EMSActuatorZoneInfiltrationFlowRate = 'Zone Infiltration', 'Air Exchange Flow Rate'

data/example_files/resources/hpxml-measures/HPXMLtoOpenStudio/resources/geometry.rb

@@ -1,20 +1,20 @@
 # frozen_string_literal: true
 
 class Geometry
-  def self.create_space_and_zone(model, spaces, space_type)
-    if not spaces.keys.include? space_type
+  def self.create_space_and_zone(model, spaces, location)
+    if not spaces.keys.include? location
       thermal_zone = OpenStudio::Model::ThermalZone.new(model)
-      thermal_zone.setName(space_type)
+      thermal_zone.setName(location)
 
       space = OpenStudio::Model::Space.new(model)
-      space.setName(space_type)
+      space.setName(location)
 
       st = OpenStudio::Model::SpaceType.new(model)
-      st.setStandardsSpaceType(space_type)
+      st.setStandardsSpaceType(location)
       space.setSpaceType(st)
 
       space.setThermalZone(thermal_zone)
-      spaces[space_type] = space
+      spaces[location] = space
     end
   end
 
@@ -335,83 +335,93 @@ class Geometry
     end
   end
 
+  def self.calculate_zone_volume(hpxml, location)
+    if [HPXML::LocationBasementUnconditioned,
+        HPXML::LocationCrawlspaceUnvented,
+        HPXML::LocationCrawlspaceVented,
+        HPXML::LocationGarage].include? location
+      floor_area = hpxml.slabs.select { |s| s.interior_adjacent_to == location }.map { |s| s.area }.sum(0.0)
+      if location == HPXML::LocationGarage
+        height = 8.0
+      else
+        height = hpxml.foundation_walls.select { |w| w.interior_adjacent_to == location }.map { |w| w.height }.max
+      end
+      return floor_area * height
+    elsif [HPXML::LocationAtticUnvented,
+           HPXML::LocationAtticVented].include? location
+      floor_area = hpxml.frame_floors.select { |f| [f.interior_adjacent_to, f.exterior_adjacent_to].include? location }.map { |s| s.area }.sum(0.0)
+      roofs = hpxml.roofs.select { |r| r.interior_adjacent_to == location }
+      avg_pitch = roofs.map { |r| r.pitch }.sum(0.0) / roofs.size
+      # Assume square hip roof for volume calculation
+      length = floor_area**0.5
+      height = 0.5 * Math.sin(Math.atan(avg_pitch / 12.0)) * length
+      return [floor_area * height / 3.0, 0.01].max
+    end
+  end
+
   def self.set_zone_volumes(runner, model, spaces, hpxml, apply_ashrae140_assumptions)
     # Living space
     spaces[HPXML::LocationLivingSpace].thermalZone.get.setVolume(UnitConversions.convert(hpxml.building_construction.conditioned_building_volume, 'ft^3', 'm^3'))
 
     # Basement, crawlspace, garage
-    spaces.keys.each do |space_type|
-      next unless [HPXML::LocationBasementUnconditioned, HPXML::LocationCrawlspaceUnvented, HPXML::LocationCrawlspaceVented, HPXML::LocationGarage].include? space_type
-
-      floor_area = hpxml.slabs.select { |s| s.interior_adjacent_to == space_type }.map { |s| s.area }.sum(0.0)
-      if space_type == HPXML::LocationGarage
-        height = 8.0
-      else
-        height = hpxml.foundation_walls.select { |w| w.interior_adjacent_to == space_type }.map { |w| w.height }.max
-      end
+    spaces.keys.each do |location|
+      next unless [HPXML::LocationBasementUnconditioned, HPXML::LocationCrawlspaceUnvented, HPXML::LocationCrawlspaceVented, HPXML::LocationGarage].include? location
 
-      spaces[space_type].thermalZone.get.setVolume(UnitConversions.convert(floor_area * height, 'ft^3', 'm^3'))
+      volume = calculate_zone_volume(hpxml, location)
+      spaces[location].thermalZone.get.setVolume(UnitConversions.convert(volume, 'ft^3', 'm^3'))
     end
 
     # Attic
-    spaces.keys.each do |space_type|
-      next unless [HPXML::LocationAtticUnvented, HPXML::LocationAtticVented].include? space_type
-
-      floor_area = hpxml.frame_floors.select { |f| [f.interior_adjacent_to, f.exterior_adjacent_to].include? space_type }.map { |s| s.area }.sum(0.0)
-      roofs = hpxml.roofs.select { |r| r.interior_adjacent_to == space_type }
-      avg_pitch = roofs.map { |r| r.pitch }.sum(0.0) / roofs.size
+    spaces.keys.each do |location|
+      next unless [HPXML::LocationAtticUnvented, HPXML::LocationAtticVented].include? location
 
       if apply_ashrae140_assumptions
-        # Hardcode the attic volume to match ASHRAE 140 Table 7-2 specification
-        volume = 3463
+        volume = 3463 # Hardcode the attic volume to match ASHRAE 140 Table 7-2 specification
       else
-        # Assume square hip roof for volume calculations; energy results are very insensitive to actual volume
-        length = floor_area**0.5
-        height = 0.5 * Math.sin(Math.atan(avg_pitch / 12.0)) * length
-        volume = [floor_area * height / 3.0, 0.01].max
+        volume = calculate_zone_volume(hpxml, location)
       end
 
-      spaces[space_type].thermalZone.get.setVolume(UnitConversions.convert(volume, 'ft^3', 'm^3'))
+      spaces[location].thermalZone.get.setVolume(UnitConversions.convert(volume, 'ft^3', 'm^3'))
     end
   end
 
-  def self.get_temperature_scheduled_space_values(space_type)
-    if space_type == HPXML::LocationOtherHeatedSpace
+  def self.get_temperature_scheduled_space_values(location)
+    if location == HPXML::LocationOtherHeatedSpace
       # Average of indoor/outdoor temperatures with minimum of heating setpoint
       return { temp_min: 68,
                indoor_weight: 0.5,
                outdoor_weight: 0.5,
                ground_weight: 0.0,
                f_regain: 0.0 }
-    elsif space_type == HPXML::LocationOtherMultifamilyBufferSpace
+    elsif location == HPXML::LocationOtherMultifamilyBufferSpace
       # Average of indoor/outdoor temperatures with minimum of 50 deg-F
       return { temp_min: 50,
                indoor_weight: 0.5,
                outdoor_weight: 0.5,
                ground_weight: 0.0,
                f_regain: 0.0 }
-    elsif space_type == HPXML::LocationOtherNonFreezingSpace
+    elsif location == HPXML::LocationOtherNonFreezingSpace
       # Floating with outdoor air temperature with minimum of 40 deg-F
       return { temp_min: 40,
                indoor_weight: 0.0,
                outdoor_weight: 1.0,
                ground_weight: 0.0,
                f_regain: 0.0 }
-    elsif space_type == HPXML::LocationOtherHousingUnit
+    elsif location == HPXML::LocationOtherHousingUnit
       # Indoor air temperature
       return { temp_min: nil,
                indoor_weight: 1.0,
                outdoor_weight: 0.0,
                ground_weight: 0.0,
                f_regain: 0.0 }
-    elsif space_type == HPXML::LocationExteriorWall
+    elsif location == HPXML::LocationExteriorWall
       # Average of indoor/outdoor temperatures
       return { temp_min: nil,
                indoor_weight: 0.5,
                outdoor_weight: 0.5,
                ground_weight: 0.0,
                f_regain: 0.5 } # From LBNL's "Technical Background for default values used for Forced Air Systems in Proposed ASHRAE Standard 152P"
-    elsif space_type == HPXML::LocationUnderSlab
+    elsif location == HPXML::LocationUnderSlab
       # Ground temperature
       return { temp_min: nil,
                indoor_weight: 0.0,
@@ -419,7 +429,7 @@ class Geometry
                ground_weight: 1.0,
                f_regain: 0.83 } # From LBNL's "Technical Background for default values used for Forced Air Systems in Proposed ASHRAE Standard 152P"
     end
-    fail "Unhandled space type: #{space_type}."
+    fail "Unhandled location: #{location}."
   end
 
   def self.get_height_of_spaces(spaces)
@@ -439,7 +449,7 @@ class Geometry
     zValueArray = []
     surfaceArray.each do |surface|
       surface.vertices.each do |vertex|
-        zValueArray << UnitConversions.convert(vertex.z, 'm', 'ft')
+        zValueArray << UnitConversions.convert(vertex.z, 'm', 'ft').round(5)
       end
     end
     return zValueArray
@@ -479,53 +489,33 @@ class Geometry
     return space_or_zone_is_of_type(space_or_zone, HPXML::LocationGarage)
   end
 
-  def self.space_or_zone_is_of_type(space_or_zone, space_type)
+  def self.space_or_zone_is_of_type(space_or_zone, location)
     if space_or_zone.is_a? OpenStudio::Model::Space
-      return space_is_of_type(space_or_zone, space_type)
+      return space_is_of_type(space_or_zone, location)
     elsif space_or_zone.is_a? OpenStudio::Model::ThermalZone
-      return zone_is_of_type(space_or_zone, space_type)
+      return zone_is_of_type(space_or_zone, location)
     end
   end
 
-  def self.space_is_of_type(space, space_type)
+  def self.space_is_of_type(space, location)
     unless space.isPlenum
       if space.spaceType.is_initialized
         if space.spaceType.get.standardsSpaceType.is_initialized
-          return true if space.spaceType.get.standardsSpaceType.get == space_type
+          return true if space.spaceType.get.standardsSpaceType.get == location
         end
       end
     end
     return false
   end
 
-  def self.zone_is_of_type(zone, space_type)
+  def self.zone_is_of_type(zone, location)
     zone.spaces.each do |space|
-      return space_is_of_type(space, space_type)
+      return space_is_of_type(space, location)
     end
   end
 
-  def self.apply_occupants(model, num_occ, cfa, space, schedules_file)
+  def self.apply_occupants(model, hpxml, num_occ, cfa, space, schedules_file)
     occ_gain, hrs_per_day, sens_frac, lat_frac = Geometry.get_occupancy_default_values()
-    weekday_sch = Schedule.OccupantsWeekdayFractions
-    weekday_sch_sum = weekday_sch.split(',').map(&:to_f).sum(0.0)
-    if (weekday_sch_sum - hrs_per_day).abs > 0.1
-      fail 'Occupancy schedule inconsistent with hrs_per_day.'
-    end
-
-    weekend_sch = Schedule.OccupantsWeekendFractions
-    monthly_sch = Schedule.OccupantsMonthlyMultipliers
-
-    # Error checking
-    if (sens_frac < 0) || (sens_frac > 1)
-      fail 'Sensible fraction must be greater than or equal to 0 and less than or equal to 1.'
-    end
-    if (lat_frac < 0) || (lat_frac > 1)
-      fail 'Latent fraction must be greater than or equal to 0 and less than or equal to 1.'
-    end
-    if lat_frac + sens_frac > 1
-      fail 'Sum of sensible and latent fractions must be less than or equal to 1.'
-    end
-
     activity_per_person = UnitConversions.convert(occ_gain, 'Btu/hr', 'W')
 
     # Hard-coded convective, radiative, latent, and lost fractions
@@ -535,13 +525,15 @@ class Geometry
     occ_rad = 0.558 * occ_sens
     occ_lost = 1 - occ_lat - occ_conv - occ_rad
 
-    space_obj_name = "#{Constants.ObjectNameOccupants}"
-    space_num_occ = num_occ * UnitConversions.convert(space.floorArea, 'm^2', 'ft^2') / cfa
-
     # Create schedule
     if not schedules_file.nil?
       people_sch = schedules_file.create_schedule_file(col_name: 'occupants')
     else
+      weekday_sch = hpxml.building_occupancy.weekday_fractions.split(',').map(&:to_f)
+      weekday_sch = weekday_sch.map { |v| v / weekday_sch.max }.join(',')
+      weekend_sch = hpxml.building_occupancy.weekend_fractions.split(',').map(&:to_f)
+      weekend_sch = weekend_sch.map { |v| v / weekend_sch.max }.join(',')
+      monthly_sch = hpxml.building_occupancy.monthly_multipliers
       people_sch = MonthWeekdayWeekendSchedule.new(model, Constants.ObjectNameOccupants + ' schedule', weekday_sch, weekend_sch, monthly_sch, Constants.ScheduleTypeLimitsFraction)
       people_sch = people_sch.schedule
     end
@@ -554,11 +546,11 @@ class Geometry
     # Add people definition for the occ
     occ_def = OpenStudio::Model::PeopleDefinition.new(model)
     occ = OpenStudio::Model::People.new(occ_def)
-    occ.setName(space_obj_name)
+    occ.setName(Constants.ObjectNameOccupants)
     occ.setSpace(space)
-    occ_def.setName(space_obj_name)
+    occ_def.setName(Constants.ObjectNameOccupants)
     occ_def.setNumberOfPeopleCalculationMethod('People', 1)
-    occ_def.setNumberofPeople(space_num_occ)
+    occ_def.setNumberofPeople(num_occ)
     occ_def.setFractionRadiant(occ_rad)
     occ_def.setSensibleHeatFraction(occ_sens)
     occ_def.setMeanRadiantTemperatureCalculationType('ZoneAveraged')

data/example_files/resources/hpxml-measures/HPXMLtoOpenStudio/resources/hotwater_appliances.rb

@@ -2,12 +2,12 @@
 
 class HotWaterAndAppliances
   def self.apply(model, runner, hpxml, weather, spaces, hot_water_distribution,
-                 solar_thermal_system, eri_version, dhw_map, schedules_file)
+                 solar_thermal_system, eri_version, schedules_file, plantloop_map)
 
     cfa = hpxml.building_construction.conditioned_floor_area
     nbeds = hpxml.building_construction.number_of_bedrooms
     ncfl = hpxml.building_construction.number_of_conditioned_floors
-    has_uncond_bsmnt = hpxml.has_space_type(HPXML::LocationBasementUnconditioned)
+    has_uncond_bsmnt = hpxml.has_location(HPXML::LocationBasementUnconditioned)
     fixtures_usage_multiplier = hpxml.water_heating.water_fixtures_usage_multiplier
     living_space = spaces[HPXML::LocationLivingSpace]
 
@@ -28,26 +28,14 @@ class HotWaterAndAppliances
       oven = hpxml.ovens[0]
     end
 
-    # For each water heater (plant loop):
-    # 1. Create WaterUseConnections object
-    # 2. Obtain setpoint schedule
+    # Create WaterUseConnections object for each water heater (plant loop)
     water_use_connections = {}
-    setpoint_scheds = {}
-    dhw_map.each do |sys_id, dhw_objects|
-      dhw_objects.each do |dhw_object|
-        if dhw_object.is_a? OpenStudio::Model::PlantLoop
-          water_use_connections[sys_id] = OpenStudio::Model::WaterUseConnections.new(model)
-          dhw_map[sys_id] << water_use_connections[sys_id]
-          dhw_object.addDemandBranchForComponent(water_use_connections[sys_id])
-        else
-          # Get water heater setpoint schedule
-          if dhw_object.is_a? OpenStudio::Model::WaterHeaterMixed
-            setpoint_scheds[sys_id] = dhw_object.setpointTemperatureSchedule.get
-          elsif dhw_object.is_a? OpenStudio::Model::WaterHeaterHeatPumpWrappedCondenser
-            setpoint_scheds[sys_id] = dhw_object.compressorSetpointTemperatureSchedule
-          end
-        end
-      end
+    hpxml.water_heating_systems.each do |water_heating_system|
+      plant_loop = plantloop_map[water_heating_system.id]
+      wuc = OpenStudio::Model::WaterUseConnections.new(model)
+      wuc.additionalProperties.setFeature('HPXML_ID', water_heating_system.id) # Used by reporting measure
+      plant_loop.addDemandBranchForComponent(wuc)
+      water_use_connections[water_heating_system.id] = wuc
     end
 
     # Clothes washer energy
@@ -55,12 +43,15 @@ class HotWaterAndAppliances
       cw_annual_kwh, cw_frac_sens, cw_frac_lat, cw_gpd = calc_clothes_washer_energy_gpd(eri_version, nbeds, clothes_washer, clothes_washer.additional_properties.space.nil?)
 
       if not schedules_file.nil?
-        cw_design_level_w = schedules_file.calc_design_level_from_daily_kwh(col_name: 'clothes_washer_power', daily_kwh: cw_annual_kwh / 365.0)
-        power_cw_schedule = schedules_file.create_schedule_file(col_name: 'clothes_washer_power')
+        cw_design_level_w = schedules_file.calc_design_level_from_daily_kwh(col_name: 'clothes_washer', daily_kwh: cw_annual_kwh / 365.0)
+        power_cw_schedule = schedules_file.create_schedule_file(col_name: 'clothes_washer')
       else
-        cw_schedule = HotWaterSchedule.new(model, Constants.ObjectNameClothesWasher, nbeds)
-        cw_design_level_w = cw_schedule.calcDesignLevelFromDailykWh(cw_annual_kwh / 365.0)
-        power_cw_schedule = cw_schedule.schedule
+        cw_weekday_sch = clothes_washer.weekday_fractions
+        cw_weekend_sch = clothes_washer.weekend_fractions
+        cw_monthly_sch = clothes_washer.monthly_multipliers
+        cw_schedule_obj = MonthWeekdayWeekendSchedule.new(model, Constants.ObjectNameClothesWasher, cw_weekday_sch, cw_weekend_sch, cw_monthly_sch, Constants.ScheduleTypeLimitsFraction)
+        cw_design_level_w = cw_schedule_obj.calcDesignLevelFromDailykWh(cw_annual_kwh / 365.0)
+        power_cw_schedule = cw_schedule_obj.schedule
       end
 
       cw_space = clothes_washer.additional_properties.space
@@ -77,11 +68,13 @@ class HotWaterAndAppliances
         cd_design_level_f = schedules_file.calc_design_level_from_annual_therm(col_name: 'clothes_dryer', annual_therm: cd_annual_therm)
         cd_schedule = schedules_file.create_schedule_file(col_name: 'clothes_dryer')
       else
-        days_shift = -1.0 / 24.0 # Shift by 1 hour relative to clothes washer
-        cd_schedule = HotWaterSchedule.new(model, Constants.ObjectNameClothesDryer, nbeds, days_shift)
-        cd_design_level_e = cd_schedule.calcDesignLevelFromDailykWh(cd_annual_kwh / 365.0)
-        cd_design_level_f = cd_schedule.calcDesignLevelFromDailyTherm(cd_annual_therm / 365.0)
-        cd_schedule = cd_schedule.schedule
+        cd_weekday_sch = clothes_dryer.weekday_fractions
+        cd_weekend_sch = clothes_dryer.weekend_fractions
+        cd_monthly_sch = clothes_dryer.monthly_multipliers
+        cd_schedule_obj = MonthWeekdayWeekendSchedule.new(model, Constants.ObjectNameClothesDryer, cd_weekday_sch, cd_weekend_sch, cd_monthly_sch, Constants.ScheduleTypeLimitsFraction)
+        cd_design_level_e = cd_schedule_obj.calcDesignLevelFromDailykWh(cd_annual_kwh / 365.0)
+        cd_design_level_f = cd_schedule_obj.calcDesignLevelFromDailyTherm(cd_annual_therm / 365.0)
+        cd_schedule = cd_schedule_obj.schedule
       end
 
       cd_space = clothes_dryer.additional_properties.space
@@ -95,12 +88,15 @@ class HotWaterAndAppliances
       dw_annual_kwh, dw_frac_sens, dw_frac_lat, dw_gpd = calc_dishwasher_energy_gpd(eri_version, nbeds, dishwasher, dishwasher.additional_properties.space.nil?)
 
       if not schedules_file.nil?
-        dw_design_level_w = schedules_file.calc_design_level_from_daily_kwh(col_name: 'dishwasher_power', daily_kwh: dw_annual_kwh / 365.0)
-        power_dw_schedule = schedules_file.create_schedule_file(col_name: 'dishwasher_power')
+        dw_design_level_w = schedules_file.calc_design_level_from_daily_kwh(col_name: 'dishwasher', daily_kwh: dw_annual_kwh / 365.0)
+        power_dw_schedule = schedules_file.create_schedule_file(col_name: 'dishwasher')
       else
-        dw_schedule = HotWaterSchedule.new(model, Constants.ObjectNameDishwasher, nbeds)
-        dw_design_level_w = dw_schedule.calcDesignLevelFromDailykWh(dw_annual_kwh / 365.0)
-        power_dw_schedule = dw_schedule.schedule
+        dw_weekday_sch = dishwasher.weekday_fractions
+        dw_weekend_sch = dishwasher.weekend_fractions
+        dw_monthly_sch = dishwasher.monthly_multipliers
+        dw_schedule_obj = MonthWeekdayWeekendSchedule.new(model, Constants.ObjectNameDishwasher, dw_weekday_sch, dw_weekend_sch, dw_monthly_sch, Constants.ScheduleTypeLimitsFraction)
+        dw_design_level_w = dw_schedule_obj.calcDesignLevelFromDailykWh(dw_annual_kwh / 365.0)
+        power_dw_schedule = dw_schedule_obj.schedule
       end
 
       dw_space = dishwasher.additional_properties.space
@@ -113,15 +109,16 @@ class HotWaterAndAppliances
       rf_annual_kwh, rf_frac_sens, rf_frac_lat = calc_refrigerator_or_freezer_energy(refrigerator, refrigerator.additional_properties.space.nil?)
 
       if not schedules_file.nil?
-        fridge_design_level = schedules_file.calc_design_level_from_annual_kwh(col_name: 'refrigerator', annual_kwh: rf_annual_kwh)
-        fridge_schedule = schedules_file.create_schedule_file(col_name: 'refrigerator')
+        fridge_col_name = refrigerator.primary_indicator ? 'refrigerator' : 'extra_refrigerator'
+        fridge_design_level = schedules_file.calc_design_level_from_annual_kwh(col_name: fridge_col_name, annual_kwh: rf_annual_kwh)
+        fridge_schedule = schedules_file.create_schedule_file(col_name: fridge_col_name)
       else
         fridge_weekday_sch = refrigerator.weekday_fractions
         fridge_weekend_sch = refrigerator.weekend_fractions
         fridge_monthly_sch = refrigerator.monthly_multipliers
-        fridge_schedule = MonthWeekdayWeekendSchedule.new(model, Constants.ObjectNameRefrigerator, fridge_weekday_sch, fridge_weekend_sch, fridge_monthly_sch, Constants.ScheduleTypeLimitsFraction)
-        fridge_design_level = fridge_schedule.calcDesignLevelFromDailykWh(rf_annual_kwh / 365.0)
-        fridge_schedule = fridge_schedule.schedule
+        fridge_schedule_obj = MonthWeekdayWeekendSchedule.new(model, Constants.ObjectNameRefrigerator, fridge_weekday_sch, fridge_weekend_sch, fridge_monthly_sch, Constants.ScheduleTypeLimitsFraction)
+        fridge_design_level = fridge_schedule_obj.calcDesignLevelFromDailykWh(rf_annual_kwh / 365.0)
+        fridge_schedule = fridge_schedule_obj.schedule
       end
 
       rf_space = refrigerator.additional_properties.space
@@ -140,9 +137,9 @@ class HotWaterAndAppliances
         freezer_weekday_sch = freezer.weekday_fractions
         freezer_weekend_sch = freezer.weekend_fractions
         freezer_monthly_sch = freezer.monthly_multipliers
-        freezer_schedule = MonthWeekdayWeekendSchedule.new(model, Constants.ObjectNameFreezer, freezer_weekday_sch, freezer_weekend_sch, freezer_monthly_sch, Constants.ScheduleTypeLimitsFraction)
-        freezer_design_level = freezer_schedule.calcDesignLevelFromDailykWh(fz_annual_kwh / 365.0)
-        freezer_schedule = freezer_schedule.schedule
+        freezer_schedule_obj = MonthWeekdayWeekendSchedule.new(model, Constants.ObjectNameFreezer, freezer_weekday_sch, freezer_weekend_sch, freezer_monthly_sch, Constants.ScheduleTypeLimitsFraction)
+        freezer_design_level = freezer_schedule_obj.calcDesignLevelFromDailykWh(fz_annual_kwh / 365.0)
+        freezer_schedule = freezer_schedule_obj.schedule
       end
 
       fz_space = freezer.additional_properties.space
@@ -162,10 +159,10 @@ class HotWaterAndAppliances
         cook_weekday_sch = cooking_range.weekday_fractions
         cook_weekend_sch = cooking_range.weekend_fractions
         cook_monthly_sch = cooking_range.monthly_multipliers
-        cook_schedule = MonthWeekdayWeekendSchedule.new(model, Constants.ObjectNameCookingRange, cook_weekday_sch, cook_weekend_sch, cook_monthly_sch, Constants.ScheduleTypeLimitsFraction)
-        cook_design_level_e = cook_schedule.calcDesignLevelFromDailykWh(cook_annual_kwh / 365.0)
-        cook_design_level_f = cook_schedule.calcDesignLevelFromDailyTherm(cook_annual_therm / 365.0)
-        cook_schedule = cook_schedule.schedule
+        cook_schedule_obj = MonthWeekdayWeekendSchedule.new(model, Constants.ObjectNameCookingRange, cook_weekday_sch, cook_weekend_sch, cook_monthly_sch, Constants.ScheduleTypeLimitsFraction)
+        cook_design_level_e = cook_schedule_obj.calcDesignLevelFromDailykWh(cook_annual_kwh / 365.0)
+        cook_design_level_f = cook_schedule_obj.calcDesignLevelFromDailyTherm(cook_annual_therm / 365.0)
+        cook_schedule = cook_schedule_obj.schedule
       end
 
       cook_space = cooking_range.additional_properties.space
@@ -195,21 +192,25 @@ class HotWaterAndAppliances
       # Schedules
       # Replace mains water temperature schedule with water heater inlet temperature schedule.
       # These are identical unless there is a DWHR.
-      start_date = OpenStudio::Date.new(OpenStudio::MonthOfYear.new(1), 1, model.getYearDescription.assumedYear)
+      start_date = OpenStudio::Date.new(OpenStudio::MonthOfYear.new(1), 1, hpxml.header.sim_calendar_year)
       timestep_day = OpenStudio::Time.new(1, 0)
       time_series_tmains = OpenStudio::TimeSeries.new(start_date, timestep_day, OpenStudio::createVector(daily_wh_inlet_temperatures_c), 'C')
       schedule_tmains = OpenStudio::Model::ScheduleInterval.fromTimeSeries(time_series_tmains, model).get
       schedule_tmains.setName('mains temperature schedule')
       model.getSiteWaterMainsTemperature.setTemperatureSchedule(schedule_tmains)
-      mw_schedule = OpenStudio::Model::ScheduleConstant.new(model)
-      mw_schedule.setValue(UnitConversions.convert(t_mix, 'F', 'C'))
-      Schedule.set_schedule_type_limits(model, mw_schedule, Constants.ScheduleTypeLimitsTemperature)
+      mw_temp_schedule = OpenStudio::Model::ScheduleConstant.new(model)
+      mw_temp_schedule.setName('mixed water temperature schedule')
+      mw_temp_schedule.setValue(UnitConversions.convert(t_mix, 'F', 'C'))
+      Schedule.set_schedule_type_limits(model, mw_temp_schedule, Constants.ScheduleTypeLimitsTemperature)
 
       if not schedules_file.nil?
-        water_schedule = schedules_file.create_schedule_file(col_name: 'fixtures')
+        fixtures_schedule = schedules_file.create_schedule_file(col_name: 'hot_water_fixtures')
       else
-        schedule_obj = HotWaterSchedule.new(model, Constants.ObjectNameFixtures, nbeds)
-        water_schedule = schedule_obj.schedule
+        fixtures_weekday_sch = hpxml.water_heating.water_fixtures_weekday_fractions
+        fixtures_weekend_sch = hpxml.water_heating.water_fixtures_weekend_fractions
+        fixtures_monthly_sch = hpxml.water_heating.water_fixtures_monthly_multipliers
+        fixtures_schedule_obj = MonthWeekdayWeekendSchedule.new(model, Constants.ObjectNameFixtures, fixtures_weekday_sch, fixtures_weekend_sch, fixtures_monthly_sch, Constants.ScheduleTypeLimitsFraction)
+        fixtures_schedule = fixtures_schedule_obj.schedule
       end
     end
 
@@ -223,28 +224,31 @@ class HotWaterAndAppliances
         w_gpd = get_dist_waste_gpd(eri_version, nbeds, has_uncond_bsmnt, cfa, ncfl, hot_water_distribution, fixtures_all_low_flow, fixtures_usage_multiplier)
 
         if not schedules_file.nil?
-          fx_peak_flow = schedules_file.calc_peak_flow_from_daily_gpm(col_name: 'fixtures', daily_water: fx_gpd)
-          dist_water_peak_flow = schedules_file.calc_peak_flow_from_daily_gpm(col_name: 'fixtures', daily_water: w_gpd)
+          fx_peak_flow = schedules_file.calc_peak_flow_from_daily_gpm(col_name: 'hot_water_fixtures', daily_water: fx_gpd)
+          dist_water_peak_flow = schedules_file.calc_peak_flow_from_daily_gpm(col_name: 'hot_water_fixtures', daily_water: w_gpd)
         else
-          fx_peak_flow = schedule_obj.calcPeakFlowFromDailygpm(fx_gpd)
-          dist_water_peak_flow = schedule_obj.calcPeakFlowFromDailygpm(w_gpd)
+          fx_peak_flow = fixtures_schedule_obj.calcPeakFlowFromDailygpm(fx_gpd)
+          dist_water_peak_flow = fixtures_schedule_obj.calcPeakFlowFromDailygpm(w_gpd)
         end
 
         # Fixtures (showers, sinks, baths)
-        add_water_use_equipment(model, Constants.ObjectNameFixtures, fx_peak_flow * gpd_frac * non_solar_fraction, water_schedule, mw_schedule, water_use_connections[water_heating_system.id])
+        add_water_use_equipment(model, Constants.ObjectNameFixtures, fx_peak_flow * gpd_frac * non_solar_fraction, fixtures_schedule, water_use_connections[water_heating_system.id], mw_temp_schedule)
 
         # Distribution waste (primary driven by fixture draws)
-        add_water_use_equipment(model, Constants.ObjectNameDistributionWaste, dist_water_peak_flow * gpd_frac * non_solar_fraction, water_schedule, mw_schedule, water_use_connections[water_heating_system.id])
+        add_water_use_equipment(model, Constants.ObjectNameDistributionWaste, dist_water_peak_flow * gpd_frac * non_solar_fraction, fixtures_schedule, water_use_connections[water_heating_system.id], mw_temp_schedule)
 
         # Recirculation pump
         dist_pump_annual_kwh = get_hwdist_recirc_pump_energy(hot_water_distribution)
         if dist_pump_annual_kwh > 0
-          dist_pump_weekday_sch = '0.010, 0.006, 0.004, 0.002, 0.004, 0.006, 0.016, 0.032, 0.048, 0.068, 0.078, 0.081, 0.074, 0.067, 0.057, 0.061, 0.055, 0.054, 0.051, 0.051, 0.052, 0.054, 0.044, 0.024'
-          dist_pump_monthly_sch = '1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0'
-          dist_pump_schedule = MonthWeekdayWeekendSchedule.new(model, Constants.ObjectNameHotWaterRecircPump, dist_pump_weekday_sch, dist_pump_weekday_sch, dist_pump_monthly_sch)
-          dist_pump_design_level = dist_pump_schedule.calcDesignLevelFromDailykWh(dist_pump_annual_kwh / 365.0)
-          dist_pump = add_electric_equipment(model, Constants.ObjectNameHotWaterRecircPump, living_space, dist_pump_design_level * gpd_frac, 0.0, 0.0, dist_pump_schedule.schedule)
-          dhw_map[water_heating_system.id] << dist_pump unless dist_pump.nil?
+          if not schedules_file.nil?
+            dist_pump_design_level = schedules_file.calc_design_level_from_daily_kwh(col_name: 'hot_water_fixtures', daily_kwh: dist_pump_annual_kwh / 365.0)
+          else
+            dist_pump_design_level = fixtures_schedule_obj.calcDesignLevelFromDailykWh(dist_pump_annual_kwh / 365.0)
+          end
+          dist_pump = add_electric_equipment(model, Constants.ObjectNameHotWaterRecircPump, living_space, dist_pump_design_level * gpd_frac, 0.0, 0.0, fixtures_schedule)
+          if not dist_pump.nil?
+            dist_pump.additionalProperties.setFeature('HPXML_ID', water_heating_system.id) # Used by reporting measure
+          end
         end
       end
 
@@ -258,13 +262,13 @@ class HotWaterAndAppliances
         end
         if not gpd_frac.nil?
           if not schedules_file.nil?
-            cw_peak_flow = schedules_file.calc_peak_flow_from_daily_gpm(col_name: 'clothes_washer', daily_water: cw_gpd)
-            water_cw_schedule = schedules_file.create_schedule_file(col_name: 'clothes_washer')
+            cw_peak_flow = schedules_file.calc_peak_flow_from_daily_gpm(col_name: 'hot_water_clothes_washer', daily_water: cw_gpd)
+            water_cw_schedule = schedules_file.create_schedule_file(col_name: 'hot_water_clothes_washer')
           else
-            cw_peak_flow = cw_schedule.calcPeakFlowFromDailygpm(cw_gpd)
-            water_cw_schedule = cw_schedule.schedule
+            cw_peak_flow = cw_schedule_obj.calcPeakFlowFromDailygpm(cw_gpd)
+            water_cw_schedule = cw_schedule_obj.schedule
           end
-          add_water_use_equipment(model, Constants.ObjectNameClothesWasher, cw_peak_flow * gpd_frac * non_solar_fraction, water_cw_schedule, setpoint_scheds[water_heating_system.id], water_use_connections[water_heating_system.id])
+          add_water_use_equipment(model, Constants.ObjectNameClothesWasher, cw_peak_flow * gpd_frac * non_solar_fraction, water_cw_schedule, water_use_connections[water_heating_system.id])
         end
       end
 
@@ -278,14 +282,15 @@ class HotWaterAndAppliances
         gpd_frac = water_heating_system.fraction_dhw_load_served
       end
       next unless not gpd_frac.nil?
+
       if not schedules_file.nil?
-        dw_peak_flow = schedules_file.calc_peak_flow_from_daily_gpm(col_name: 'dishwasher', daily_water: dw_gpd)
-        water_dw_schedule = schedules_file.create_schedule_file(col_name: 'dishwasher')
+        dw_peak_flow = schedules_file.calc_peak_flow_from_daily_gpm(col_name: 'hot_water_dishwasher', daily_water: dw_gpd)
+        water_dw_schedule = schedules_file.create_schedule_file(col_name: 'hot_water_dishwasher')
       else
-        dw_peak_flow = dw_schedule.calcPeakFlowFromDailygpm(dw_gpd)
-        water_dw_schedule = dw_schedule.schedule
+        dw_peak_flow = dw_schedule_obj.calcPeakFlowFromDailygpm(dw_gpd)
+        water_dw_schedule = dw_schedule_obj.schedule
       end
-      add_water_use_equipment(model, Constants.ObjectNameDishwasher, dw_peak_flow * gpd_frac * non_solar_fraction, water_dw_schedule, setpoint_scheds[water_heating_system.id], water_use_connections[water_heating_system.id])
+      add_water_use_equipment(model, Constants.ObjectNameDishwasher, dw_peak_flow * gpd_frac * non_solar_fraction, water_dw_schedule, water_use_connections[water_heating_system.id])
     end
 
     if not hot_water_distribution.nil?
@@ -293,14 +298,14 @@ class HotWaterAndAppliances
       # Floor mopping, shower evaporation, water films on showers, tubs & sinks surfaces, plant watering, etc.
       water_sens_btu, water_lat_btu = get_water_gains_sens_lat(nbeds)
       if not schedules_file.nil?
-        water_design_level_sens = schedules_file.calc_design_level_from_daily_kwh(col_name: 'fixtures', daily_kwh: UnitConversions.convert(water_sens_btu, 'Btu', 'kWh') / 365.0)
-        water_design_level_lat = schedules_file.calc_design_level_from_daily_kwh(col_name: 'fixtures', daily_kwh: UnitConversions.convert(water_lat_btu, 'Btu', 'kWh') / 365.0)
+        water_design_level_sens = schedules_file.calc_design_level_from_daily_kwh(col_name: 'hot_water_fixtures', daily_kwh: UnitConversions.convert(water_sens_btu, 'Btu', 'kWh') / 365.0)
+        water_design_level_lat = schedules_file.calc_design_level_from_daily_kwh(col_name: 'hot_water_fixtures', daily_kwh: UnitConversions.convert(water_lat_btu, 'Btu', 'kWh') / 365.0)
       else
-        water_design_level_sens = schedule_obj.calcDesignLevelFromDailykWh(UnitConversions.convert(water_sens_btu, 'Btu', 'kWh') / 365.0)
-        water_design_level_lat = schedule_obj.calcDesignLevelFromDailykWh(UnitConversions.convert(water_lat_btu, 'Btu', 'kWh') / 365.0)
+        water_design_level_sens = fixtures_schedule_obj.calcDesignLevelFromDailykWh(UnitConversions.convert(water_sens_btu, 'Btu', 'kWh') / 365.0)
+        water_design_level_lat = fixtures_schedule_obj.calcDesignLevelFromDailykWh(UnitConversions.convert(water_lat_btu, 'Btu', 'kWh') / 365.0)
       end
-      add_other_equipment(model, Constants.ObjectNameWaterSensible, living_space, water_design_level_sens, 1.0, 0.0, water_schedule, nil)
-      add_other_equipment(model, Constants.ObjectNameWaterLatent, living_space, water_design_level_lat, 0.0, 1.0, water_schedule, nil)
+      add_other_equipment(model, Constants.ObjectNameWaterSensible, living_space, water_design_level_sens, 1.0, 0.0, fixtures_schedule, nil)
+      add_other_equipment(model, Constants.ObjectNameWaterLatent, living_space, water_design_level_lat, 0.0, 1.0, fixtures_schedule, nil)
     end
   end
 
@@ -597,11 +602,7 @@ class HotWaterAndAppliances
 
   def self.calc_refrigerator_or_freezer_energy(refrigerator_or_freezer, is_outside = false)
     # Get values
-    annual_kwh = refrigerator_or_freezer.adjusted_annual_kwh
-    if annual_kwh.nil?
-      annual_kwh = refrigerator_or_freezer.rated_annual_kwh
-    end
-
+    annual_kwh = refrigerator_or_freezer.rated_annual_kwh
     annual_kwh *= refrigerator_or_freezer.usage_multiplier
     if not is_outside
       frac_sens = 1.0
@@ -717,7 +718,7 @@ class HotWaterAndAppliances
     return oe
   end
 
-  def self.add_water_use_equipment(model, obj_name, peak_flow, schedule, temp_schedule, water_use_connections)
+  def self.add_water_use_equipment(model, obj_name, peak_flow, schedule, water_use_connections, mw_temp_schedule = nil)
     return if peak_flow == 0.0
 
     wu_def = OpenStudio::Model::WaterUseEquipmentDefinition.new(model)
@@ -727,7 +728,9 @@ class HotWaterAndAppliances
     wu_def.setPeakFlowRate(peak_flow)
     wu_def.setEndUseSubcategory(obj_name)
     wu.setFlowRateFractionSchedule(schedule)
-    wu_def.setTargetTemperatureSchedule(temp_schedule)
+    if not mw_temp_schedule.nil?
+      wu_def.setTargetTemperatureSchedule(mw_temp_schedule)
+    end
     water_use_connections.addWaterUseEquipment(wu)
 
     return wu
@@ -969,9 +972,9 @@ class HotWaterAndAppliances
                                              HPXML::LocationLivingSpace]
 
     extra_refrigerator_location = nil
-    extra_refrigerator_location_hierarchy.each do |space_type|
-      if hpxml.has_space_type(space_type)
-        extra_refrigerator_location = space_type
+    extra_refrigerator_location_hierarchy.each do |location|
+      if hpxml.has_location(location)
+        extra_refrigerator_location = location
         break
       end
     end