Module: OsLib_Schedules

Included in:

OsLib_LightingAndEquipment

Defined in:

lib/openstudio/extension/core/os_lib_schedules.rb

Overview

******************************************************************************* OpenStudio®, Copyright © Alliance for Sustainable Energy, LLC. See also openstudio.net/license *******************************************************************************

Class Method Summary

• .addScheduleTypeLimits(model) ⇒ Object

  TODO: - make sure to add this new method to cofee when done.

• .adjust_hours_of_operation_for_schedule_ruleset(runner, model, schedule, options = {}) ⇒ Object
• .conditionalScheduleValueAdjust(model, schedule, valueTestDouble, passDouble, failDouble, floorDouble, modificationType = 'Multiplier') ⇒ Object

  change value when value passes/fails test.

• .create_schedule_variable_interval_from_time_series(model, time_series) ⇒ Object

  create ScheduleVariableInterval from TimeSeries.

• .create_timeseries_from_schedule_ruleset(model, schedule_ruleset) ⇒ Object

  create TimeSeries from ScheduleRuleset.

• .createComplexSchedule(model, options = {}) ⇒ Object

  create a complex ruleset schedule.

• .createSimpleSchedule(model, options = {}) ⇒ Object

  create a ruleset schedule with a basic profile.

• .getMinMaxAnnualProfileValue(model, schedule) ⇒ Object

  find the maximum profile value for a schedule.

• .scheduleFromRateOfChange(model, schedule) ⇒ Object

  create a new schedule using absolute velocity of existing schedule.

• .simpleScheduleValueAdjust(model, schedule, double, modificationType = 'Multiplier') ⇒ Object

  find the maximum profile value for a schedule.

• .timeConditionalScheduleValueAdjust(model, schedule, hhmm_before, hhmm__after, inside_double, outside_double, modificationType = 'Multiplier') ⇒ Object

  change value when time passes test.

• .weightedMergeScheduleRulesets(model, scheduleWeighHash) ⇒ Object

  merge multiple schedules into one using load or other value to weight each schedules influence on the merge.

Class Method Details

.addScheduleTypeLimits(model) ⇒ Object

TODO: - make sure to add this new method to cofee when done

# File 'lib/openstudio/extension/core/os_lib_schedules.rb', line 554

