urbanopt-cli 0.6.1 → 0.7.0

data/example_files/resources/hpxml-measures/{BuildResidentialHPXML → BuildResidentialScheduleFile}/resources/schedules.rb

@@ -6,36 +6,28 @@ require 'matrix'
 
 class ScheduleGenerator
   def initialize(runner:,
-                 model:,
                  epw_file:,
-                 building_id: nil,
-                 random_seed: nil)
+                 state:,
+                 random_seed: nil,
+                 minutes_per_step:,
+                 steps_in_day:,
+                 mkc_ts_per_day:,
+                 mkc_ts_per_hour:,
+                 total_days_in_year:,
+                 sim_year:,
+                 sim_start_day:,
+                 **remainder)
     @runner = runner
-    @model = model
     @epw_file = epw_file
-    @state = 'CO'
-    unless epw_file.stateProvinceRegion.empty?
-      @state = epw_file.stateProvinceRegion
-    end
-    @building_id = building_id
+    @state = state
     @random_seed = random_seed
-  end
-
-  def get_simulation_parameters
-    @minutes_per_step = 60
-    if @model.getSimulationControl.timestep.is_initialized
-      @minutes_per_step = 60 / @model.getSimulationControl.timestep.get.numberOfTimestepsPerHour
-    end
-
-    @steps_in_day = 24 * 60 / @minutes_per_step
-
-    @mkc_ts_per_day = 96
-    @mkc_ts_per_hour = @mkc_ts_per_day / 24
-
-    @model.getYearDescription.isLeapYear ? @total_days_in_year = 366 : @total_days_in_year = 365
-
-    @sim_year = @model.getYearDescription.calendarYear.get
-    @sim_start_day = DateTime.new(@sim_year, 1, 1)
+    @minutes_per_step = minutes_per_step
+    @steps_in_day = steps_in_day
+    @mkc_ts_per_day = mkc_ts_per_day
+    @mkc_ts_per_hour = mkc_ts_per_hour
+    @total_days_in_year = total_days_in_year
+    @sim_year = sim_year
+    @sim_start_day = sim_start_day
   end
 
   def get_random_seed
@@ -49,51 +41,15 @@ class ScheduleGenerator
     return seed
   end
 
-  def self.col_names
-    # col_name => affected_by_vacancy
-    return {
-      'occupants' => true,
-      'lighting_interior' => true,
-      'lighting_exterior' => true,
-      'lighting_garage' => true,
-      'lighting_exterior_holiday' => true,
-      'cooking_range' => true,
-      'refrigerator' => false,
-      'extra_refrigerator' => false,
-      'freezer' => false,
-      'dishwasher' => true,
-      'dishwasher_power' => true,
-      'clothes_washer' => true,
-      'clothes_washer_power' => true,
-      'clothes_dryer' => true,
-      'clothes_dryer_exhaust' => true,
-      'baths' => true,
-      'showers' => true,
-      'sinks' => true,
-      'fixtures' => true,
-      'ceiling_fan' => true,
-      'plug_loads_other' => true,
-      'plug_loads_tv' => true,
-      'plug_loads_vehicle' => true,
-      'plug_loads_well_pump' => true,
-      'fuel_loads_grill' => true,
-      'fuel_loads_lighting' => true,
-      'fuel_loads_fireplace' => true,
-      'pool_pump' => false,
-      'pool_heater' => false,
-      'hot_tub_pump' => false,
-      'hot_tub_heater' => false,
-      'sleep' => nil,
-      'vacancy' => nil
-    }
-  end
-
   def initialize_schedules
     @schedules = {}
 
-    ScheduleGenerator.col_names.keys.each do |col_name|
+    Constants.ScheduleColNames.keys.each do |col_name|
+      next if col_name == 'vacancy'
+
       @schedules[col_name] = Array.new(@total_days_in_year * @steps_in_day, 0.0)
     end
+    @schedules['sleep'] = Array.new(@total_days_in_year * @steps_in_day, 0.0)
 
     return @schedules
   end
@@ -103,22 +59,29 @@ class ScheduleGenerator
   end
 
   def create(args:)
-    get_simulation_parameters
     initialize_schedules
 
-    success = create_average_schedules(args: args)
+    success = create_average_schedules
     return false if not success
 
