urbanopt-cli 0.6.1 → 0.7.0

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

@@ -7,6 +7,7 @@ class HourlyByMonthSchedule
   def initialize(model, sch_name, weekday_month_by_hour_values, weekend_month_by_hour_values,
                  schedule_type_limits_name = nil, normalize_values = true)
     @model = model
+    @year = model.getYearDescription.assumedYear
     @sch_name = sch_name
     @schedule = nil
     @weekday_month_by_hour_values = validateValues(weekday_month_by_hour_values, 12, 24)
@@ -69,13 +70,8 @@ class HourlyByMonthSchedule
   end
 
   def createSchedule()
-    year_description = @model.getYearDescription
-    leap_offset = 0
-    if year_description.isLeapYear
-      leap_offset = 1
-    end
-    day_endm = [0, 31, 59 + leap_offset, 90 + leap_offset, 120 + leap_offset, 151 + leap_offset, 181 + leap_offset, 212 + leap_offset, 243 + leap_offset, 273 + leap_offset, 304 + leap_offset, 334 + leap_offset, 365 + leap_offset]
-    day_startm = [0, 1, 32, 60 + leap_offset, 91 + leap_offset, 121 + leap_offset, 152 + leap_offset, 182 + leap_offset, 213 + leap_offset, 244 + leap_offset, 274 + leap_offset, 305 + leap_offset, 335 + leap_offset]
+    day_startm = Schedule.day_start_months(@year)
+    day_endm = Schedule.day_end_months(@year)
 
     time = []
     for h in 1..24
@@ -85,15 +81,13 @@ class HourlyByMonthSchedule
     schedule = OpenStudio::Model::ScheduleRuleset.new(@model)
     schedule.setName(@sch_name)
 
-    assumedYear = year_description.assumedYear # prevent excessive OS warnings about 'UseWeatherFile'
-
     prev_wkdy_vals = nil
     prev_wkdy_rule = nil
     prev_wknd_vals = nil
     prev_wknd_rule = nil
     for m in 1..12
-      date_s = OpenStudio::Date::fromDayOfYear(day_startm[m], assumedYear)
-      date_e = OpenStudio::Date::fromDayOfYear(day_endm[m], assumedYear)
+      date_s = OpenStudio::Date::fromDayOfYear(day_startm[m - 1], @year)
+      date_e = OpenStudio::Date::fromDayOfYear(day_endm[m - 1], @year)
 
       wkdy_vals = []
       wknd_vals = []
@@ -171,6 +165,169 @@ class HourlyByMonthSchedule
   end
 end
 