def self.addScheduleTypeLimits(model) # TODO: - make sure to add this new method to cofee when done
  type_limits = {}

  lightsScheduleTypeLimits = OpenStudio::Model::ScheduleTypeLimits.new(model)
  lightsScheduleTypeLimits.setName('Lights Schedule Type Limits')
  lightsScheduleTypeLimits.setLowerLimitValue(0.0)
  lightsScheduleTypeLimits.setUpperLimitValue(1.0)
  lightsScheduleTypeLimits.setNumericType('Continuous')
  lightsScheduleTypeLimits.setUnitType('Dimensionless')
  type_limits['Lights'] = lightsScheduleTypeLimits

  occupancyScheduleTypeLimits = OpenStudio::Model::ScheduleTypeLimits.new(model)
  occupancyScheduleTypeLimits.setName('Occupancy Schedule Type Limits')
  occupancyScheduleTypeLimits.setLowerLimitValue(0.0)
  occupancyScheduleTypeLimits.setUpperLimitValue(1.0)
  occupancyScheduleTypeLimits.setNumericType('Continuous')
  occupancyScheduleTypeLimits.setUnitType('Dimensionless')
  type_limits['Occupancy'] = occupancyScheduleTypeLimits

  peopleActivityScheduleTypeLimits = OpenStudio::Model::ScheduleTypeLimits.new(model)
  peopleActivityScheduleTypeLimits.setName('People Activity Type Limits')
  peopleActivityScheduleTypeLimits.setLowerLimitValue(0.0)
  # peopleActivityScheduleTypeLimits.setUpperLimitValue(1500.0)
  peopleActivityScheduleTypeLimits.setNumericType('Continuous')
  peopleActivityScheduleTypeLimits.setUnitType('ActivityLevel')
  type_limits['People Activity'] = peopleActivityScheduleTypeLimits

  equipmentScheduleTypeLimits = OpenStudio::Model::ScheduleTypeLimits.new(model)
  equipmentScheduleTypeLimits.setName('Equipment Schedule Type Limits')
  equipmentScheduleTypeLimits.setLowerLimitValue(0.0)
  equipmentScheduleTypeLimits.setUpperLimitValue(1.0)
  equipmentScheduleTypeLimits.setNumericType('Continuous')
  equipmentScheduleTypeLimits.setUnitType('Dimensionless')
  type_limits['Equipment'] = equipmentScheduleTypeLimits

  waterUseScheduleTypeLimits = OpenStudio::Model::ScheduleTypeLimits.new(model)
  waterUseScheduleTypeLimits.setName('Water Use Schedule Type Limits')
  waterUseScheduleTypeLimits.setLowerLimitValue(0.0)
  waterUseScheduleTypeLimits.setUpperLimitValue(1.0)
  waterUseScheduleTypeLimits.setNumericType('Continuous')
  waterUseScheduleTypeLimits.setUnitType('Dimensionless')
  type_limits['Water Use'] = waterUseScheduleTypeLimits

  elevatorsScheduleTypeLimits = OpenStudio::Model::ScheduleTypeLimits.new(model)
  elevatorsScheduleTypeLimits.setName('Elevators Schedule Type Limits')
  elevatorsScheduleTypeLimits.setLowerLimitValue(0.0)
  elevatorsScheduleTypeLimits.setUpperLimitValue(1.0)
  elevatorsScheduleTypeLimits.setNumericType('Continuous')
  elevatorsScheduleTypeLimits.setUnitType('Dimensionless')
  type_limits['Elevators'] = elevatorsScheduleTypeLimits

  processLoadsScheduleTypeLimits = OpenStudio::Model::ScheduleTypeLimits.new(model)
  processLoadsScheduleTypeLimits.setName('Process Loads Schedule Type Limits')
  processLoadsScheduleTypeLimits.setLowerLimitValue(0.0)
  processLoadsScheduleTypeLimits.setUpperLimitValue(1.0)
  processLoadsScheduleTypeLimits.setNumericType('Continuous')
  processLoadsScheduleTypeLimits.setUnitType('Dimensionless')
  type_limits['Process Load'] = elevatorsScheduleTypeLimits

  thermostatHeatingScheduleTypeLimits = OpenStudio::Model::ScheduleTypeLimits.new(model)
  thermostatHeatingScheduleTypeLimits.setName('Thermostat Heating Setpoint Schedule Type Limits')
  thermostatHeatingScheduleTypeLimits.setLowerLimitValue(0.0)
  thermostatHeatingScheduleTypeLimits.setUpperLimitValue(100.0)
  thermostatHeatingScheduleTypeLimits.setNumericType('Continuous')
  thermostatHeatingScheduleTypeLimits.setUnitType('Temperature')
  type_limits['Thermostat Heating Setpoint'] = thermostatHeatingScheduleTypeLimits

  temperatureScheduleTypeLimits = OpenStudio::Model::ScheduleTypeLimits.new(model)
  temperatureScheduleTypeLimits.setName('Thermostat Cooling Setpoint Schedule Type Limits')
  temperatureScheduleTypeLimits.setLowerLimitValue(0.0)
  temperatureScheduleTypeLimits.setUpperLimitValue(100.0)
  temperatureScheduleTypeLimits.setNumericType('Continuous')
  temperatureScheduleTypeLimits.setUnitType('Temperature')
  type_limits['Thermostat Cooling Setpoint'] = temperatureScheduleTypeLimits

  hvacOperationScheduleTypeLimits = OpenStudio::Model::ScheduleTypeLimits.new(model)
  hvacOperationScheduleTypeLimits.setName('HVAC Operation Schedule Type Limits')
  hvacOperationScheduleTypeLimits.setLowerLimitValue(0)
  hvacOperationScheduleTypeLimits.setUpperLimitValue(1)
  hvacOperationScheduleTypeLimits.setNumericType('Discrete')
  hvacOperationScheduleTypeLimits.setUnitType('Availability')
  type_limits['HVAC Operation'] = hvacOperationScheduleTypeLimits

  temperatureScheduleTypeLimits = OpenStudio::Model::ScheduleTypeLimits.new(model)
  temperatureScheduleTypeLimits.setName('Temperature Schedule Type Limits')
  temperatureScheduleTypeLimits.setNumericType('Continuous')
  temperatureScheduleTypeLimits.setUnitType('Temperature')
  type_limits['Temperature'] = temperatureScheduleTypeLimits

  fractionScheduleTypeLimits = OpenStudio::Model::ScheduleTypeLimits.new(model)
  fractionScheduleTypeLimits.setName('Fraction Schedule Type Limits')
  fractionScheduleTypeLimits.setLowerLimitValue(0.0)
  fractionScheduleTypeLimits.setUpperLimitValue(1.0)
  fractionScheduleTypeLimits.setNumericType('Continuous')
  fractionScheduleTypeLimits.setUnitType('Dimensionless')
  type_limits['Fraction'] = fractionScheduleTypeLimits

  dimensionlessScheduleTypeLimits = OpenStudio::Model::ScheduleTypeLimits.new(model)
  dimensionlessScheduleTypeLimits.setName('Dimensionless Schedule Type Limits')
  dimensionlessScheduleTypeLimits.setNumericType('Continuous')
  dimensionlessScheduleTypeLimits.setUnitType('Dimensionless')
  type_limits['Dimensionless'] = dimensionlessScheduleTypeLimits

  return type_limits
end

.adjust_hours_of_operation_for_schedule_ruleset(runner, model, schedule, options = {}) ⇒ Object

# File 'lib/openstudio/extension/core/os_lib_schedules.rb', line 685