-    success = create_stochastic_schedules(args: args)
-    return false if not success
+    if args[:schedules_type] == 'stochastic'
+      success = create_stochastic_schedules(args: args)
+      return false if not success
+    end
 
     success = set_vacancy(args: args)
     return false if not success
 
+    # Remove columns
+    @schedules.delete('sleep')
+    @schedules.delete('sinks')
+    @schedules.delete('showers')
+    @schedules.delete('baths')
+
     return true
   end
 
-  def create_average_schedules(args:)
+  def create_average_schedules
     create_average_occupants
     create_average_cooking_range
     create_average_plug_loads_other
@@ -129,10 +92,10 @@ class ScheduleGenerator
     create_average_lighting_exterior
     create_average_lighting_garage
     create_average_lighting_exterior_holiday
-    create_average_clothes_washer(args: args)
-    create_average_clothes_dryer(args: args)
-    create_average_dishwasher(args: args)
-    create_average_fixtures(args: args)
+    create_average_clothes_washer
+    create_average_clothes_dryer
+    create_average_dishwasher
+    create_average_fixtures
     create_average_ceiling_fan
     create_average_refrigerator
     create_average_extra_refrigerator
@@ -151,7 +114,7 @@ class ScheduleGenerator
   end
 
   def create_average_lighting_interior
-    lighting_sch = Lighting.get_schedule(@model, @epw_file)
+    lighting_sch = Lighting.get_schedule(@epw_file)
     create_timeseries_from_months(sch_name: 'lighting_interior', month_schs: lighting_sch)
   end
 
@@ -164,7 +127,7 @@ class ScheduleGenerator
   end
 
   def create_average_lighting_exterior_holiday
-    create_timeseries_from_weekday_weekend_monthly(sch_name: 'lighting_exterior_holiday', weekday_sch: Schedule.LightingExteriorHolidayWeekdayFractions, weekend_sch: Schedule.LightingExteriorHolidayWeekendFractions, monthly_sch: Schedule.LightingExteriorHolidayMonthlyMultipliers, begin_month: 11, begin_day_of_month: 24, end_month: 1, end_day_of_month: 6)
+    create_timeseries_from_weekday_weekend_monthly(sch_name: 'lighting_exterior_holiday', weekday_sch: Schedule.LightingExteriorHolidayWeekdayFractions, weekend_sch: Schedule.LightingExteriorHolidayWeekendFractions, monthly_sch: Schedule.LightingExteriorHolidayMonthlyMultipliers, begin_month: 11, begin_day: 24, end_month: 1, end_day: 6)
   end
 
   def create_average_cooking_range
@@ -183,23 +146,22 @@ class ScheduleGenerator
     create_timeseries_from_weekday_weekend_monthly(sch_name: 'freezer', weekday_sch: Schedule.FreezerWeekdayFractions, weekend_sch: Schedule.FreezerWeekendFractions, monthly_sch: Schedule.FreezerMonthlyMultipliers)
   end
 
-  def create_average_dishwasher(args:)
-    create_timeseries_from_minutely(sch_name: 'dishwasher', obj_name: Constants.ObjectNameDishwasher, days_shift: 0, dryer_exhaust_min_runtime: 0, args: args)
-    create_timeseries_from_minutely(sch_name: 'dishwasher_power', obj_name: Constants.ObjectNameDishwasher, days_shift: 0, dryer_exhaust_min_runtime: 0, args: args)
+  def create_average_dishwasher
+    create_timeseries_from_weekday_weekend_monthly(sch_name: 'hot_water_dishwasher', weekday_sch: Schedule.DishwasherWeekdayFractions, weekend_sch: Schedule.DishwasherWeekendFractions, monthly_sch: Schedule.DishwasherMonthlyMultipliers)
+    create_timeseries_from_weekday_weekend_monthly(sch_name: 'dishwasher', weekday_sch: Schedule.DishwasherWeekdayFractions, weekend_sch: Schedule.DishwasherWeekendFractions, monthly_sch: Schedule.DishwasherMonthlyMultipliers)
   end
 