+# Annual schedule defined by 365 24-hour values for weekdays and weekends.
+class HourlyByDaySchedule
+  # weekday_day_by_hour_values must be a 365-element array of 24-element arrays of numbers.
+  # weekend_day_by_hour_values must be a 365-element array of 24-element arrays of numbers.
+  def initialize(model, sch_name, weekday_day_by_hour_values, weekend_day_by_hour_values,
+                 schedule_type_limits_name = nil, normalize_values = true)
+    @model = model
+    @year = model.getYearDescription.assumedYear
+    @sch_name = sch_name
+    @schedule = nil
+    @num_days = Constants.NumDaysInYear(@year)
+    @weekday_day_by_hour_values = validateValues(weekday_day_by_hour_values, @num_days, 24)
+    @weekend_day_by_hour_values = validateValues(weekend_day_by_hour_values, @num_days, 24)
+    @schedule_type_limits_name = schedule_type_limits_name
+
+    if normalize_values
+      @maxval = calcMaxval()
+    else
+      @maxval = 1.0
+    end
+    @schedule = createSchedule()
+  end
+
+  def calcDesignLevel(val)
+    return val * 1000
+  end
+
+  def schedule
+    return @schedule
+  end
+
+  def maxval
+    return @maxval
+  end
+
+  private
+
+  def validateValues(vals, num_outter_values, num_inner_values)
+    err_msg = "A #{num_outter_values}-element array with #{num_inner_values}-element arrays of numbers must be entered for the schedule."
+    if not vals.is_a?(Array)
+      fail err_msg
+    end
+
+    begin
+      if vals.length != num_outter_values
+        fail err_msg
+      end
+
+      vals.each do |val|
+        if not val.is_a?(Array)
+          fail err_msg
+        end
+        if val.length != num_inner_values
+          fail err_msg
+        end
+      end
+    rescue
+      fail err_msg
+    end
+    return vals
+  end
+
+  def calcMaxval()
+    maxval = [@weekday_month_by_hour_values.flatten.max, @weekend_month_by_hour_values.flatten.max].max
+    if maxval == 0.0
+      maxval = 1.0 # Prevent divide by zero
+    end
+    return maxval
+  end
+
+  def createSchedule()
+    time = []
+    for h in 1..24
+      time[h] = OpenStudio::Time.new(0, h, 0, 0)
+    end
+
+    schedule = OpenStudio::Model::ScheduleRuleset.new(@model)
+    schedule.setName(@sch_name)
+
+    prev_wkdy_vals = nil
+    prev_wkdy_rule = nil
+    prev_wknd_vals = nil
+    prev_wknd_rule = nil
+    for d in 1..@num_days
+      date_s = OpenStudio::Date::fromDayOfYear(d, @year)
+      date_e = OpenStudio::Date::fromDayOfYear(d, @year)
+
+      wkdy_vals = []
+      wknd_vals = []
+      for h in 1..24
+        wkdy_vals[h] = (@weekday_day_by_hour_values[d - 1][h - 1]) / @maxval
+        wknd_vals[h] = (@weekend_day_by_hour_values[d - 1][h - 1]) / @maxval
+      end
+
+      if (wkdy_vals == prev_wkdy_vals) && (wknd_vals == prev_wknd_vals)
+        # Extend end date of current rule(s)
+        prev_wkdy_rule.setEndDate(date_e) unless prev_wkdy_rule.nil?
+        prev_wknd_rule.setEndDate(date_e) unless prev_wknd_rule.nil?
+      elsif wkdy_vals == wknd_vals
+        # Alldays
+        wkdy_rule = OpenStudio::Model::ScheduleRule.new(schedule)
+        wkdy_rule.setName(@sch_name + " #{Schedule.allday_name} ruleset#{d}")
+        wkdy = wkdy_rule.daySchedule
+        wkdy.setName(@sch_name + " #{Schedule.allday_name}#{d}")
+        previous_value = wkdy_vals[1]
+        for h in 1..24
+          next if (h != 24) && (wkdy_vals[h + 1] == previous_value)
+
+          wkdy.addValue(time[h], previous_value)
+          previous_value = wkdy_vals[h + 1]
+        end
+        Schedule.set_weekday_rule(wkdy_rule)
+        Schedule.set_weekend_rule(wkdy_rule)
+        wkdy_rule.setStartDate(date_s)
+        wkdy_rule.setEndDate(date_e)
+        prev_wkdy_rule = wkdy_rule
+        prev_wknd_rule = nil
+      else
+        # Weekdays
+        wkdy_rule = OpenStudio::Model::ScheduleRule.new(schedule)
+        wkdy_rule.setName(@sch_name + " #{Schedule.weekday_name} ruleset#{d}")
+        wkdy = wkdy_rule.daySchedule
+        wkdy.setName(@sch_name + " #{Schedule.weekday_name}#{d}")
+        previous_value = wkdy_vals[1]
+        for h in 1..24
+          next if (h != 24) && (wkdy_vals[h + 1] == previous_value)
+
+          wkdy.addValue(time[h], previous_value)
+          previous_value = wkdy_vals[h + 1]
+        end
+        Schedule.set_weekday_rule(wkdy_rule)
+        wkdy_rule.setStartDate(date_s)
+        wkdy_rule.setEndDate(date_e)
+        prev_wkdy_rule = wkdy_rule
+
+        # Weekends
+        wknd_rule = OpenStudio::Model::ScheduleRule.new(schedule)
+        wknd_rule.setName(@sch_name + " #{Schedule.weekend_name} ruleset#{d}")
+        wknd = wknd_rule.daySchedule
+        wknd.setName(@sch_name + " #{Schedule.weekend_name}#{d}")
+        previous_value = wknd_vals[1]
+        for h in 1..24
+          next if (h != 24) && (wknd_vals[h + 1] == previous_value)
+
+          wknd.addValue(time[h], previous_value)
+          previous_value = wknd_vals[h + 1]
+        end
+        Schedule.set_weekend_rule(wknd_rule)
+        wknd_rule.setStartDate(date_s)
+        wknd_rule.setEndDate(date_e)
+        prev_wknd_rule = wknd_rule
+      end
+
+      prev_wkdy_vals = wkdy_vals
+      prev_wknd_vals = wknd_vals
+    end
+
+    Schedule.set_schedule_type_limits(@model, schedule, @schedule_type_limits_name)
+
+    return schedule
+  end
+end
+
 # Annual schedule defined by 24 weekday hourly values, 24 weekend hourly values, and 12 monthly values
 class MonthWeekdayWeekendSchedule
   # weekday_hourly_values can either be a comma-separated string of 24 numbers or a 24-element array of numbers.
@@ -180,6 +337,7 @@ class MonthWeekdayWeekendSchedule
                  schedule_type_limits_name = nil, normalize_values = true, begin_month = 1,
                  begin_day = 1, end_month = 12, end_day = 31)
     @model = model
+    @year = model.getYearDescription.assumedYear
     @sch_name = sch_name
     @schedule = nil
     @weekday_hourly_values = validateValues(weekday_hourly_values, 24, 'weekday')
@@ -205,13 +363,19 @@ class MonthWeekdayWeekendSchedule
   end
 
   def calcDesignLevelFromDailykWh(daily_kwh)
-    return daily_kwh * @maxval * 1000 * @schadjust
+    design_level_kw = daily_kwh * @maxval * @schadjust
+    return UnitConversions.convert(design_level_kw, 'kW', 'W')
   end
 
   def calcDesignLevelFromDailyTherm(daily_therm)
     return calcDesignLevelFromDailykWh(UnitConversions.convert(daily_therm, 'therm', 'kWh'))
   end
 
+  def calcPeakFlowFromDailygpm(daily_water)
+    water_gpm = daily_water * @maxval * @schadjust / 60.0
+    return UnitConversions.convert(water_gpm, 'gal/min', 'm^3/s')
+  end
+
   def schedule
     return @schedule
   end
@@ -304,24 +468,13 @@ class MonthWeekdayWeekendSchedule
   end
 
   def createSchedule()
-    year_description = @model.getYearDescription
-    leap_offset = 0
-    if year_description.isLeapYear
-      leap_offset = 1
-    end
+    month_num_days = Constants.NumDaysInMonths(@year)
+    month_num_days[@end_month - 1] = @end_day
+
+    day_startm = Schedule.day_start_months(@year)
+    day_startm[@begin_month - 1] += @begin_day - 1
+    day_endm = [Schedule.day_start_months(@year), month_num_days].transpose.map { |i| i.reduce(:+) - 1 }
 