def self.adjust_hours_of_operation_for_schedule_ruleset(runner, model, schedule, options = {})
  defaults = {
    'base_start_hoo' => 8.0, # may not be good idea to have default
    'base_finish_hoo' => 18.0, # may not be good idea to have default
    'delta_length_hoo' => 0.0,
    'shift_hoo' => 0.0,
    'default' => true,
    'mon' => true,
    'tue' => true,
    'wed' => true,
    'thur' => true,
    'fri' => true,
    'sat' => true,
    'sun' => true,
    'summer' => false,
    'winter' => false
  }

  # merge user inputs with defaults
  options = defaults.merge(options)

  # grab schedule out of argument
  if schedule.to_ScheduleRuleset.is_initialized
    schedule = schedule.to_ScheduleRuleset.get
  else
    runner.registerWarning("you should only pass ruleset schedules into this method. skipping #{schedule.name}")
    return nil
  end

  # array of all profiles to change
  profiles = []

  # push default profiles to array
  if options['default']
    default_rule = schedule.defaultDaySchedule
    profiles << default_rule
  end

  # push profiles to array
  rules = schedule.scheduleRules
  rules.each do |rule|
    day_sch = rule.daySchedule

    # if any day requested also exists in the rule, then it will be altered
    alter_rule = false
    if rule.applyMonday && rule.applyMonday == options['mon'] then alter_rule = true end
    if rule.applyTuesday && rule.applyTuesday == options['tue'] then alter_rule = true end
    if rule.applyWednesday && rule.applyWednesday == options['wed'] then alter_rule = true end
    if rule.applyThursday && rule.applyThursday == options['thur'] then alter_rule = true end
    if rule.applyFriday && rule.applyFriday == options['fri'] then alter_rule = true end
    if rule.applySaturday && rule.applySaturday == options['sat'] then alter_rule = true end
    if rule.applySunday && rule.applySunday == options['sun'] then alter_rule = true end

    # TODO: - add in logic to warn user about conflicts where a single rule has conflicting tests

    if alter_rule
      profiles << day_sch
    end
  end

  # add design days to array
  if options['summer']
    summer_design = schedule.summerDesignDaySchedule
    profiles << summer_design
  end
  if options['winter']
    winter_design = schedule.winterDesignDaySchedule
    profiles << winter_design
  end

  # give info messages as I change specific profiles
  runner.registerInfo("Adjusting #{schedule.name}")

  # rename schedule
  schedule.setName("#{schedule.name} - extend #{options['delta_length_hoo']} shift #{options['shift_hoo']}") # if I put inputs here name will get long

  # break time args into hours and minutes
  start_hoo_hours = (options['base_start_hoo']).to_i
  start_hoo_minutes = (((options['base_start_hoo']) - (options['base_start_hoo']).to_i) * 60).to_i
  finish_hoo_hours = (options['base_finish_hoo']).to_i
  finish_hoo_minutes = (((options['base_finish_hoo']) - (options['base_finish_hoo']).to_i) * 60).to_i
  delta_hours = (options['delta_length_hoo']).to_i
  delta_minutes = (((options['delta_length_hoo']) - (options['delta_length_hoo']).to_i) * 60).to_i
  shift_hours = (options['shift_hoo']).to_i
  shift_minutes = (((options['shift_hoo']) - (options['shift_hoo']).to_i) * 60).to_i

  # time objects to use in measure
  time_0 = OpenStudio::Time.new(0, 0, 0, 0)
  time_1_min = OpenStudio::Time.new(0, 0, 1, 0) # add this to avoid times in day profile less than this
  time_12 =  OpenStudio::Time.new(0, 12, 0, 0)
  time_24 =  OpenStudio::Time.new(0, 24, 0, 0)
  start_hoo_time = OpenStudio::Time.new(0, start_hoo_hours, start_hoo_minutes, 0)
  finish_hoo_time = OpenStudio::Time.new(0, finish_hoo_hours, finish_hoo_minutes, 0)
  delta_time = OpenStudio::Time.new(0, delta_hours, delta_minutes, 0) # not used
  shift_time = OpenStudio::Time.new(0, shift_hours, shift_minutes, 0)

  # calculations
  if options['base_start_hoo'] <= options['base_finish_hoo']
    base_opp_day_length = options['base_finish_hoo'] - options['base_start_hoo']
    mid_hoo = start_hoo_time + (finish_hoo_time - start_hoo_time) / 2
    mid_non_hoo = mid_hoo + time_12
    if mid_non_hoo > time_24 then mid_non_hoo -= time_24 end
  else
    base_opp_day_length = options['base_finish_hoo'] - options['base_start_hoo'] + 24
    mid_non_hoo = finish_hoo_time + (start_hoo_time - finish_hoo_time) / 2
    mid_hoo = mid_non_hoo + time_12
    if mid_non_hoo > time_24 then mid_non_hoo -= time_24 end
  end
  adjusted_opp_day_length = base_opp_day_length + options['delta_length_hoo']
  hoo_time_multiplier = adjusted_opp_day_length / base_opp_day_length
  non_hoo_time_multiplier = (24 - adjusted_opp_day_length) / (24 - base_opp_day_length)

  # check for invalid input
  if adjusted_opp_day_length < 0
    runner.registerError('Requested hours of operation adjustment results in an invalid negative hours of operation')
    return false
  end
  # check for invalid input
  if adjusted_opp_day_length > 24
    runner.registerError('Requested hours of operation adjustment results in more than 24 hours of operation')
    return false
  end

  # making some temp objects to avoid having to deal with wrap around for change of hoo times
  mid_hoo < start_hoo_time ? (adj_mid_hoo = mid_hoo + time_24) : (adj_mid_hoo = mid_hoo)
  finish_hoo_time < adj_mid_hoo ? (adj_finish_hoo_time = finish_hoo_time + time_24) : (adj_finish_hoo_time = finish_hoo_time)
  mid_non_hoo < adj_finish_hoo_time ? (adj_mid_non_hoo = mid_non_hoo + time_24) : (adj_mid_non_hoo = mid_non_hoo)
  adj_start = start_hoo_time + time_24 # not used

  # edit profiles
  profiles.each do |day_sch|
    times = day_sch.times
    values = day_sch.values

    # in this case delete all values outside of
    # todo - may need similar logic if exactly 0 hours
    if adjusted_opp_day_length == 24
      start_val = day_sch.getValue(start_hoo_time)
      finish_val = day_sch.getValue(finish_hoo_time)

      # remove times out of range that should not be reference or compressed
      if start_hoo_time < finish_hoo_time
        times.each do |time|
          if time <= start_hoo_time || time > finish_hoo_time
            day_sch.removeValue(time)
          end
        end
        # add in values
        day_sch.addValue(start_hoo_time,start_val)
        day_sch.addValue(finish_hoo_time,finish_val)
        day_sch.addValue(time_24,[start_val,finish_val].max)
      else
        times.each do |time|
          if time > start_hoo_time && time <= finish_hoo_time
            day_sch.removeValue(time)
          end
        end
        # add in values
        day_sch.addValue(finish_hoo_time,finish_val)
        day_sch.addValue(start_hoo_time,start_val)
        day_sch.addValue(time_24,[values.first,values.last].max)
      end

    end

    times = day_sch.times
    values = day_sch.values

    # arrays for values to avoid overlap conflict of times
    new_times = []
    new_values = []

    # this is to store what datapoint will be first after midnight, and what the value at that time should be
    min_time_new = time_24
    min_time_value = nil

    # flag if found time at 24
    found_24_or_0 = false

    # push times to array
    times.each do |time|
      # create logic for four possible quadrants. Assume any quadrant can pass over 24/0 threshold
      time < start_hoo_time ? (temp_time = time + time_24) : (temp_time = time)

      # calculate change in time do to hoo delta
      if temp_time <= adj_finish_hoo_time
        expand_time = (temp_time - adj_mid_hoo) * hoo_time_multiplier - (temp_time - adj_mid_hoo)
      else
        expand_time = (temp_time - adj_mid_non_hoo) * non_hoo_time_multiplier - (temp_time - adj_mid_non_hoo)
      end

      new_time = time + shift_time + expand_time

      # adjust wrap around times
      if new_time < time_0
        new_time += time_24
      elsif new_time > time_24
        new_time -= time_24
      end
      new_times << new_time

      # see which new_time has the lowest value. Then add a value at 24 equal to that
      if !found_24_or_0 && new_time <= min_time_new
        min_time_new = new_time
        min_time_value = day_sch.getValue(time)
      elsif new_time == time_24 # this was added to address time exactly at 24
        min_time_new = new_time
        min_time_value = day_sch.getValue(time)
        found_24_or_0 = true
      elsif new_time == time_0
        min_time_new = new_time
        min_time_value = day_sch.getValue(time_0)
        found_24_or_0 = true
      end
    end

    # push values to array
    values.each do |value|
      new_values << value
    end

    # add value for what will be 24
    new_times << time_24
    new_values << min_time_value

    new_time_val_hash = {}
    new_times.each_with_index do |time,i|
      new_time_val_hash[time.totalHours] = {:time => time, :value => new_values[i]}
    end

    # clear values
    day_sch.clearValues

    new_time_val_hash = Hash[new_time_val_hash.sort]
    prev_time = nil
    new_time_val_hash.sort.each do |hours,time_val|
      if prev_time.nil? || time_val[:time] - prev_time > time_1_min
        day_sch.addValue(time_val[:time], time_val[:value])
        prev_time = time_val[:time]
      else
        puts "time step in #{day_sch.name} between #{prev_time.toString} and #{time_val[:time].toString} is too small to support, not adding value"
      end
    end

  end

  return schedule