-  def create_average_clothes_washer(args:)
-    create_timeseries_from_minutely(sch_name: 'clothes_washer', obj_name: Constants.ObjectNameClothesWasher, days_shift: 0, dryer_exhaust_min_runtime: 0, args: args)
-    create_timeseries_from_minutely(sch_name: 'clothes_washer_power', obj_name: Constants.ObjectNameClothesWasher, days_shift: 0, dryer_exhaust_min_runtime: 0, args: args)
+  def create_average_clothes_washer
+    create_timeseries_from_weekday_weekend_monthly(sch_name: 'hot_water_clothes_washer', weekday_sch: Schedule.ClothesWasherWeekdayFractions, weekend_sch: Schedule.ClothesWasherWeekendFractions, monthly_sch: Schedule.ClothesWasherMonthlyMultipliers)
+    create_timeseries_from_weekday_weekend_monthly(sch_name: 'clothes_washer', weekday_sch: Schedule.ClothesWasherWeekdayFractions, weekend_sch: Schedule.ClothesWasherWeekendFractions, monthly_sch: Schedule.ClothesWasherMonthlyMultipliers)
   end
 
-  def create_average_clothes_dryer(args:)
-    create_timeseries_from_minutely(sch_name: 'clothes_dryer', obj_name: Constants.ObjectNameClothesDryer, days_shift: -1.0 / 24.0, dryer_exhaust_min_runtime: 0, args: args)
-    create_timeseries_from_minutely(sch_name: 'clothes_dryer_exhaust', obj_name: Constants.ObjectNameClothesDryerExhaust, days_shift: -1.0 / 24.0, dryer_exhaust_min_runtime: 24, args: args)
+  def create_average_clothes_dryer
+    create_timeseries_from_weekday_weekend_monthly(sch_name: 'clothes_dryer', weekday_sch: Schedule.ClothesDryerWeekdayFractions, weekend_sch: Schedule.ClothesDryerWeekendFractions, monthly_sch: Schedule.ClothesDryerMonthlyMultipliers)
   end
 
-  def create_average_fixtures(args:)
-    create_timeseries_from_minutely(sch_name: 'fixtures', obj_name: Constants.ObjectNameFixtures, days_shift: 0, dryer_exhaust_min_runtime: 0, args: args)
+  def create_average_fixtures
+    create_timeseries_from_weekday_weekend_monthly(sch_name: 'hot_water_fixtures', weekday_sch: Schedule.FixturesWeekdayFractions, weekend_sch: Schedule.FixturesWeekendFractions, monthly_sch: Schedule.FixturesMonthlyMultipliers)
   end
 
   def create_average_ceiling_fan
@@ -255,20 +217,20 @@ class ScheduleGenerator
                                                      weekend_sch:,
                                                      monthly_sch:,
                                                      begin_month: nil,
-                                                     begin_day_of_month: nil,
+                                                     begin_day: nil,
                                                      end_month: nil,
-                                                     end_day_of_month: nil)
+                                                     end_day: nil)
 
     daily_sch = { 'weekday_sch' => weekday_sch.split(',').map { |i| i.to_f },
                   'weekend_sch' => weekend_sch.split(',').map { |i| i.to_f },
                   'monthly_multiplier' => monthly_sch.split(',').map { |i| i.to_f } }
 
-    if begin_month.nil? && begin_day_of_month.nil? && end_month.nil? && end_day_of_month.nil?
+    if begin_month.nil? && begin_day.nil? && end_month.nil? && end_day.nil?
       begin_day = @sim_start_day
       end_day = DateTime.new(@sim_year, 12, 31)
     else
-      begin_day = DateTime.new(@sim_year, begin_month, begin_day_of_month)
-      end_day = DateTime.new(@sim_year, end_month, end_day_of_month)
+      begin_day = DateTime.new(@sim_year, begin_month, begin_day)
+      end_day = DateTime.new(@sim_year, end_month, end_day)
     end
 
     @total_days_in_year.times do |day|
@@ -292,7 +254,7 @@ class ScheduleGenerator
   def create_timeseries_from_months(sch_name:,
                                     month_schs:)
 
-    num_days_in_months = Constants.NumDaysInMonths(@model.getYearDescription)
+    num_days_in_months = Constants.NumDaysInMonths(@sim_year)
     sch = []
     for month in 0..11
       sch << month_schs[month] * num_days_in_months[month]