-    num_days_in_each_month = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
-    num_days_in_each_month[@end_month] = @end_day
-    num_days_in_each_month.each_index do |i|
-      num_days_in_each_month[i] += leap_offset if i == 2
-    end
-    orig_day_startm = [0, 1, 32, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335]
-    orig_day_startm.each_index do |i|
-      orig_day_startm[i] += leap_offset if i > 2
-    end
-    day_startm = orig_day_startm.map(&:clone)
-    day_startm[@begin_month] = orig_day_startm[@begin_month] + @begin_day - 1
-    day_endm = [orig_day_startm, num_days_in_each_month].transpose.map { |i| (i != [0, 0]) ? i.reduce(:+) - 1 : 0 }
     time = []
     for h in 1..24
       time[h] = OpenStudio::Time.new(0, h, 0, 0)
@@ -330,8 +483,6 @@ class MonthWeekdayWeekendSchedule
     schedule = OpenStudio::Model::ScheduleRuleset.new(@model)
     schedule.setName(@sch_name)
 
-    assumedYear = year_description.assumedYear # prevent excessive OS warnings about 'UseWeatherFile'
-
     prev_wkdy_vals = nil
     prev_wkdy_rule = nil
     prev_wknd_vals = nil
@@ -346,8 +497,8 @@ class MonthWeekdayWeekendSchedule
 
     periods.each do |period|
       for m in period[0]..period[1]
-        date_s = OpenStudio::Date::fromDayOfYear(day_startm[m], assumedYear)
-        date_e = OpenStudio::Date::fromDayOfYear(day_endm[m], assumedYear)
+        date_s = OpenStudio::Date::fromDayOfYear(day_startm[m - 1], @year)
+        date_e = OpenStudio::Date::fromDayOfYear(day_endm[m - 1], @year)
 
         wkdy_vals = []
         wknd_vals = []
@@ -426,232 +577,6 @@ class MonthWeekdayWeekendSchedule
   end
 end
 