end

.conditionalScheduleValueAdjust(model, schedule, valueTestDouble, passDouble, failDouble, floorDouble, modificationType = 'Multiplier') ⇒ Object

change value when value passes/fails test

# File 'lib/openstudio/extension/core/os_lib_schedules.rb', line 135

def self.conditionalScheduleValueAdjust(model, schedule, valueTestDouble, passDouble, failDouble, floorDouble, modificationType = 'Multiplier') # can increase/decrease by percentage or static value
  # TODO: - add in design days, maybe as optional argument

  # give option to clone or not

  # gather profiles
  profiles = []
  defaultProfile = schedule.to_ScheduleRuleset.get.defaultDaySchedule
  profiles << defaultProfile
  rules = schedule.scheduleRules
  rules.each do |rule|
    profiles << rule.daySchedule
  end

  # alter profiles
  profiles.each do |profile|
    times = profile.times
    i = 0

    profile.values.each do |value|
      # run test on this value
      if value < valueTestDouble
        double = passDouble
      else
        double = failDouble
      end

      # skip if value is floor or less
      next if value <= floorDouble

      if modificationType == 'Multiplier'
        profile.addValue(times[i], [value * double, floorDouble].max) # take the max of the floor or resulting value
      end
      if modificationType == 'Sum'
        profile.addValue(times[i], [value + double, floorDouble].max) # take the max of the floor or resulting value
      end
      i += 1
    end
  end

  result = schedule
  return result