@@ -310,47 +272,6 @@ class ScheduleGenerator
     @schedules[sch_name] = normalize(@schedules[sch_name])
   end
 
-  def create_timeseries_from_minutely(sch_name:,
-                                      obj_name:,
-                                      days_shift:,
-                                      dryer_exhaust_min_runtime:,
-                                      args:)
-
-    nbeds = args[:geometry_num_bedrooms]
-    create_sch_object = false
-    sch = HotWaterSchedule.new(@model, obj_name, nbeds, days_shift, dryer_exhaust_min_runtime, create_sch_object)
-
-    weeks = 1 # use a single week that repeats
-
-    year_description = @model.getYearDescription
-    last_day_of_year = 365
-    last_day_of_year += 1 if year_description.isLeapYear
-
-    time = []
-    (@minutes_per_step..24 * 60).step(@minutes_per_step).to_a.each_with_index do |m, i|
-      time[i] = OpenStudio::Time.new(0, 0, m, 0)
-    end
-
-    data = sch.data
-
-    unique_day_schedule = []
-    for d in 1..7 * weeks # how many unique day schedules
-      next if d > last_day_of_year
-
-      time.each_with_index do |m, i|
-        previous_value = data[i + (d - 1) * 24 * 60 / @minutes_per_step]
-        unique_day_schedule << previous_value
-      end
-    end
-
-    repeated_schedule = []
-    for w in 0..52 # max num of weeks
-      repeated_schedule += unique_day_schedule
-    end
-
-    @schedules[sch_name] = repeated_schedule[0...@total_days_in_year * @steps_in_day]
-  end
-
   def create_stochastic_schedules(args:)
     # initialize a random number generator
     prng = Random.new(get_random_seed)
@@ -434,11 +355,9 @@ class ScheduleGenerator
     monthly_lighting_schedule = schedule_config['lighting']['monthly_multiplier']
     holiday_lighting_schedule = schedule_config['lighting']['holiday_sch']
 
-    sch_option_type = Constants.OptionTypeLightingScheduleCalculated
-    sch = Lighting.get_schedule(@model, @epw_file)
+    sch = Lighting.get_schedule(@epw_file)
     interior_lighting_schedule = []
-    year_description = @model.getYearDescription
-    num_days_in_months = Constants.NumDaysInMonths(year_description.isLeapYear)
+    num_days_in_months = Constants.NumDaysInMonths(@sim_year)
     for month in 0..11
       interior_lighting_schedule << sch[month] * num_days_in_months[month]
     end
@@ -446,7 +365,7 @@ class ScheduleGenerator
     m = interior_lighting_schedule.max
     interior_lighting_schedule = interior_lighting_schedule.map { |s| s / m }
 
-    holiday_lighting_schedule = get_holiday_lighting_sch(@model, @runner, holiday_lighting_schedule)
+    holiday_lighting_schedule = get_holiday_lighting_sch(holiday_lighting_schedule)
 
     away_schedule = []
     idle_schedule = []
@@ -634,9 +553,9 @@ class ScheduleGenerator
     #    (it's typically composed of multiple water draw events)
     # 4. For each event, sample the event duration
     # 5. Fill in the dishwasher/clothes washer time slot using those water draw events
-    dw_flow_rate_mean = schedule_config['dishwasher']['flow_rate_mean']
-    dw_flow_rate_std = schedule_config['dishwasher']['flow_rate_std']
-    dw_minutes_between_event_gap = schedule_config['dishwasher']['minutes_between_event_gap']
+    dw_flow_rate_mean = schedule_config['hot_water_dishwasher']['flow_rate_mean']
+    dw_flow_rate_std = schedule_config['hot_water_dishwasher']['flow_rate_std']
+    dw_minutes_between_event_gap = schedule_config['hot_water_dishwasher']['minutes_between_event_gap']
     dw_activity_sch = [0] * mins_in_year
     m = 0
     dw_flow_rate = gaussian_rand(prng, dw_flow_rate_mean, dw_flow_rate_std, 0)
@@ -648,11 +567,11 @@ class ScheduleGenerator
       dish_state = sum_across_occupants(all_simulated_values, 4, step, max_clip = 1)
       step_jump = 1
       if dish_state > 0