-class HotWaterSchedule
-  def initialize(model, obj_name, nbeds, days_shift = 0, dryer_exhaust_min_runtime = 0, create_sch_object = true)
-    @model = model
-    @sch_name = "#{obj_name} schedule"
-    @schedule = nil
-    if nbeds < 1
-      @nbeds = 1
-    elsif nbeds > 5
-      @nbeds = 5
-    else
-      @nbeds = nbeds
-    end
-    file_prefixes = { Constants.ObjectNameClothesWasher => 'ClothesWasher',
-                      Constants.ObjectNameClothesDryer => 'ClothesWasher',
-                      Constants.ObjectNameClothesDryerExhaust => 'ClothesWasher',
-                      Constants.ObjectNameDishwasher => 'Dishwasher',
-                      Constants.ObjectNameFixtures => 'Fixtures' }
-    @file_prefix = file_prefixes[obj_name]
-
-    timestep_minutes = (60 / @model.getTimestep.numberOfTimestepsPerHour).to_i
-    weeks = 1 # use a single week that repeats
-
-    @data = loadMinuteDrawProfileFromFile(timestep_minutes, days_shift, weeks, dryer_exhaust_min_runtime)
-    @totflow, @maxflow, @ontime = loadDrawProfileStatsFromFile()
-    if create_sch_object
-      @schedule = createSchedule(@data, timestep_minutes, weeks)
-    end
-  end
-
-  def data
-    return @data
-  end
-
-  def calcDesignLevelFromDailykWh(daily_kWh)
-    return UnitConversions.convert(daily_kWh * 365 * 60 / (365 * @totflow / @maxflow), 'kW', 'W')
-  end
-
-  def calcPeakFlowFromDailygpm(daily_water)
-    return UnitConversions.convert(@maxflow * daily_water / @totflow, 'gal/min', 'm^3/s')
-  end
-
-  def calcDailyGpmFromPeakFlow(peak_flow)
-    return UnitConversions.convert(@totflow * peak_flow / @maxflow, 'm^3/s', 'gal/min')
-  end
-
-  def calcDesignLevelFromDailyTherm(daily_therm)
-    return calcDesignLevelFromDailykWh(UnitConversions.convert(daily_therm, 'therm', 'kWh'))
-  end
-
-  def schedule
-    return @schedule
-  end
-
-  def totalFlow
-    return @totflow
-  end
-
-  private
-
-  def loadMinuteDrawProfileFromFile(timestep_minutes, days_shift, weeks, dryer_exhaust_min_runtime)
-    data = []
-    if @file_prefix.nil?
-      return data
-    end
-
-    # Get appropriate file
-    minute_draw_profile = File.join(File.dirname(__FILE__), "data_hot_water_#{@file_prefix.downcase}_schedule_#{@nbeds}bed.csv")
-    if not File.file?(minute_draw_profile)
-      fail "Unable to find file: #{minute_draw_profile}"
-    end
-
-    minutes_in_year = 8760 * 60
-    weeks_in_minutes = weeks * 7 * 24 * 60
-
-    # Read data into minute array
-    skippedheader = false
-    min_shift = 24 * 60 * (days_shift % 365) # For MF homes, shift each unit by an additional week
-    items = [0] * minutes_in_year
-    File.open(minute_draw_profile).each do |line|
-      linedata = line.strip.split(',')
-      if not skippedheader
-        skippedheader = true
-        next
-      end
-      shifted_minute = linedata[0].to_i - min_shift
-      if shifted_minute < 0
-        stored_minute = shifted_minute + minutes_in_year
-      else
-        stored_minute = shifted_minute
-      end
-      value = linedata[1].to_f
-      items[stored_minute.to_i] = value
-      if shifted_minute >= weeks_in_minutes
-        break # no need to process more data
-      end
-    end
-
-    if dryer_exhaust_min_runtime > 0
-      # Clothes dryer exhaust vent should operate whenever the dryer is operating,
-      # with a minimum runtime in minutes.
-      items.reverse.each_with_index do |val, i|
-        next unless val > 0
-
-        place = (items.length - 1) - i
-        last = place + dryer_exhaust_min_runtime
-        items.fill(1, place...last)
-      end
-    end
-
-    # Aggregate minute schedule up to the timestep level to reduce the size
-    # and speed of processing.
-    for tstep in 0..(minutes_in_year / timestep_minutes).to_i - 1
-      timestep_items = items[tstep * timestep_minutes, timestep_minutes]
-      avgitem = timestep_items.reduce(:+).to_f / timestep_items.size
-      data.push(avgitem)
-      if (tstep + 1) * timestep_minutes > weeks_in_minutes
-        break # no need to process more data
-      end
-    end
-
-    return data
-  end
-
-  def loadDrawProfileStatsFromFile()
-    totflow = 0 # daily gal/day
-    maxflow = 0
-    ontime = 0
-
-    column_header = @file_prefix
-
-    totflow_column_header = "#{column_header} Sum"
-    maxflow_column_header = "#{column_header} Max"
-    ontime_column_header = 'On-time Fraction'
-
-    draw_file = File.join(File.dirname(__FILE__), 'data_hot_water_max_flows.csv')
-
-    datafound = false
-    skippedheader = false
-    totflow_col_num = nil
-    maxflow_col_num = nil
-    ontime_col_num = nil
-    File.open(draw_file).each do |line|
-      linedata = line.strip.split(',')
-      if not skippedheader
-        skippedheader = true
-        # Which columns to read?
-        totflow_col_num = linedata.index(totflow_column_header)
-        maxflow_col_num = linedata.index(maxflow_column_header)
-        ontime_col_num = linedata.index(ontime_column_header)
-        next
-      end
-      next unless linedata[0].to_i == @nbeds
-
-      datafound = true
-      if not totflow_col_num.nil?
-        totflow = linedata[totflow_col_num].to_f
-      end
-      if not maxflow_col_num.nil?
-        maxflow = linedata[maxflow_col_num].to_f
-      end
-      if not ontime_col_num.nil?
-        ontime = linedata[ontime_col_num].to_f
-      end
-      break
-    end
-
-    if not datafound
-      fail "Unable to find data for bedrooms = #{@nbeds}."
-    end
-
-    return totflow, maxflow, ontime
-  end
-
-  def createSchedule(data, timestep_minutes, weeks)
-    data_size = data.size
-    if data_size == 0
-      return
-    end
-
-    year_description = @model.getYearDescription
-    assumed_year = year_description.assumedYear
-
-    last_day_of_year = 365
-    last_day_of_year += 1 if year_description.isLeapYear
-
-    # Create ScheduleRuleset with repeating weeks
-
-    time = []
-    (timestep_minutes..24 * 60).step(timestep_minutes).to_a.each_with_index do |m, i|
-      time[i] = OpenStudio::Time.new(0, 0, m, 0)
-    end
-
-    schedule = OpenStudio::Model::ScheduleRuleset.new(@model)
-
-    schedule_rules = []
-    for d in 1..7 * weeks # how many unique day schedules
-      next if d > last_day_of_year
-
-      rule = OpenStudio::Model::ScheduleRule.new(schedule)
-      rule.setName(@sch_name + " #{Schedule.allday_name} ruleset#{d}")
-      day_schedule = rule.daySchedule
-      day_schedule.setName(@sch_name + " #{Schedule.allday_name}#{d}")
-      previous_value = data[(d - 1) * 24 * 60 / timestep_minutes]
-      time.each_with_index do |m, i|
-        if i != time.length - 1
-          next if data[i + 1 + (d - 1) * 24 * 60 / timestep_minutes] == previous_value
-        end
-        day_schedule.addValue(m, previous_value)
-        previous_value = data[i + 1 + (d - 1) * 24 * 60 / timestep_minutes]
-      end
-      Schedule.set_weekday_rule(rule)
-      Schedule.set_weekend_rule(rule)
-      for w in 0..52 # max num of weeks
-        next if d + (w * 7 * weeks) > last_day_of_year
-
-        date_s = OpenStudio::Date::fromDayOfYear(d + (w * 7 * weeks), assumed_year)
-        rule.addSpecificDate(date_s)
-      end
-    end
-
-    schedule.setName(@sch_name)
-
-    return schedule
-  end
-end
-
 class Schedule
   def self.allday_name
     return 'allday'
@@ -798,11 +723,11 @@ class Schedule
   end
 
   def self.OccupantsWeekdayFractions
-    return '1.00000, 1.00000, 1.00000, 1.00000, 1.00000, 1.00000, 1.00000, 0.88310, 0.40861, 0.24189, 0.24189, 0.24189, 0.24189, 0.24189, 0.24189, 0.24189, 0.29498, 0.55310, 0.89693, 0.89693, 0.89693, 1.00000, 1.00000, 1.00000'
+    return '0.061, 0.061, 0.061, 0.061, 0.061, 0.061, 0.061, 0.053, 0.025, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.018, 0.033, 0.054, 0.054, 0.054, 0.061, 0.061, 0.061'
   end
 
   def self.OccupantsWeekendFractions