end

.create_schedule_variable_interval_from_time_series(model, time_series) ⇒ Object

create ScheduleVariableInterval from TimeSeries

# File 'lib/openstudio/extension/core/os_lib_schedules.rb', line 681

def self.create_schedule_variable_interval_from_time_series(model, time_series)
  result = OpenStudio::Model::ScheduleInterval.fromTimeSeries(time_series, model).get
end

.create_timeseries_from_schedule_ruleset(model, schedule_ruleset) ⇒ Object

create TimeSeries from ScheduleRuleset

# File 'lib/openstudio/extension/core/os_lib_schedules.rb', line 661

def self.create_timeseries_from_schedule_ruleset(model, schedule_ruleset)
  yd = model.getYearDescription
  start_date = yd.makeDate(1, 1)
  end_date = yd.makeDate(12, 31)

  values = OpenStudio::DoubleVector.new
  day = OpenStudio::Time.new(1.0)
  interval = OpenStudio::Time.new(1.0 / 48.0)
  day_schedules = schedule_ruleset.to_ScheduleRuleset.get.getDaySchedules(start_date, end_date)
  day_schedules.each do |day_schedule|
    time = interval
    while time < day
      values << day_schedule.getValue(time)
      time += interval
    end
  end
  time_series = OpenStudio::TimeSeries.new(start_date, interval, OpenStudio.createVector(values), '')
end

.createComplexSchedule(model, options = {}) ⇒ Object

create a complex ruleset schedule

# File 'lib/openstudio/extension/core/os_lib_schedules.rb', line 467

def self.createComplexSchedule(model, options = {})
  defaults = {
    'name' => nil,
    'default_day' => ['always_on', [24.0, 1.0]]
  }

  # merge user inputs with defaults
  options = defaults.merge(options)

  # ScheduleRuleset
  sch_ruleset = OpenStudio::Model::ScheduleRuleset.new(model)
  if name
    sch_ruleset.setName(options['name'])
  end

  # Winter Design Day
  unless options['winter_design_day'].nil?
    winter_dsn_day = OpenStudio::Model::ScheduleDay.new(model)
    sch_ruleset.setWinterDesignDaySchedule(winter_dsn_day)
    winter_dsn_day = sch_ruleset.winterDesignDaySchedule
    winter_dsn_day.setName("#{sch_ruleset.name} Winter Design Day")
    options['winter_design_day'].each do |data_pair|
      hour = data_pair[0].truncate
      min = ((data_pair[0] - hour) * 60).to_i
      winter_dsn_day.addValue(OpenStudio::Time.new(0, hour, min, 0), data_pair[1])
    end
  end

  # Summer Design Day
  unless options['summer_design_day'].nil?
    summer_dsn_day = OpenStudio::Model::ScheduleDay.new(model)
    sch_ruleset.setSummerDesignDaySchedule(summer_dsn_day)
    summer_dsn_day = sch_ruleset.summerDesignDaySchedule
    summer_dsn_day.setName("#{sch_ruleset.name} Summer Design Day")
    options['summer_design_day'].each do |data_pair|
      hour = data_pair[0].truncate
      min = ((data_pair[0] - hour) * 60).to_i
      summer_dsn_day.addValue(OpenStudio::Time.new(0, hour, min, 0), data_pair[1])
    end
  end

  # Default Day
  default_day = sch_ruleset.defaultDaySchedule
  default_day.setName("#{sch_ruleset.name} #{options['default_day'][0]}")
  default_data_array = options['default_day']
  default_data_array.delete_at(0)
  default_data_array.each do |data_pair|
    hour = data_pair[0].truncate
    min = ((data_pair[0] - hour) * 60).to_i
    default_day.addValue(OpenStudio::Time.new(0, hour, min, 0), data_pair[1])
  end

  # Rules
  unless options['rules'].nil?
    options['rules'].each do |data_array|
      rule = OpenStudio::Model::ScheduleRule.new(sch_ruleset)
      rule.setName("#{sch_ruleset.name} #{data_array[0]} Rule")
      date_range = data_array[1].split('-')
      start_date = date_range[0].split('/')
      end_date = date_range[1].split('/')
      rule.setStartDate(model.getYearDescription.makeDate(start_date[0].to_i, start_date[1].to_i))
      rule.setEndDate(model.getYearDescription.makeDate(end_date[0].to_i, end_date[1].to_i))
      days = data_array[2].split('/')
      rule.setApplySunday(true) if days.include? 'Sun'
      rule.setApplyMonday(true) if days.include? 'Mon'
      rule.setApplyTuesday(true) if days.include? 'Tue'
      rule.setApplyWednesday(true) if days.include? 'Wed'
      rule.setApplyThursday(true) if days.include? 'Thu'
      rule.setApplyFriday(true) if days.include? 'Fri'
      rule.setApplySaturday(true) if days.include? 'Sat'
      day_schedule = rule.daySchedule
      day_schedule.setName("#{sch_ruleset.name} #{data_array[0]}")
      data_array.delete_at(0)
      data_array.delete_at(0)
      data_array.delete_at(0)
      data_array.each do |data_pair|
        hour = data_pair[0].truncate
        min = ((data_pair[0] - hour) * 60).to_i
        day_schedule.addValue(OpenStudio::Time.new(0, hour, min, 0), data_pair[1])
      end
    end
  end

  result = sch_ruleset
  return result
