openstudio-standards 0.2.16 → 0.2.17.rc1

data/lib/openstudio-standards/standards/Standards.ScheduleRuleset.rb

@@ -115,6 +115,42 @@ class Standard
     return annual_flh
   end
 
+  # Returns the min and max value in a design day (heating or cooling) from a ruleset schedule
+  #
+  # @author Weili Xu, PNNL.
+  # @param schedule_ruleset [OpenStudio::Model::ScheduleRuleset] schedule ruleset object
+  # @param type [String] 'winter' will enable the winter design day search, 'summer' enables summer design day search
+  # @return [Hash] Hash has two keys, min and max.
+  def schedule_ruleset_design_day_min_max_value(schedule_ruleset, type = 'winter')
+    if type == 'winter'
+      schedule = schedule_ruleset.winterDesignDaySchedule
+    elsif type == 'summer'
+      schedule = schedule_ruleset.summerDesignDaySchedule
+    end
+
+    if !schedule
+      OpenStudio.logFree(OpenStudio::Warn, 'OpenStudio::Model::ScheduleRuleset', "#{schedule_ruleset.name} is missing #{type} design day schedule, use default day schedule to process the min max search")
+      schedule = schedule_ruleset.defaultDaySchedule
+    end
+
+    min = nil
+    max = nil
+    schedule.values.each do |value|
+      if min.nil?
+        min = value
+      else
+        min = value if min > value
+      end
+      if max.nil?
+        max = value
+      else
+        max = value if max < value
+      end
+    end
+
+    return { 'min' => min, 'max' => max }
+  end
+
   # Returns the min and max value for this schedule.
   # It doesn't evaluate design days only run-period conditions
   #
@@ -606,6 +642,513 @@ class Standard
     return true
   end
 