-    return '1.00000, 1.00000, 1.00000, 1.00000, 1.00000, 1.00000, 1.00000, 0.88310, 0.40861, 0.24189, 0.24189, 0.24189, 0.24189, 0.24189, 0.24189, 0.24189, 0.29498, 0.55310, 0.89693, 0.89693, 0.89693, 1.00000, 1.00000, 1.00000'
+    return '0.061, 0.061, 0.061, 0.061, 0.061, 0.061, 0.061, 0.053, 0.025, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.015, 0.018, 0.033, 0.054, 0.054, 0.054, 0.061, 0.061, 0.061'
   end
 
   def self.OccupantsMonthlyMultipliers
@@ -846,6 +771,54 @@ class Schedule
     return '1.097, 1.097, 0.991, 0.987, 0.991, 0.890, 0.896, 0.896, 0.890, 1.085, 1.085, 1.097'
   end
 
+  def self.DishwasherWeekdayFractions
+    return '0.015, 0.007, 0.005, 0.003, 0.003, 0.010, 0.020, 0.031, 0.058, 0.065, 0.056, 0.048, 0.041, 0.046, 0.036, 0.038, 0.038, 0.049, 0.087, 0.111, 0.090, 0.067, 0.044, 0.031'
+  end
+
+  def self.DishwasherWeekendFractions
+    return '0.015, 0.007, 0.005, 0.003, 0.003, 0.010, 0.020, 0.031, 0.058, 0.065, 0.056, 0.048, 0.041, 0.046, 0.036, 0.038, 0.038, 0.049, 0.087, 0.111, 0.090, 0.067, 0.044, 0.031'
+  end
+
+  def self.DishwasherMonthlyMultipliers
+    return '1.097, 1.097, 0.991, 0.987, 0.991, 0.890, 0.896, 0.896, 0.890, 1.085, 1.085, 1.097'
+  end
+
+  def self.ClothesWasherWeekdayFractions
+    return '0.009, 0.007, 0.004, 0.004, 0.007, 0.011, 0.022, 0.049, 0.073, 0.086, 0.084, 0.075, 0.067, 0.060, 0.049, 0.052, 0.050, 0.049, 0.049, 0.049, 0.049, 0.047, 0.032, 0.017'
+  end
+
+  def self.ClothesWasherWeekendFractions
+    return '0.009, 0.007, 0.004, 0.004, 0.007, 0.011, 0.022, 0.049, 0.073, 0.086, 0.084, 0.075, 0.067, 0.060, 0.049, 0.052, 0.050, 0.049, 0.049, 0.049, 0.049, 0.047, 0.032, 0.017'
+  end
+
+  def self.ClothesWasherMonthlyMultipliers
+    return '1.011, 1.002, 1.022, 1.020, 1.022, 0.996, 0.999, 0.999, 0.996, 0.964, 0.959, 1.011'
+  end
+
+  def self.ClothesDryerWeekdayFractions
+    return '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'
+  end
+
+  def self.ClothesDryerWeekendFractions
+    return '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'
+  end
+
+  def self.ClothesDryerMonthlyMultipliers
+    return '1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0'
+  end
+
+  def self.FixturesWeekdayFractions
+    return '0.012, 0.006, 0.004, 0.005, 0.010, 0.034, 0.078, 0.087, 0.080, 0.067, 0.056, 0.047, 0.040, 0.035, 0.033, 0.031, 0.039, 0.051, 0.060, 0.060, 0.055, 0.048, 0.038, 0.026'
+  end
+
+  def self.FixturesWeekendFractions
+    return '0.012, 0.006, 0.004, 0.005, 0.010, 0.034, 0.078, 0.087, 0.080, 0.067, 0.056, 0.047, 0.040, 0.035, 0.033, 0.031, 0.039, 0.051, 0.060, 0.060, 0.055, 0.048, 0.038, 0.026'
+  end
+
+  def self.FixturesMonthlyMultipliers
+    return '1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0'
+  end
+
   def self.RefrigeratorWeekdayFractions
     return '0.040, 0.039, 0.038, 0.037, 0.036, 0.036, 0.038, 0.040, 0.041, 0.041, 0.040, 0.040, 0.042, 0.042, 0.042, 0.041, 0.044, 0.048, 0.050, 0.048, 0.047, 0.046, 0.044, 0.041'
   end
@@ -883,11 +856,11 @@ class Schedule
   end
 
   def self.CeilingFanWeekdayFractions
-    return '0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.5, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0'
+    return '0.057, 0.057, 0.057, 0.057, 0.057, 0.057, 0.057, 0.024, 0.024, 0.024, 0.024, 0.024, 0.024, 0.024, 0.024, 0.024, 0.024, 0.024, 0.057, 0.057, 0.057, 0.057, 0.057, 0.057'
   end
 
   def self.CeilingFanWeekendFractions
-    return '0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.5, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0'
+    return '0.057, 0.057, 0.057, 0.057, 0.057, 0.057, 0.057, 0.024, 0.024, 0.024, 0.024, 0.024, 0.024, 0.024, 0.024, 0.024, 0.024, 0.024, 0.057, 0.057, 0.057, 0.057, 0.057, 0.057'
   end
 
   def self.CeilingFanMonthlyMultipliers(weather:)
@@ -927,7 +900,7 @@ class Schedule
   end
 
   def self.PlugLoadsVehicleMonthlyMultipliers
-    return '1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1'
+    return '1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0'
   end
 
   def self.PlugLoadsWellPumpWeekdayFractions