end

.createSimpleSchedule(model, options = {}) ⇒ Object

create a ruleset schedule with a basic profile

# File 'lib/openstudio/extension/core/os_lib_schedules.rb', line 8

def self.createSimpleSchedule(model, options = {})
  defaults = {
    'name' => nil,
    'winterTimeValuePairs' => { 24.0 => 0.0 },
    'summerTimeValuePairs' => { 24.0 => 1.0 },
    'defaultTimeValuePairs' => { 24.0 => 1.0 }
  }

  # merge user inputs with defaults
  options = defaults.merge(options)

  # ScheduleRuleset
  sch_ruleset = OpenStudio::Model::ScheduleRuleset.new(model)
  if name
    sch_ruleset.setName(options['name'])
  end

  # Winter Design Day
  winter_dsn_day = OpenStudio::Model::ScheduleDay.new(model)
  sch_ruleset.setWinterDesignDaySchedule(winter_dsn_day)
  winter_dsn_day = sch_ruleset.winterDesignDaySchedule
  winter_dsn_day.setName("#{sch_ruleset.name} Winter Design Day")
  options['winterTimeValuePairs'].each do |k, v|
    hour = k.truncate
    min = ((k - hour) * 60).to_i
    winter_dsn_day.addValue(OpenStudio::Time.new(0, hour, min, 0), v)
  end

  # Summer Design Day
  summer_dsn_day = OpenStudio::Model::ScheduleDay.new(model)
  sch_ruleset.setSummerDesignDaySchedule(summer_dsn_day)
  summer_dsn_day = sch_ruleset.summerDesignDaySchedule
  summer_dsn_day.setName("#{sch_ruleset.name} Summer Design Day")
  options['summerTimeValuePairs'].each do |k, v|
    hour = k.truncate
    min = ((k - hour) * 60).to_i
    summer_dsn_day.addValue(OpenStudio::Time.new(0, hour, min, 0), v)
  end

  # All Days
  default_day = sch_ruleset.defaultDaySchedule
  default_day.setName("#{sch_ruleset.name} Schedule Week Day")
  options['defaultTimeValuePairs'].each do |k, v|
    hour = k.truncate
    min = ((k - hour) * 60).to_i
    default_day.addValue(OpenStudio::Time.new(0, hour, min, 0), v)
  end

  result = sch_ruleset
  return result
end

.getMinMaxAnnualProfileValue(model, schedule) ⇒ Object

find the maximum profile value for a schedule

# File 'lib/openstudio/extension/core/os_lib_schedules.rb', line 61

def self.getMinMaxAnnualProfileValue(model, schedule)
  # validate schedule
  if schedule.to_ScheduleRuleset.is_initialized
    schedule = schedule.to_ScheduleRuleset.get

    # gather profiles
    profiles = []
    defaultProfile = schedule.to_ScheduleRuleset.get.defaultDaySchedule
    profiles << defaultProfile
    rules = schedule.scheduleRules
    rules.each do |rule|
      profiles << rule.daySchedule
    end

    # test profiles
    min = nil
    max = nil
    profiles.each do |profile|
      profile.values.each do |value|
        if min.nil?
          min = value
        else
          if min > value then min = value end
        end
        if max.nil?
          max = value
        else
          if max < value then max = value end
        end
      end
    end
    result = { 'min' => min, 'max' => max } # this doesn't include summer and winter design day
  else
    result = nil
  end

  return result
end

.scheduleFromRateOfChange(model, schedule) ⇒ Object

create a new schedule using absolute velocity of existing schedule

# File 'lib/openstudio/extension/core/os_lib_schedules.rb', line 387

def self.scheduleFromRateOfChange(model, schedule)
  # clone source schedule
  newSchedule = schedule.clone(model)
  newSchedule.setName("#{schedule.name} - Rate of Change")
  newSchedule = newSchedule.to_ScheduleRuleset.get

  # create array of all profiles to change. This includes summer, winter, default, and rules
  profiles = []
  profiles << newSchedule.winterDesignDaySchedule
  profiles << newSchedule.summerDesignDaySchedule
  profiles << newSchedule.defaultDaySchedule

  # time values may need
  endProfileTime = OpenStudio::Time.new(0, 24, 0, 0)
  hourBumpTime = OpenStudio::Time.new(0, 1, 0, 0)
  oneHourLeftTime = OpenStudio::Time.new(0, 23, 0, 0)

  rules = newSchedule.scheduleRules
  rules.each do |rule|
    profiles << rule.daySchedule
  end

  profiles.uniq.each do |profile|
    times = profile.times
    values = profile.values

    i = 0
    valuesIntermediate = []
    timesIntermediate = []
    until i == values.size
      if i == 0
        valuesIntermediate << 0.0
        if times[i] > hourBumpTime
          timesIntermediate << times[i] - hourBumpTime
          if times[i + 1].nil?
            timeStepValue = endProfileTime.hours + endProfileTime.minutes / 60 - times[i].hours - times[i].minutes / 60
          else
            timeStepValue = times[i + 1].hours + times[i + 1].minutes / 60 - times[i].hours - times[i].minutes / 60
          end
          valuesIntermediate << (values[i + 1].to_f - values[i].to_f).abs / (timeStepValue * 2)
        end
        timesIntermediate << times[i]
      elsif i == (values.size - 1)
        if times[times.size - 2] < oneHourLeftTime
          timesIntermediate << times[times.size - 2] + hourBumpTime # this should be the second to last time
          timeStepValue = times[i - 1].hours + times[i - 1].minutes / 60 - times[i - 2].hours - times[i - 2].minutes / 60
          valuesIntermediate << (values[i - 1].to_f - values[i - 2].to_f).abs / (timeStepValue * 2)
        end
        valuesIntermediate << 0.0
        timesIntermediate << times[i] # this should be the last time
      else
        # get value multiplier based on how many hours it is spread over
        timeStepValue = times[i].hours + times[i].minutes / 60 - times[i - 1].hours - times[i - 1].minutes / 60
        valuesIntermediate << (values[i].to_f - values[i - 1].to_f).abs / timeStepValue
        timesIntermediate << times[i]
      end
      i += 1
    end

    # delete all profile values
    profile.clearValues

    i = 0
    until i == timesIntermediate.size
      if i == (timesIntermediate.size - 1)
        profile.addValue(timesIntermediate[i], valuesIntermediate[i].to_f)
      else
        profile.addValue(timesIntermediate[i], valuesIntermediate[i].to_f)
      end
      i += 1
    end
  end

  # fix velocity so it isn't fraction change per step, but per hour (I need to count hours between times and divide value by this)

  result = newSchedule
  return result