-        cluster_size = sample_activity_cluster_size(prng, cluster_size_prob_map, 'dishwasher')
+        cluster_size = sample_activity_cluster_size(prng, cluster_size_prob_map, 'hot_water_dishwasher')
         start_minute = step * 15
         m = 0
         cluster_size.times do
-          duration = sample_event_duration(prng, event_duration_prob_map, 'dishwasher')
+          duration = sample_event_duration(prng, event_duration_prob_map, 'hot_water_dishwasher')
           int_duration = duration.ceil
           flow_rate = dw_flow_rate * duration / int_duration
           int_duration.times do
@@ -673,11 +592,11 @@ class ScheduleGenerator
       step += step_jump
     end
 
-    cw_flow_rate_mean = schedule_config['clothes_washer']['flow_rate_mean']
-    cw_flow_rate_std = schedule_config['clothes_washer']['flow_rate_std']
-    cw_minutes_between_event_gap = schedule_config['clothes_washer']['minutes_between_event_gap']
+    cw_flow_rate_mean = schedule_config['hot_water_clothes_washer']['flow_rate_mean']
+    cw_flow_rate_std = schedule_config['hot_water_clothes_washer']['flow_rate_std']
+    cw_minutes_between_event_gap = schedule_config['hot_water_clothes_washer']['minutes_between_event_gap']
     cw_activity_sch = [0] * mins_in_year # this is the clothes_washer water draw schedule
-    cw_load_size_probability = schedule_config['clothes_washer']['load_size_probability']
+    cw_load_size_probability = schedule_config['hot_water_clothes_washer']['load_size_probability']
     m = 0
     cw_flow_rate = gaussian_rand(prng, cw_flow_rate_mean, cw_flow_rate_std, 0)
     # States are: 'sleeping','shower','laundry','cooking', 'dishwashing', 'absent', 'nothingAtHome'
@@ -691,9 +610,9 @@ class ScheduleGenerator
         start_minute = step * 15
         m = 0
         num_loads.times do
-          cluster_size = sample_activity_cluster_size(prng, cluster_size_prob_map, 'clothes_washer')
+          cluster_size = sample_activity_cluster_size(prng, cluster_size_prob_map, 'hot_water_clothes_washer')
           cluster_size.times do
-            duration = sample_event_duration(prng, event_duration_prob_map, 'clothes_washer')
+            duration = sample_event_duration(prng, event_duration_prob_map, 'hot_water_clothes_washer')
             int_duration = duration.ceil
             flow_rate = cw_flow_rate * duration.to_f / int_duration
             int_duration.times do
@@ -733,7 +652,7 @@ class ScheduleGenerator
         duration_15min, avg_power = sample_appliance_duration_power(prng, appliance_power_dist_map, 'dishwasher')
 
         month = (start_time + step * 15 * 60).month
-        duration_min = (duration_15min * 15 * schedule_config['dishwasher']['monthly_multiplier'][month - 1]).to_i
+        duration_min = (duration_15min * 15 * schedule_config['hot_water_dishwasher']['monthly_multiplier'][month - 1]).to_i
 
         duration = [duration_min, mins_in_year - step * 15].min
         dw_power_sch.fill(avg_power, step * 15, duration)
@@ -759,7 +678,7 @@ class ScheduleGenerator
 
         month = (start_time + step * 15 * 60).month
         cd_duration_min = (cd_duration_15min * 15 * schedule_config['clothes_dryer']['monthly_multiplier'][month - 1]).to_i
-        cw_duration_min = (cw_duration_15min * 15 * schedule_config['clothes_washer']['monthly_multiplier'][month - 1]).to_i
+        cw_duration_min = (cw_duration_15min * 15 * schedule_config['hot_water_clothes_washer']['monthly_multiplier'][month - 1]).to_i
 
         cw_duration = [cw_duration_min, mins_in_year - step * 15].min
         cw_power_sch.fill(cw_avg_power, step * 15, cw_duration)