@@ -1025,43 +998,202 @@ class Schedule
   def self.HotTubHeaterMonthlyMultipliers
     return '0.837, 0.835, 1.084, 1.084, 1.084, 1.096, 1.096, 1.096, 1.096, 0.931, 0.925, 0.837'
   end
+
+  def self.get_day_num_from_month_day(year, month, day)
+    # Returns a value between 1 and 365 (or 366 for a leap year)
+    # Returns e.g. 32 for month=2 and day=1 (Feb 1)
+    month_num_days = Constants.NumDaysInMonths(year)
+    day_num = day
+    for m in 0..month - 2
+      day_num += month_num_days[m]
+    end
+    return day_num
+  end
+
+  def self.get_daily_season(year, start_month, start_day, end_month, end_day)
+    start_day_num = get_day_num_from_month_day(year, start_month, start_day)
+    end_day_num = get_day_num_from_month_day(year, end_month, end_day)
+
+    season = Array.new(Constants.NumDaysInYear(year), 0)
+    if end_day_num >= start_day_num
+      season.fill(1, start_day_num - 1, end_day_num - start_day_num + 1) # Fill between start/end days
+    else # Wrap around year
+      season.fill(1, start_day_num - 1) # Fill between start day and end of year
+      season.fill(1, 0, end_day_num) # Fill between start of year and end day
+    end
+    return season
+  end
+
+  def self.months_to_days(year, months)
+    month_num_days = Constants.NumDaysInMonths(year)
+    days = []
+    for m in 0..11
+      days.concat([months[m]] * month_num_days[m])
+    end
+    return days
+  end
+
+  def self.day_start_months(year)
+    month_num_days = Constants.NumDaysInMonths(year)
+    return month_num_days.each_with_index.map { |n, i| get_day_num_from_month_day(year, i + 1, 1) }
+  end
+
+  def self.day_end_months(year)
+    month_num_days = Constants.NumDaysInMonths(year)
+    return month_num_days.each_with_index.map { |n, i| get_day_num_from_month_day(year, i + 1, n) }
+  end
+
+  def self.create_ruleset_from_daily_season(model, values)
+    s = OpenStudio::Model::ScheduleRuleset.new(model)
+    year = model.getYearDescription.assumedYear
+    start_value = values[0]
+    start_date = OpenStudio::Date::fromDayOfYear(1, year)
+    values.each_with_index do |value, i|
+      i += 1
+      next unless value != start_value || i == values.length
+
+      rule = OpenStudio::Model::ScheduleRule.new(s)
+      set_weekday_rule(rule)
+      set_weekend_rule(rule)
+      i += 1 if i == values.length
+      end_date = OpenStudio::Date::fromDayOfYear(i - 1, year)
+      rule.setStartDate(start_date)
+      rule.setEndDate(end_date)
+      day_schedule = rule.daySchedule
+      day_schedule.addValue(OpenStudio::Time.new(0, 24, 0, 0), start_value)
+      break if i == values.length + 1
+
+      start_date = OpenStudio::Date::fromDayOfYear(i, year)
+      start_value = value
+    end
+    return s
+  end
+
+  def self.parse_date_range(date_range)
+    begin_end_dates = date_range.split('-').map { |v| v.strip }
+    if begin_end_dates.size != 2
+      fail "Invalid date format specified for '#{date_range}'."
+    end
+
+    begin_values = begin_end_dates[0].split(' ').map { |v| v.strip }
+    end_values = begin_end_dates[1].split(' ').map { |v| v.strip }
+
+    if (begin_values.size != 2) || (end_values.size != 2)
+      fail "Invalid date format specified for '#{date_range}'."
+    end
+
+    require 'date'
+    begin_month = Date::ABBR_MONTHNAMES.index(begin_values[0].capitalize)
+    end_month = Date::ABBR_MONTHNAMES.index(end_values[0].capitalize)
+    begin_day = begin_values[1].to_i
+    end_day = end_values[1].to_i
+    if begin_month.nil? || end_month.nil? || begin_day == 0 || end_day == 0
+      fail "Invalid date format specified for '#{date_range}'."
+    end
+
+    return begin_month, begin_day, end_month, end_day
+  end
 end
 
 class SchedulesFile