end

.simpleScheduleValueAdjust(model, schedule, double, modificationType = 'Multiplier') ⇒ Object

find the maximum profile value for a schedule

# File 'lib/openstudio/extension/core/os_lib_schedules.rb', line 101

def self.simpleScheduleValueAdjust(model, schedule, double, modificationType = 'Multiplier') # can increase/decrease by percentage or static value
  # TODO: - add in design days, maybe as optional argument

  # give option to clone or not

  # gather profiles
  profiles = []
  defaultProfile = schedule.to_ScheduleRuleset.get.defaultDaySchedule
  profiles << defaultProfile
  rules = schedule.scheduleRules
  rules.each do |rule|
    profiles << rule.daySchedule
  end

  # alter profiles
  profiles.each do |profile|
    times = profile.times
    i = 0
    profile.values.each do |value|
      if modificationType == 'Multiplier' || modificationType == 'Percentage' # percentage was used early on but Multiplier is preferable
        profile.addValue(times[i], value * double)
      end
      if modificationType == 'Sum' || modificationType == 'Value' # value was used early on but Sum is preferable
        profile.addValue(times[i], value + double)
      end
      i += 1
    end
  end

  result = schedule
  return result
end

.timeConditionalScheduleValueAdjust(model, schedule, hhmm_before, hhmm__after, inside_double, outside_double, modificationType = 'Multiplier') ⇒ Object

change value when time passes test

# File 'lib/openstudio/extension/core/os_lib_schedules.rb', line 180

def self.timeConditionalScheduleValueAdjust(model, schedule, hhmm_before, hhmm__after, inside_double, outside_double, modificationType = 'Multiplier') # can increase/decrease by percentage or static value
  # setup variables
  array = hhmm_before.to_s.split('')
  before_hour = "#{array[0]}#{array[1]}".to_i
  before_min = "#{array[2]}#{array[3]}".to_i
  array = hhmm__after.to_s.split('')
  after_hour = "#{array[0]}#{array[1]}".to_i
  after_min = "#{array[2]}#{array[3]}".to_i

  # gather profiles
  profiles = []
  schedule = schedule.to_ScheduleRuleset.get
  defaultProfile = schedule.defaultDaySchedule
  profiles << defaultProfile
  rules = schedule.scheduleRules
  rules.each do |rule|
    profiles << rule.daySchedule
  end

  # alter profiles
  profiles.each do |day_sch|
    times = day_sch.times
    i = 0

    # set times special times needed for methods below
    before_time = OpenStudio::Time.new(0, before_hour, before_min, 0)
    after_time = OpenStudio::Time.new(0, after_hour, after_min, 0)
    # day_end_time = OpenStudio::Time.new(0, 24, 0, 0)

    # add datapoint at before and after time
    original_value_at_before_time = day_sch.getValue(before_time)
    original_value_at_after_time = day_sch.getValue(after_time)
    day_sch.addValue(before_time, original_value_at_before_time)
    day_sch.addValue(after_time, original_value_at_after_time)

    # make arrays for original times and values
    times = day_sch.times
    values = day_sch.values
    day_sch.clearValues

    # make arrays for new values
    new_times = []
    new_values = []

    # loop through original time/value pairs to populate new array
    for i in 0..(values.length - 1)
      new_times << times[i]

      if times[i] > before_time && times[i] <= after_time # updated this so times[i] == before_time goes into the else
        if inside_double.nil?
          new_values << values[i]
        elsif modificationType == 'Sum'
          new_values << inside_double + values[i]
        elsif modificationType == 'Replace'
          new_values << inside_double
        else # should be Multiplier
          new_values << inside_double * values[i]
        end
      else
        if outside_double.nil?
          new_values << values[i]
        elsif modificationType == 'Sum'
          new_values << outside_double + values[i]
        elsif modificationType == 'Replace'
          new_values << outside_double
        else # should be Multiplier
          new_values << outside_double * values[i]
        end
      end

    end

    # generate new day_sch values
    for i in 0..(new_values.length - 1)
      day_sch.addValue(new_times[i], new_values[i])
    end
  end

  result = schedule
  return result