@@ -798,85 +717,87 @@ class ScheduleGenerator
     sink_activity_sch = sink_activity_sch.rotate(-4 * 60 + random_offset) # 4 am shifting
     sink_activity_sch = apply_monthly_offsets(array: sink_activity_sch, weekday_monthly_shift_dict: weekday_monthly_shift_dict, weekend_monthly_shift_dict: weekend_monthly_shift_dict)
     sink_activity_sch = aggregate_array(sink_activity_sch, @minutes_per_step)
-    @schedules['sinks'] = sink_activity_sch.map { |flow| flow / Constants.PeakFlowRate }
+    sink_peak_flow = sink_activity_sch.max
+    @schedules['sinks'] = sink_activity_sch.map { |flow| flow / sink_peak_flow }
 
     random_offset = (prng.rand * 2 * offset_range).to_i - offset_range
     dw_activity_sch = dw_activity_sch.rotate(random_offset)
     dw_activity_sch = apply_monthly_offsets(array: dw_activity_sch, weekday_monthly_shift_dict: weekday_monthly_shift_dict, weekend_monthly_shift_dict: weekend_monthly_shift_dict)
     dw_activity_sch = aggregate_array(dw_activity_sch, @minutes_per_step)
-    @schedules['dishwasher'] = dw_activity_sch.map { |flow| flow / Constants.PeakFlowRate }
+    dw_peak_flow = dw_activity_sch.max
+    @schedules['hot_water_dishwasher'] = dw_activity_sch.map { |flow| flow / dw_peak_flow }
 
     random_offset = (prng.rand * 2 * offset_range).to_i - offset_range
     cw_activity_sch = cw_activity_sch.rotate(random_offset)
     cw_activity_sch = apply_monthly_offsets(array: cw_activity_sch, weekday_monthly_shift_dict: weekday_monthly_shift_dict, weekend_monthly_shift_dict: weekend_monthly_shift_dict)
     cw_activity_sch = aggregate_array(cw_activity_sch, @minutes_per_step)
-    @schedules['clothes_washer'] = cw_activity_sch.map { |flow| flow / Constants.PeakFlowRate }
+    cw_peak_flow = cw_activity_sch.max
+    @schedules['hot_water_clothes_washer'] = cw_activity_sch.map { |flow| flow / cw_peak_flow }
 
     random_offset = (prng.rand * 2 * offset_range).to_i - offset_range
     shower_activity_sch = shower_activity_sch.rotate(random_offset)
     shower_activity_sch = apply_monthly_offsets(array: shower_activity_sch, weekday_monthly_shift_dict: weekday_monthly_shift_dict, weekend_monthly_shift_dict: weekend_monthly_shift_dict)
     shower_activity_sch = aggregate_array(shower_activity_sch, @minutes_per_step)
-    @schedules['showers'] = shower_activity_sch.map { |flow| flow / Constants.PeakFlowRate }
+    shower_peak_flow = shower_activity_sch.max
+    @schedules['showers'] = shower_activity_sch.map { |flow| flow / shower_peak_flow }
 
     random_offset = (prng.rand * 2 * offset_range).to_i - offset_range
     bath_activity_sch = bath_activity_sch.rotate(random_offset)
     bath_activity_sch = apply_monthly_offsets(array: bath_activity_sch, weekday_monthly_shift_dict: weekday_monthly_shift_dict, weekend_monthly_shift_dict: weekend_monthly_shift_dict)
     bath_activity_sch = aggregate_array(bath_activity_sch, @minutes_per_step)
-    @schedules['baths'] = bath_activity_sch.map { |flow| flow / Constants.PeakFlowRate }
+    bath_peak_flow = bath_activity_sch.max
+    @schedules['baths'] = bath_activity_sch.map { |flow| flow / bath_peak_flow }
 
     random_offset = (prng.rand * 2 * offset_range).to_i - offset_range
     cooking_power_sch = cooking_power_sch.rotate(random_offset)
     cooking_power_sch = apply_monthly_offsets(array: cooking_power_sch, weekday_monthly_shift_dict: weekday_monthly_shift_dict, weekend_monthly_shift_dict: weekend_monthly_shift_dict)
     cooking_power_sch = aggregate_array(cooking_power_sch, @minutes_per_step)