-  def initialize(runner:,
-                 model:,
+  def initialize(runner: nil,
+                 model: nil,
+                 year: nil,
                  schedules_path:,
-                 col_names:,
                  **remainder)
 
-    @validated = true
     @runner = runner
     @model = model
+    @year = year
     @schedules_path = schedules_path
-    @external_file = get_external_file
-    import(col_names: col_names)
+
+    import(col_names: Constants.ScheduleColNames.keys)
+
+    @tmp_schedules = Marshal.load(Marshal.dump(@schedules))
+    set_vacancy
+
+    tmpfile = Tempfile.new(['schedules', '.csv'])
+    @tmp_schedules_path = tmpfile.path.to_s
+    export
+
+    get_external_file
+  end
+
+  def import(col_names:)
+    @schedules = {}
+    columns = CSV.read(@schedules_path).transpose
+    columns.each do |col|
+      unless col_names.include? col[0]
+        fail "Schedule column name '#{col[0]}' is invalid. [context: #{@schedules_path}]"
+      end
+
+      values = col[1..-1].reject { |v| v.nil? }
+      values = validate_schedule(col_name: col[0], values: values)
+      @schedules[col[0]] = values
+    end
   end
 
-  def validated?
-    return @validated
+  def validate_schedule(col_name:,
+                        values:)
+
+    num_hrs_in_year = Constants.NumHoursInYear(@year)
+    schedule_length = values.length
+
+    begin
+      values = values.map { |v| Float(v) }
+    rescue ArgumentError
+      fail "Schedule value must be numeric for column '#{col_name}'. [context: #{@schedules_path}]"
+    end
+
+    if (1.0 - values.max).abs > 0.01
+      fail "Schedule max value for column '#{col_name}' must be 1. [context: #{@schedules_path}]"
+    end
+
+    if values.min < 0
+      fail "Schedule min value for column '#{col_name}' must be non-negative. [context: #{@schedules_path}]"
+    end
+
+    valid_minutes_per_item = [1, 2, 3, 4, 5, 6, 10, 12, 15, 20, 30, 60]
+    valid_num_rows = valid_minutes_per_item.map { |min_per_item| (60.0 * num_hrs_in_year / min_per_item).to_i }
+    unless valid_num_rows.include? schedule_length
+      fail "Schedule has invalid number of rows (#{schedule_length}) for column '#{col_name}'. Must be one of: #{valid_num_rows.reverse.join(', ')}. [context: #{@schedules_path}]"
+    end
+
+    return values
+  end
+
+  def export
+    return false if @tmp_schedules_path.nil?
+
+    CSV.open(@tmp_schedules_path, 'wb') do |csv|
+      csv << @tmp_schedules.keys
+      rows = @tmp_schedules.values.transpose
+      rows.each do |row|
+        csv << row
+      end
+    end
+
+    return true
   end
 
   def schedules
     return @schedules
   end
 
+  def tmp_schedules
+    return @tmp_schedules
+  end
+
+  def external_file
+    return @external_file
+  end
+
   def get_col_index(col_name:)
     headers = CSV.open(@schedules_path, 'r') { |csv| csv.first }
     col_num = headers.index(col_name)
     return col_num
   end
 
-  def get_col_name(col_index:)
-    headers = CSV.open(@schedules_path, 'r') { |csv| csv.first }
-    col_name = headers[col_index]
-    return col_name
-  end
-
   def create_schedule_file(col_name:,
                            rows_to_skip: 1)
     @model.getScheduleFiles.each do |schedule_file|
@@ -1076,8 +1208,7 @@ class SchedulesFile
     end
 
     col_index = get_col_index(col_name: col_name)
-    year_description = @model.getYearDescription
-    num_hrs_in_year = Constants.NumHoursInYear(year_description.isLeapYear)
+    num_hrs_in_year = Constants.NumHoursInYear(@year)
     schedule_length = @schedules[col_name].length
     min_per_item = 60.0 / (schedule_length / num_hrs_in_year)
 
@@ -1092,15 +1223,16 @@ class SchedulesFile
   end
 
   # the equivalent number of hours in the year, if the schedule was at full load (1.0)
-  def annual_equivalent_full_load_hrs(col_name:)
-    # import(col_names: [col_name])
+  def annual_equivalent_full_load_hrs(col_name:,
+                                      schedules: nil)
+    if schedules.nil?
+      schedules = @schedules # the schedules before vacancy is applied
+    end
 
-    year_description = @model.getYearDescription
-    num_hrs_in_year = Constants.NumHoursInYear(year_description.isLeapYear)
-    schedule_length = @schedules[col_name].length
+    num_hrs_in_year = Constants.NumHoursInYear(@year)
+    schedule_length = schedules[col_name].length
     min_per_item = 60.0 / (schedule_length / num_hrs_in_year)
-
-    ann_equiv_full_load_hrs = @schedules[col_name].reduce(:+) / (60.0 / min_per_item)
+    ann_equiv_full_load_hrs = schedules[col_name].reduce(:+) / (60.0 / min_per_item)
 
     return ann_equiv_full_load_hrs
   end
@@ -1132,27 +1264,17 @@ class SchedulesFile
   def calc_design_level_from_daily_kwh(col_name:,
                                        daily_kwh:)
     full_load_hrs = annual_equivalent_full_load_hrs(col_name: col_name)
-    year_description = @model.getYearDescription
-    num_days_in_year = Constants.NumDaysInYear(year_description.isLeapYear)
+    num_days_in_year = Constants.NumDaysInYear(@year)
     daily_full_load_hrs = full_load_hrs / num_days_in_year
     design_level = UnitConversions.convert(daily_kwh / daily_full_load_hrs, 'kW', 'W')
 
     return design_level
   end
 
-  # thermal equivalent of calc_design_level_from_daily_kwh
-  def calc_design_level_from_daily_therm(col_name:,
-                                         daily_therm:)
-    daily_kwh = UnitConversions.convert(daily_therm, 'therm', 'kWh')
-    design_level = calc_design_level_from_daily_kwh(col_name: col_name, daily_kwh: daily_kwh)
-    return design_level
-  end
-
   # similar to calc_design_level_from_daily_kwh but for water usage
   def calc_peak_flow_from_daily_gpm(col_name:, daily_water:)
     ann_equiv_full_load_hrs = annual_equivalent_full_load_hrs(col_name: col_name)
-    year_description = @model.getYearDescription
-    num_days_in_year = Constants.NumDaysInYear(year_description.isLeapYear)
+    num_days_in_year = Constants.NumDaysInYear(@year)
     daily_full_load_hrs = ann_equiv_full_load_hrs / num_days_in_year
     peak_flow = daily_water / daily_full_load_hrs # gallons_per_hour
     peak_flow /= 60 # convert to gallons per minute
@@ -1160,146 +1282,27 @@ class SchedulesFile
     return peak_flow
   end
 
-  # get daily gallons from the peak flow rate
-  def calc_daily_gpm_from_peak_flow(col_name:, peak_flow:)
-    ann_equiv_full_load_hrs = annual_equivalent_full_load_hrs(col_name: col_name)
-    year_description = @model.getYearDescription
-    num_days_in_year = Constants.NumDaysInYear(year_description.isLeapYear)
-    peak_flow = UnitConversions.convert(peak_flow, 'm^3/s', 'gal/min')
-    daily_gallons = (ann_equiv_full_load_hrs * 60 * peak_flow) / num_days_in_year
-    return daily_gallons
-  end
-
-  def validate_schedule(col_name:,
-                        values:)
-
-    year_description = @model.getYearDescription
-    num_hrs_in_year = Constants.NumHoursInYear(year_description.isLeapYear)
-    schedule_length = values.length
-
-    if values.max > 1
-      @runner.registerError("The max value of schedule '#{col_name}' is greater than 1.")
-      @validated = false
-    end
-
-    min_per_item = 60.0 / (schedule_length / num_hrs_in_year)
-    unless [1, 2, 3, 4, 5, 6, 10, 12, 15, 20, 30, 60].include? min_per_item
-      @runner.registerError("Calculated an invalid schedule min_per_item=#{min_per_item}.")
-      @validated = false
-    end
-  end
-
-  def external_file
-    return @external_file
-  end
-
   def get_external_file
-    if File.exist? @schedules_path
-      external_file = OpenStudio::Model::ExternalFile::getExternalFile(@model, @schedules_path)
-      if external_file.is_initialized
-        external_file = external_file.get
+    if File.exist? @tmp_schedules_path
+      @external_file = OpenStudio::Model::ExternalFile::getExternalFile(@model, @tmp_schedules_path)
+      if @external_file.is_initialized
+        @external_file = @external_file.get
       end
     end
-    return external_file
   end
 
   def set_vacancy
-    return unless @schedules.keys.include? 'vacancy'
-    return if @schedules['vacancy'].all? { |i| i == 0 }
+    return unless @tmp_schedules.keys.include? 'vacancy'
+    return if @tmp_schedules['vacancy'].all? { |i| i == 0 }
 
-    col_names = ScheduleGenerator.col_names
+    col_names = Constants.ScheduleColNames
 
-    @schedules[col_names.keys[0]].each_with_index do |ts, i|
+    @tmp_schedules[col_names.keys[0]].each_with_index do |ts, i|
       col_names.keys.each do |col_name|
+        next if col_names[col_name].nil?
         next unless col_names[col_name] # skip those unaffected by vacancy
 
-        @schedules[col_name][i] *= (1.0 - @schedules['vacancy'][i])
-      end
-    end
-
-    update(col_names: col_names.keys)
-  end
-
-  def set_outage(outage_start_date:,
-                 outage_end_date:)
-
-    minutes_per_step = 60
-    if @model.getSimulationControl.timestep.is_initialized
-      minutes_per_step = 60 / @model.getSimulationControl.timestep.get.numberOfTimestepsPerHour
-    end
-
-    col_names = ScheduleGenerator.col_names
-
-    sec_per_step = minutes_per_step * 60.0
-    col_names.each do |col_name, val|
-      next if col_name == 'occupants'
-      next if val.nil?
-
-      ts = Time.new(outage_start_date.year, 'Jan', 1)
-      @schedules[col_name].each_with_index do |step, i|
-        if outage_start_date <= ts && ts < outage_end_date # in the outage period
-          @schedules[col_name][i] = 0.0
-        end
-        ts += sec_per_step
-      end
-    end
-
-    update(col_names: col_names.keys)
-  end
-
-  def import(col_names:)
-    @schedules = {}
-    col_names += ['vacancy']
-    columns = CSV.read(@schedules_path).transpose
-    columns.each do |col|
-      next if not col_names.include? col[0]
-
-      values = col[1..-1].reject { |v| v.nil? }
-      values = values.map { |v| v.to_f }
-      validate_schedule(col_name: col[0], values: values)
-      @schedules[col[0]] = values
-    end
-  end
-
-  def export
-    return false if @schedules_path.nil?
-
-    CSV.open(@schedules_path, 'wb') do |csv|
-      csv << @schedules.keys
-      rows = @schedules.values.transpose
-      rows.each do |row|
-        csv << row
-      end
-    end
-
-    return true
-  end
-
-  def update(col_names:)
-    return false if @schedules_path.nil?
-
-    # need to update schedules csv in generated_files folder (alongside run folder) since this is what the simulation points to
-    begin
-      schedules_path = File.expand_path(File.join(File.dirname(@schedules_path), '../generated_files', File.basename(@schedules_path))) # called from cli
-      columns = CSV.read(schedules_path).transpose
-    rescue
-      schedules_path = File.expand_path(File.join(File.dirname(@schedules_path), '../../../files', File.basename(@schedules_path))) # testing
-      columns = CSV.read(schedules_path).transpose
-    end
-
-    col_names.each do |col_name|
-      col_num = get_col_index(col_name: col_name)
-      columns.each_with_index do |col, i|
-        next unless i == col_num
-
-        columns[i][1..-1] = @schedules[col_name]
-      end
-    end
-
-    rows = columns.transpose
-    CSV.open(schedules_path, 'wb') do |csv|
-      rows.each do |row|
-        csv << row
+        @tmp_schedules[col_name][i] *= (1.0 - @tmp_schedules['vacancy'][i])
       end
     end
   end