end

.weightedMergeScheduleRulesets(model, scheduleWeighHash) ⇒ Object

merge multiple schedules into one using load or other value to weight each schedules influence on the merge

# File 'lib/openstudio/extension/core/os_lib_schedules.rb', line 263

def self.weightedMergeScheduleRulesets(model, scheduleWeighHash)
  # WARNING NOT READY FOR GENERAL USE YET - this doesn't do anything with rules yet, just winter, summer, and default profile

  # get denominator for weight
  denominator = 0
  scheduleWeighHash.each do |schedule, weight|
    denominator += weight
  end

  # create new schedule
  sch_ruleset = OpenStudio::Model::ScheduleRuleset.new(model)
  sch_ruleset.setName('Merged Schedule') # TODO: - make this optional user argument

  # create winter design day profile
  winter_dsn_day = OpenStudio::Model::ScheduleDay.new(model)
  sch_ruleset.setWinterDesignDaySchedule(winter_dsn_day)
  winter_dsn_day = sch_ruleset.winterDesignDaySchedule
  winter_dsn_day.setName("#{sch_ruleset.name} Winter Design Day")

  # create  summer design day profile
  summer_dsn_day = OpenStudio::Model::ScheduleDay.new(model)
  sch_ruleset.setSummerDesignDaySchedule(summer_dsn_day)
  summer_dsn_day = sch_ruleset.summerDesignDaySchedule
  summer_dsn_day.setName("#{sch_ruleset.name} Summer Design Day")

  # create default profile
  default_day = sch_ruleset.defaultDaySchedule
  default_day.setName("#{sch_ruleset.name} Schedule Week Day")

  # hash of schedule rules
  rulesHash = {} # mon, tue, wed, thur, fri, sat, sun, startDate, endDate
  # to avoid stacking order issues across schedules, I may need to make a rule for each day of the week for each date range

  scheduleWeighHash.each do |schedule, weight|
    # populate winter design day profile
    oldWinterProfile = schedule.to_ScheduleRuleset.get.winterDesignDaySchedule
    times_final = summer_dsn_day.times
    i = 0
    valueUpdatedArray = []
    # loop through times already in profile and update values
    until i > times_final.size - 1
      value = oldWinterProfile.getValue(times_final[i]) * weight / denominator
      starting_value = winter_dsn_day.getValue(times_final[i])
      winter_dsn_day.addValue(times_final[i], value + starting_value)
      valueUpdatedArray << times_final[i]
      i += 1
    end
    # loop through any new times unique to the current old profile to be merged
    j = 0
    times = oldWinterProfile.times
    values = oldWinterProfile.values
    until j > times.size - 1
      unless valueUpdatedArray.include? times[j]
        value = values[j] * weight / denominator
        starting_value = winter_dsn_day.getValue(times[j])
        winter_dsn_day.addValue(times[j], value + starting_value)
      end
      j += 1
    end

    # populate summer design day profile
    oldSummerProfile = schedule.to_ScheduleRuleset.get.summerDesignDaySchedule
    times_final = summer_dsn_day.times
    i = 0
    valueUpdatedArray = []
    # loop through times already in profile and update values
    until i > times_final.size - 1
      value = oldSummerProfile.getValue(times_final[i]) * weight / denominator
      starting_value = summer_dsn_day.getValue(times_final[i])
      summer_dsn_day.addValue(times_final[i], value + starting_value)
      valueUpdatedArray << times_final[i]
      i += 1
    end
    # loop through any new times unique to the current old profile to be merged
    j = 0
    times = oldSummerProfile.times
    values = oldSummerProfile.values
    until j > times.size - 1
      unless valueUpdatedArray.include? times[j]
        value = values[j] * weight / denominator
        starting_value = summer_dsn_day.getValue(times[j])
        summer_dsn_day.addValue(times[j], value + starting_value)
      end
      j += 1
    end

    # populate default profile
    oldDefaultProfile = schedule.to_ScheduleRuleset.get.defaultDaySchedule
    times_final = default_day.times
    i = 0
    valueUpdatedArray = []
    # loop through times already in profile and update values
    until i > times_final.size - 1
      value = oldDefaultProfile.getValue(times_final[i]) * weight / denominator
      starting_value = default_day.getValue(times_final[i])
      default_day.addValue(times_final[i], value + starting_value)
      valueUpdatedArray << times_final[i]
      i += 1
    end
    # loop through any new times unique to the current old profile to be merged
    j = 0
    times = oldDefaultProfile.times
    values = oldDefaultProfile.values
    until j > times.size - 1
      unless valueUpdatedArray.include? times[j]
        value = values[j] * weight / denominator
        starting_value = default_day.getValue(times[j])
        default_day.addValue(times[j], value + starting_value)
      end
      j += 1
    end

    # create rules

    # gather data for rule profiles

    # populate rule profiles
  end

  result = { 'mergedSchedule' => sch_ruleset, 'denominator' => denominator }
  return result
end