-    @schedules['cooking_range'] = cooking_power_sch.map { |power| power / Constants.PeakPower }
+    cooking_peak_power = cooking_power_sch.max
+    @schedules['cooking_range'] = cooking_power_sch.map { |power| power / cooking_peak_power }
 
     random_offset = (prng.rand * 2 * offset_range).to_i - offset_range
     cw_power_sch = cw_power_sch.rotate(random_offset)
     cw_power_sch = apply_monthly_offsets(array: cw_power_sch, weekday_monthly_shift_dict: weekday_monthly_shift_dict, weekend_monthly_shift_dict: weekend_monthly_shift_dict)
     cw_power_sch = aggregate_array(cw_power_sch, @minutes_per_step)
-    @schedules['clothes_washer_power'] = cw_power_sch.map { |power| power / Constants.PeakPower }
+    cw_peak_power = cw_power_sch.max
+    @schedules['clothes_washer'] = cw_power_sch.map { |power| power / cw_peak_power }
 
     random_offset = (prng.rand * 2 * offset_range).to_i - offset_range
     cd_power_sch = cd_power_sch.rotate(random_offset)
     cd_power_sch = apply_monthly_offsets(array: cd_power_sch, weekday_monthly_shift_dict: weekday_monthly_shift_dict, weekend_monthly_shift_dict: weekend_monthly_shift_dict)
     cd_power_sch = aggregate_array(cd_power_sch, @minutes_per_step)
-    @schedules['clothes_dryer'] = cd_power_sch.map { |power| power / Constants.PeakPower }
-    @schedules['clothes_dryer_exhaust'] = @schedules['clothes_dryer']
+    cd_peak_power = cd_power_sch.max
+    @schedules['clothes_dryer'] = cd_power_sch.map { |power| power / cd_peak_power }
 
     random_offset = (prng.rand * 2 * offset_range).to_i - offset_range
     dw_power_sch = dw_power_sch.rotate(random_offset)
     dw_power_sch = apply_monthly_offsets(array: dw_power_sch, weekday_monthly_shift_dict: weekday_monthly_shift_dict, weekend_monthly_shift_dict: weekend_monthly_shift_dict)
     dw_power_sch = aggregate_array(dw_power_sch, @minutes_per_step)
-    @schedules['dishwasher_power'] = dw_power_sch.map { |power| power / Constants.PeakPower }
+    dw_peak_power = dw_power_sch.max
+    @schedules['dishwasher'] = dw_power_sch.map { |power| power / dw_peak_power }
 
     @schedules['occupants'] = away_schedule.map { |i| 1.0 - i }
 
-    @schedules['fixtures'] = [@schedules['showers'], @schedules['sinks'], @schedules['baths']].transpose.map { |flow| flow.reduce(:+) }
+    @schedules['hot_water_fixtures'] = [@schedules['showers'], @schedules['sinks'], @schedules['baths']].transpose.map { |flow| flow.reduce(:+) }
+    fixtures_peak_flow = @schedules['hot_water_fixtures'].max
+    @schedules['hot_water_fixtures'] = @schedules['hot_water_fixtures'].map { |flow| flow / fixtures_peak_flow }
 
     return true
   end
 
   def set_vacancy(args:)