+  #
+  # Return Array of weekday values from Array of all day values
+  # @author Xuechen (Jerry) Lei, PNNL
+  # @param model [OpenStudio::model::Model] OpenStudio model object
+  # @param values [Array] hourly time-series values of all days
+  # @param value_includes_holiday [Bool] whether the input values include a day of holiday at the end of the array
+  #
+  # @return [Array] hourly time-series values in weekdays
+  #
+  def get_weekday_values_from_8760(model, values, value_includes_holiday = true)
+    start_day = model.getYearDescription.dayofWeekforStartDay
+    start_day_map = {
+      'Sunday' => 0,
+      'Monday' => 1,
+      'Tuesday' => 2,
+      'Wednesday' => 3,
+      'Thursday' => 4,
+      'Friday' => 5,
+      'Saturday' => 6
+    }
+    start_day_num = start_day_map[start_day]
+    weekday_values = []
+    day_of_week = start_day_num
+    num_of_days = values.size / 24
+    if value_includes_holiday
+      num_of_days -= 1
+    end
+
+    for day_i in 1..num_of_days do
+      if day_of_week >= 1 && day_of_week <= 5
+        weekday_values += values.slice!(0, 24)
+      end
+      day_of_week += 1
+      # reset day of week
+      if day_of_week == 7
+        day_of_week = 0
+      end
+    end
+
+    return weekday_values
+  end
+
+  # Create a sequential array of values from a ScheduleReset object
+  # Will actually include 24 extra values if model year is a leap year
+  # Will also include 24 values at end of array representing the holiday day schedule
+  # Intended use is for storing fan schedules to hash of ZoneName:SchedArray so schedules
+  # can be saved when HVAC objects are deleted
+  # @author Doug Maddox, PNNL
+  # @param [object] model
+  # @param [Object] schedule_ruleset
+  # @return [Array<Double>] Array of sequential hourly values for year + 24 hours at end for holiday
+  def get_8760_values_from_schedule_ruleset(model, schedule_ruleset)
+    yd = model.getYearDescription
+    start_date = yd.makeDate(1, 1)
+    end_date = yd.makeDate(12, 31)
+
+    day_of_week = start_date.dayOfWeek.valueName
+
+    values = OpenStudio::DoubleVector.new
+    day = OpenStudio::Time.new(1.0)
+    interval = OpenStudio::Time.new(1.0 / 24.0)
+    day_schedules = schedule_ruleset.to_ScheduleRuleset.get.getDaySchedules(start_date, end_date)
+
+    numdays = day_schedules.size
+
+    # Get holiday schedule and append to end of values array
+    day_schedule_holiday = nil
+    schedule_ruleset.to_ScheduleRuleset.get.scheduleRules.each do |week_rule|
+      # If a holiday day type is defined, then store the schedule object for the first occurrence
+      # For now this is not implemented into the 8760 array
+      # if week_rule.applyHoliday
+      #  day_schedule_holiday = week_rule.daySchedule
+      #  break
+      # end
+    end
+    if day_schedule_holiday.nil?
+      day_schedule_holiday = schedule_ruleset.to_ScheduleRuleset.get.defaultDaySchedule
+    end
+    # Currently holidaySchedule is not working in SDK in ScheduleRuleset object
+    # TODO: enable the following lines when holidaySchedule is available
+    # if !schedule_ruleset.isHolidayScheduleDefaulted
+    #   day_schedule = schedule_ruleset.to_ScheduleRuleset.get.holidaySchedule
+    # else
+    #  day_schedule = schedule_ruleset.to_ScheduleRuleset.get.defaultSchedule
+    # end
+
+    # Make new array of day schedules for year, and add holiday day schedule to end
+    day_sched_array = []
+    day_schedules.each do |day_schedule|
+      day_sched_array << day_schedule
+    end
+
+    day_sched_array << day_schedule_holiday
+    numdays = day_schedules.size
+
+    day_sched_array.each do |day_schedule|
+      current_hour = interval
+      time_values = day_schedule.times
+      num_times = time_values.size
+      value_sum = 0
+      value_count = 0
+      time_values.each do |until_hr|
+        if until_hr < current_hour
+          # Add to tally for next hour average
+          value_sum += day_schedule.getValue(until_hr).to_f
+          value_count += 1
+        elsif until_hr >= current_hour + interval
+          # Loop through hours to catch current hour up to until_hr
+          while current_hour <= until_hr
+            values << day_schedule.getValue(until_hr).to_f
+            current_hour += interval
+          end
+
+          if (current_hour - until_hr) < interval
+            # This means until_hr is not an even hour break
+            # i.e. there is a sub-hour time step
+            # Increment the sum for averaging
+            value_sum += day_schedule.getValue(until_hr).to_f
+            value_count += 1
+          end
+
+        else
+          # Add to tally for this hour average
+          value_sum += day_schedule.getValue(until_hr).to_f
+          value_count += 1
+          # Calc hour average
+          if value_count > 0
+            value_avg = value_sum / value_count
+          else
+            value_avg = 0
+          end
+          values << value_avg
+          # setup for next hour
+          value_sum = 0
+          value_count = 0
+          current_hour += interval
+        end
+      end
+    end
+
+    return values
+  end
+
+  # Create a ScheduleRuleset object from an 8760 sequential array of values for a
+  # Values array will actually include 24 extra values if model year is a leap year
+  # Values array will also include 24 values at end of array representing the holiday day schedule
+  # @author Doug Maddox, PNNL
+  # @param model [Object]
+  # @param values [Array<Double>] array of annual values (8760 +/ 24) + holiday values (24)
+  # @param sch_name [String] name of schedule to be created
+  # @param sch_type_limits [Object] ScheduleTypeLimits object
+  # @return [Object] ScheduleRuleset
+  def make_ruleset_sched_from_8760(model, values, sch_name, sch_type_limits)
+    # Build array of arrays: each top element is a week, each sub element is an hour of week
+    all_week_values = []
+    hr_of_yr = -1
+    (0..51).each do |iweek|
+      week_values = []
+      (0..167).each do |hr_of_wk|
+        hr_of_yr += 1
+        week_values[hr_of_wk] = values[hr_of_yr]
+      end
+      all_week_values << week_values
+    end
+
+    # Extra week for days 365 and 366 (if applicable) of year
+    # since 52 weeks is 364 days
+    hr_of_yr += 1
+    last_hr = values.size - 1
+    iweek = 52
+    week_values = []
+    hr_of_wk = -1
+    (hr_of_yr..last_hr).each do |ihr_of_yr|
+      hr_of_wk += 1
+      week_values[hr_of_wk] = values[ihr_of_yr]
+    end
+    all_week_values << week_values
+
+    # Build ruleset schedules for first week
+    yd = model.getYearDescription
+    start_date = yd.makeDate(1, 1)
+    one_day = OpenStudio::Time.new(1.0)
+    seven_days = OpenStudio::Time.new(7.0)
+    end_date = start_date + seven_days - one_day
+
+    # Create new ruleset schedule
+    sch_ruleset = OpenStudio::Model::ScheduleRuleset.new(model)
+    sch_ruleset.setName(sch_name)
+    sch_ruleset.setScheduleTypeLimits(sch_type_limits)
+
+    # Make week schedule for first week
+    num_week_scheds = 1
+    week_sch_name = sch_name + '_ws' + num_week_scheds.to_s
+    week_1_rules = make_week_ruleset_sched_from_168(model, sch_ruleset, all_week_values[1], start_date, end_date, week_sch_name)
+    week_n_rules = week_1_rules
+    all_week_rules = []
+    all_week_rules << week_1_rules
+    iweek_previous_week_rule = 0
+
+    # temporary loop for debugging
+    week_n_rules.each do |sch_rule|
+      day_rule = sch_rule.daySchedule
+      xtest = 1
+    end
+
+    # For each subsequent week, check if it is same as previous
+    # If same, then append to Schedule:Rule of previous week
+    # If different, then create new Schedule:Rule
+    (1..51).each do |iweek|
+      is_a_match = true
+      start_date = end_date + one_day
+      end_date += seven_days
+      (0..167).each do |ihr|
+        if all_week_values[iweek][ihr] != all_week_values[iweek_previous_week_rule][ihr]
+          is_a_match = false
+          break
+        end
+      end
+      if is_a_match
+        # Update the end date for the Rules of the previous week to include this week
+        all_week_rules[iweek_previous_week_rule].each do |sch_rule|
+          sch_rule.setEndDate(end_date)
+        end
+      else
+        # Create a new week schedule for this week
+        num_week_scheds += 1
+        week_sch_name = sch_name + '_ws' + num_week_scheds.to_s
+        week_n_rules = make_week_ruleset_sched_from_168(model, sch_ruleset, all_week_values[iweek], start_date, end_date, week_sch_name)
+        all_week_rules << week_n_rules
+        # Set this week as the reference for subsequent weeks
+        iweek_previous_week_rule = iweek
+      end
+    end
+
+    # temporary loop for debugging
+    week_n_rules.each do |sch_rule|
+      day_rule = sch_rule.daySchedule
+      xtest = 1
+    end
+
+    # Need to handle week 52 with days 365 and 366
+    # For each of these days, check if it matches a day from the previous week
+    iweek = 52
+    # First handle day 365
+    end_date += one_day
+    start_date = end_date
+    match_was_found = false
+    # week_n is the previous week
+    week_n_rules.each do |sch_rule|
+      day_rule = sch_rule.daySchedule
+      is_match = true
+      # Need a 24 hour array of values for the day rule
+      ihr_start = 0
+      day_values = []
+      day_rule.times.each do |time|
+        now_value = day_rule.getValue(time).to_f
+        until_ihr = time.totalHours.to_i - 1
+        (ihr_start..until_ihr).each do |ihr|
+          day_values << now_value
+        end
+      end
+      (0..23).each do |ihr|
+        if day_values[ihr] != all_week_values[iweek][ihr + ihr_start]
+          # not matching for this day_rule
+          is_match = false
+          break
+        end
+      end
+      if is_match
+        match_was_found = true
+        # Extend the schedule period to include this day
+        sch_rule.setEndDate(end_date)
+        break
+      end
+    end
+    if match_was_found == false
+      # Need to add a new rule
+      day_of_week = start_date.dayOfWeek.valueName
+      day_names = [day_of_week]
+      day_sch_name = sch_name + '_Day_365'
+      day_sch_values = []
+      (0..23).each do |ihr|
+        day_sch_values << all_week_values[iweek][ihr]
+      end
+      # sch_rule is a sub-component of the ScheduleRuleset
+      sch_rule = add_one_ruleset_sch_rule(model, sch_ruleset, start_date, end_date, day_sch_values, day_sch_name, day_names)
+      week_n_rules = sch_rule
+    end
+
+    # Handle day 366, if leap year
+    # Last day in this week is the holiday schedule
+    # If there are three days in this week, then the second is day 366
+    if all_week_values[iweek].size == 24 * 3
+      ihr_start = 23
+      end_date += one_day
+      start_date = end_date
+      match_was_found = false
+      # week_n is the previous week
+      # which would be the week based on day 356, if that was its own week
+      week_n_rules.each do |sch_rule|
+        day_rule = sch_rule.daySchedule
+        is_match = true
+        day_rule.times.each do |ihr|
+          if day_rule.getValue(ihr).to_f != all_week_values[iweek][ihr + ihr_start]
+            # not matching for this day_rule
+            is_match = false
+            break
+          end
+        end
+        if is_match
+          match_was_found = true
+          # Extend the schedule period to include this day
+          sch_rule.setEndDate(OpenStudio::Date.new(OpenStudio::MonthOfYear.new(end_date.month.to_i), end_date.day.to_i))
+          break
+        end
+      end
+      if match_was_found == false
+        # Need to add a new rule
+        # sch_rule is a sub-component of the ScheduleRuleset
+
+        day_of_week = start_date.dayOfWeek.valueName
+        day_names = [day_of_week]
+        day_sch_name = sch_name + '_Day_366'
+        day_sch_values = []
+        (0..23).each do |ihr|
+          day_sch_values << all_week_values[iweek][ihr]
+        end
+        sch_rule = add_one_ruleset_sch_rule(model, sch_ruleset, start_date, end_date, day_sch_values, day_sch_name, day_names)
+        week_n_rules = sch_rule
+      end
+
+      # Last day in values array is the holiday schedule
+      # TODO: add holiday schedule when implemented in OpenStudio SDK
+    end
+
+    # Need to handle design days
+    # Find schedule with the most operating hours in a day,
+    # and apply that to both cooling and heating design days
+    hr_of_yr = -1
+    max_eflh = 0
+    ihr_max = -1
+    (0..364).each do |iday|
+      eflh = 0
+      ihr_start = hr_of_yr + 1
+      (0..23).each do |ihr|
+        hr_of_yr += 1
+        eflh += 1 if values[hr_of_yr] > 0
+      end
+      if eflh > max_eflh
+        max_eflh = eflh
+        # store index to first hour of day with max on hours
+        ihr_max = ihr_start
+      end
+    end
+    # Create the schedules for the design days
+    day_sch = OpenStudio::Model::ScheduleDay.new(model)
+    day_sch.setName(sch_name + 'Winter Design Day')
+    (0..23).each do |ihr|
+      hr_of_yr = ihr_max + ihr
+      next if values[hr_of_yr] == values[hr_of_yr + 1]
+
+      day_sch.addValue(OpenStudio::Time.new(0, ihr + 1, 0, 0), values[hr_of_yr])
+    end
+    sch_ruleset.setWinterDesignDaySchedule(day_sch)
+
+    day_sch = OpenStudio::Model::ScheduleDay.new(model)
+    day_sch.setName(sch_name + 'Summer Design Day')
+    (0..23).each do |ihr|
+      hr_of_yr = ihr_max + ihr
+      next if values[hr_of_yr] == values[hr_of_yr + 1]
+
+      day_sch.addValue(OpenStudio::Time.new(0, ihr + 1, 0, 0), values[hr_of_yr])
+    end
+    sch_ruleset.setSummerDesignDaySchedule(day_sch)
+
+    return sch_ruleset
+  end
+
+  # Create a ScheduleRules object from an hourly array of values for a week
+  # @author Doug Maddox, PNNL
+  # @param model [Object]
+  # @param sch_ruleset [Object] ScheduleRuleset object
+  # @param values [Array<Double>] array of hourly values for week (168)
+  # @param start_date [Date] start date of week period
+  # @param end_date [Date] end date of week period
+  # @param sch_name [String] name of parent ScheduleRuleset object
+  # @return [Array<Object>] array of ScheduleRules objects
+  def make_week_ruleset_sched_from_168(model, sch_ruleset, values, start_date, end_date, sch_name)
+    one_day = OpenStudio::Time.new(1.0)
+    now_date = start_date - one_day
+    days_of_week = []
+    values_by_day = []
+    # Organize data into days
+    # create a 2-D array values_by_day[iday][ihr]
+    hr_of_wk = -1
+    (0..6).each do |iday|
+      hr_values = []
+      (0..23).each do |hr_of_day|
+        hr_of_wk += 1
+        hr_values << values[hr_of_wk]
+      end
+      values_by_day << hr_values
+      now_date += one_day
+      days_of_week << now_date.dayOfWeek.valueName
+    end
+
+    # Make list of unique day schedules
+    # First one is automatically unique
+    # Store indexes to days with the same sched in array of arrays
+    # day_sched_idays[0] << 0
+    day_sched = {}
+    day_sched['day_idx_list'] = [0]
+    day_sched['hr_values'] = values_by_day[0]
+    day_scheds = []
+    day_scheds << day_sched
+
+    # Check each day with the cumulative list of day_scheds and add new, if unique
+    (1..6).each do |iday|
+      match_was_found = false
+      day_scheds.each do |day_sched|
+        # Compare each jday to the current iday and check for a match
+        is_a_match = true
+        (0..23).each do |ihr|
+          if day_sched['hr_values'][ihr] != values_by_day[iday][ihr]
+            # this hour is not a match
+            is_a_match = false
+            break
+          end
+        end
+        if is_a_match
+          # Add the day index to the list for this day_sched
+          day_sched['day_idx_list'] << iday
+          match_was_found = true
+          break
+        end
+      end
+      if match_was_found == false
+        # Add a new day type
+        day_sched = {}
+        day_sched['day_idx_list'] = [iday]
+        day_sched['hr_values'] = values_by_day[iday]
+        day_scheds << day_sched
+      end
+    end
+
+    # Add the Rule and Day objects
+    sch_rules = []
+    iday_sch = 0
+    day_scheds.each do |day_sched|
+      iday_sch += 1
+
+      day_names = []
+      day_sched['day_idx_list'].each do |idx|
+        day_names << days_of_week[idx]
+      end
+      day_sch_name = "#{sch_name} Day #{iday_sch}"
+      day_sch_values = day_sched['hr_values']
+      sch_rule = add_one_ruleset_sch_rule(model, sch_ruleset, start_date, end_date, day_sch_values, day_sch_name, day_names)
+
+      sch_rules << sch_rule
+    end
+
+    return sch_rules
+  end
+
+  # Create a ScheduleRules object from an hourly array of values for a week
+  # @author Doug Maddox, PNNL
+  # @param model [Object]
+  # @param sch_ruleset [Object] ScheduleRuleset object
+  # @param values [Array<Double>] array of hourly values for day (24)
+  # @param start_date [Date] start date of week period
+  # @param end_date [Date] end date of week period
+  # @param sch_name [String] name of ScheduleDay object
+  # @param day_names [Array<String>] list of days of week for which this day type is applicable
+  # @return [Object] ScheduleDay object
+  def add_one_ruleset_sch_rule(model, sch_ruleset, start_date, end_date, values, sch_name, day_names)
+    # sch_rule is a sub-component of the ScheduleRuleset
+    sch_rule = OpenStudio::Model::ScheduleRule.new(sch_ruleset)
+    # Set the dates when the rule applies
+    sch_rule.setStartDate(OpenStudio::Date.new(OpenStudio::MonthOfYear.new(start_date.monthOfYear.value.to_i), start_date.dayOfMonth.to_i))
+    sch_rule.setStartDate(start_date)
+    sch_rule.setEndDate(end_date)
+
+    # Set the days for which the rule applies
+    day_names.each do |day_of_week|
+      sch_rule.setApplySunday(true) if day_of_week == 'Sunday'
+      sch_rule.setApplyMonday(true) if day_of_week == 'Monday'
+      sch_rule.setApplyTuesday(true) if day_of_week == 'Tuesday'
+      sch_rule.setApplyWednesday(true) if day_of_week == 'Wednesday'
+      sch_rule.setApplyThursday(true) if day_of_week == 'Thursday'
+      sch_rule.setApplyFriday(true) if day_of_week == 'Friday'
+      sch_rule.setApplySaturday(true) if day_of_week == 'Saturday'
+    end
+
+    # Create the day schedule and add hourly values
+    day_sch = sch_rule.daySchedule
+    # day_sch = OpenStudio::Model::ScheduleDay.new(model)
+    day_sch.setName(sch_name)
+    (0..23).each do |ihr|
+      next if values[ihr] == values[ihr + 1]
+
+      day_sch.addValue(OpenStudio::Time.new(0, ihr + 1, 0, 0), values[ihr])
+    end
+
+    return sch_rule
+  end
+
   private
 
   # Set the hours of operation (0 or 1) for a ScheduleDay.