-    if args[:schedules_vacancy_begin_month].is_initialized && args[:schedules_vacancy_begin_day_of_month].is_initialized && args[:schedules_vacancy_end_month].is_initialized && args[:schedules_vacancy_end_day_of_month].is_initialized
-      begin
-        vacancy_start_date = Time.new(@sim_year, args[:schedules_vacancy_begin_month].get, args[:schedules_vacancy_begin_day_of_month].get)
-        vacancy_end_date = Time.new(@sim_year, args[:schedules_vacancy_end_month].get, args[:schedules_vacancy_end_day_of_month].get, 24)
-
-        sec_per_step = @minutes_per_step * 60.0
-        ts = Time.new(@sim_year, 'Jan', 1)
-        @schedules['vacancy'].each_with_index do |step, i|
-          if vacancy_start_date <= ts && ts <= vacancy_end_date # in the vacancy period
-            @schedules['vacancy'][i] = 1.0
-          end
-          ts += sec_per_step
-        end
-
-        @runner.registerInfo("Set vacancy period from #{vacancy_start_date} to #{vacancy_end_date}.")
-      rescue
-        @runner.registerError('Invalid vacancy date(s) specified.')
+    if (not args[:schedules_vacancy_begin_month].nil?) && (not args[:schedules_vacancy_begin_day].nil?) && (not args[:schedules_vacancy_end_month].nil?) && (not args[:schedules_vacancy_end_day].nil?)
+      start_day_num = Schedule.get_day_num_from_month_day(@sim_year, args[:schedules_vacancy_begin_month], args[:schedules_vacancy_begin_day])
+      end_day_num = Schedule.get_day_num_from_month_day(@sim_year, args[:schedules_vacancy_end_month], args[:schedules_vacancy_end_day])
+
+      vacancy = Array.new(@schedules['occupants'].length, 0)
+      if end_day_num >= start_day_num
+        vacancy.fill(1.0, (start_day_num - 1) * args[:steps_in_day], (end_day_num - start_day_num + 1) * args[:steps_in_day]) # Fill between start/end days
+      else # Wrap around year
+        vacancy.fill(1.0, (start_day_num - 1) * args[:steps_in_day]) # Fill between start day and end of year
+        vacancy.fill(1.0, 0, end_day_num * args[:steps_in_day]) # Fill between start of year and end day
       end
-    else
-      @runner.registerInfo('No vacancy period set.')
+      @schedules['vacancy'] = vacancy
     end
     return true
   end
@@ -928,8 +849,8 @@ class ScheduleGenerator
     activity_names = ['clothes_washer', 'dishwasher', 'clothes_dryer', 'cooking']
     power_dist_map = {}
     activity_names.each do |activity|
-      duration_file = resources_path + "/schedules_#{activity}_power_duration_dist.csv"
-      consumption_file = resources_path + "/schedules_#{activity}_power_consumption_dist.csv"
+      duration_file = resources_path + "/schedules_#{activity}_duration_dist.csv"
+      consumption_file = resources_path + "/schedules_#{activity}_consumption_dist.csv"
       duration_vals = CSV.read(duration_file)
       consumption_vals = CSV.read(consumption_file)
       duration_vals = duration_vals.map { |a| a.map { |i| i.to_i } }
@@ -959,7 +880,7 @@ class ScheduleGenerator
   end
 
   def read_activity_cluster_size_probs(resources_path:)
-    activity_names = ['clothes_washer', 'dishwasher', 'shower']
+    activity_names = ['hot_water_clothes_washer', 'hot_water_dishwasher', 'shower']
     cluster_size_prob_map = {}
     activity_names.each do |activity|
       cluster_size_file = resources_path + "/schedules_#{activity}_cluster_size_probability.csv"
@@ -971,7 +892,7 @@ class ScheduleGenerator
   end
 
   def read_event_duration_probs(resources_path:)
-    activity_names = ['clothes_washer', 'dishwasher', 'shower']
+    activity_names = ['hot_water_clothes_washer', 'hot_water_dishwasher', 'shower']
     event_duration_probabilites_map = {}
     activity_names.each do |activity|
       duration_file = resources_path + "/schedules_#{activity}_event_duration_probability.csv"
@@ -1106,7 +1027,7 @@ class ScheduleGenerator
     return weights.size - 1 # If the prob weight don't sum to n, return last index
   end
 
-  def get_holiday_lighting_sch(model, runner, holiday_sch)
+  def get_holiday_lighting_sch(holiday_sch)
     holiday_start_day = 332 # November 27
     holiday_end_day = 6 # Jan 6
     sch = [0] * 24 * @total_days_in_year

data/example_files/resources/hpxml-measures/{BuildResidentialHPXML → BuildResidentialScheduleFile}/resources/schedules_config.json

@@ -341,7 +341,7 @@
     "flow_rate_mean": 4.4,
     "flow_rate_std": 1.17
   },
-  "dishwasher": {
+  "hot_water_dishwasher": {
     "flow_rate_mean": 1.39,
     "flow_rate_std": 0.2,
     "minutes_between_event_gap": 10,
@@ -360,7 +360,7 @@
       1.094
     ]
   },
-  "clothes_washer": {
+  "hot_water_clothes_washer": {
     "flow_rate_mean": 2.2,
     "flow_rate_std": 0.62,
     "minutes_between_event_gap": 4,