Module: OpenstudioStandards::Schedules

Defined in:
lib/openstudio-standards/schedules/create.rb,
lib/openstudio-standards/schedules/modify.rb,
lib/openstudio-standards/schedules/information.rb

Create collapse

Modify collapse

Information collapse

Class Method Details

.create_complex_schedule(model, options = {}) ⇒ OpenStudio::Model::ScheduleRuleset

create a ruleset schedule with a complex profile

Parameters:

  • model (OpenStudio::Model::Model) —

    OpenStudio model object

  • options (Hash) (defaults to: {}) —

    Hash of name and time value pairs

Returns:

  • (OpenStudio::Model::ScheduleRuleset) —

    OpenStudio ruleset schedule object



67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
 
# File 'lib/openstudio-standards/schedules/create.rb', line 67

def self.create_complex_schedule(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

  return sch_ruleset
end

.create_schedule_from_rate_of_change(model, schedule_ruleset) ⇒ OpenStudio::Model::ScheduleRuleset

TODO:

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)

create a new schedule using absolute velocity of existing schedule

Parameters:

  • model (OpenStudio::Model::Model) —

    OpenStudio model object

  • schedule_ruleset (OpenStudio::Model::ScheduleRuleset) —

    OpenStudio ruleset schedule object

Returns:

  • (OpenStudio::Model::ScheduleRuleset) —

    OpenStudio ScheduleRuleset object



160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
 
# File 'lib/openstudio-standards/schedules/create.rb', line 160

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

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

  # time values may need
  end_profile_time = OpenStudio::Time.new(0, 24, 0, 0)
  hour_bump_time = OpenStudio::Time.new(0, 1, 0, 0)
  one_hour_left_time = OpenStudio::Time.new(0, 23, 0, 0)

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

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

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

    # delete all profile values
    profile.clearValues

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

  return new_schedule
end

.create_simple_schedule(model, options = {}) ⇒ OpenStudio::Model::ScheduleRuleset

create a ruleset schedule with a basic profile

Parameters:

  • model (OpenStudio::Model::Model) —

    OpenStudio model object

  • options (Hash) (defaults to: {}) —

    Hash of name and time value pairs

Returns:

  • (OpenStudio::Model::ScheduleRuleset) —

    OpenStudio ScheduleRuleset object



11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
 
# File 'lib/openstudio-standards/schedules/create.rb', line 11

def self.create_simple_schedule(model, options = {})
  defaults = {
    'name' => nil,
    'winter_time_value_pairs' => { 24.0 => 0.0 },
    'summer_time_value_pairs' => { 24.0 => 1.0 },
    'default_time_value_pairs' => { 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['winter_time_value_pairs'].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['summer_time_value_pairs'].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['default_time_value_pairs'].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

  return sch_ruleset
end

.create_weighted_merge_schedules(model, schedule_weights_hash, sch_name: 'Merged Schedule') ⇒ Hash

TODO:

apply weights to schedule rules as well, not just winter, summer, and default profile

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

Parameters:

  • model (OpenStudio::Model::Model) —

    OpenStudio model object

  • schedule_weights_hash (Hash) —

    Hash of OpenStudio::Model::ScheduleRuleset, Double

  • sch_name (String) (defaults to: 'Merged Schedule') —

    Optional name of new schedule

Returns:

  • (Hash) —

    Hash of merged schedule and the total denominator



243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
 
# File 'lib/openstudio-standards/schedules/create.rb', line 243

def self.create_weighted_merge_schedules(model, schedule_weights_hash, sch_name: 'Merged Schedule')
  # get denominator for weight
  denominator = 0.0
  schedule_weights_hash.each do |schedule, weight|
    denominator += weight
  end

  # create new schedule
  sch_ruleset = OpenStudio::Model::ScheduleRuleset.new(model)
  sch_ruleset.setName(sch_name)

  # 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
  rules_hash = {} # 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

  schedule_weights_hash.each do |schedule, weight|
    # populate winter design day profile
    old_winter_profile = schedule.to_ScheduleRuleset.get.winterDesignDaySchedule
    times_final = summer_dsn_day.times
    i = 0
    value_updated_array = []
    # loop through times already in profile and update values
    until i > times_final.size - 1
      value = old_winter_profile.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)
      value_updated_array << times_final[i]
      i += 1
    end
    # loop through any new times unique to the current old profile to be merged
    j = 0
    times = old_winter_profile.times
    values = old_winter_profile.values
    until j > times.size - 1
      unless value_updated_array.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
    old_summer_profile = schedule.to_ScheduleRuleset.get.summerDesignDaySchedule
    times_final = summer_dsn_day.times
    i = 0
    value_updated_array = []
    # loop through times already in profile and update values
    until i > times_final.size - 1
      value = old_summer_profile.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)
      value_updated_array << times_final[i]
      i += 1
    end
    # loop through any new times unique to the current old profile to be merged
    j = 0
    times = old_summer_profile.times
    values = old_summer_profile.values
    until j > times.size - 1
      unless value_updated_array.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
    old_default_profile = schedule.to_ScheduleRuleset.get.defaultDaySchedule
    times_final = default_day.times
    i = 0
    value_updated_array = []
    # loop through times already in profile and update values
    until i > times_final.size - 1
      value = old_default_profile.getValue(times_final[i]) * weight / denominator
      starting_value = default_day.getValue(times_final[i])
      default_day.addValue(times_final[i], value + starting_value)
      value_updated_array << times_final[i]
      i += 1
    end
    # loop through any new times unique to the current old profile to be merged
    j = 0
    times = old_default_profile.times
    values = old_default_profile.values
    until j > times.size - 1
      unless value_updated_array.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

.schedule_ruleset_adjust_hours_of_operation(schedule_ruleset, options = {}) ⇒ OpenStudio::Model::ScheduleRuleset

Adjust hours of operation

Parameters:

  • schedule_ruleset (OpenStudio::Model::ScheduleRuleset) —

    OpenStudio ScheduleRuleset object

  • options (Hash) (defaults to: {}) —

    Hash of argument options

Returns:

  • (OpenStudio::Model::ScheduleRuleset) —

    OpenStudio ScheduleRuleset object



197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
 
# File 'lib/openstudio-standards/schedules/modify.rb', line 197

def self.schedule_ruleset_adjust_hours_of_operation(schedule_ruleset, 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_ruleset.to_ScheduleRuleset.is_initialized
    schedule = schedule_ruleset.to_ScheduleRuleset.get
  else
    OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.Schedules.Modify', "schedule_ruleset_adjust_hours_of_operation only applies to ScheduleRuleset objects. 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
  OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.Schedules.Modify', "Adjusting #{schedule.name}")

  # rename schedule
  schedule.setName("#{schedule.name} - extend #{options['delta_length_hoo']} shift #{options['shift_hoo']}")

  # 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
    OpenStudio.logFree(OpenStudio::Error, 'openstudio.standards.Schedules.Modify', '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
    OpenStudio.logFree(OpenStudio::Error, 'openstudio.standards.Schedules.Modify', '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
        OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.Schedules.Modify', "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

.schedule_ruleset_conditional_adjust_value(schedule_ruleset, test_value, pass_value, fail_value, floor_value, modification_type = 'Multiplier') ⇒ OpenStudio::Model::ScheduleRuleset

TODO:

add in design day adjustments, maybe as an optional argument

TODO:

provide option to clone existing schedule

Increase/decrease by percentage or static value change value when value passes/fails test

Parameters:

  • schedule_ruleset (OpenStudio::Model::ScheduleRuleset) —

    OpenStudio ScheduleRuleset object

  • test_value (Double) —

    if less than the test_value, use the pass_value to modify, otherwise use the fail_value

  • pass_value (Double) —

    value to adjust by if less than test value

  • fail_value (Double) —

    value to adjust by if more than test value

  • floor_value (Double) —

    minimum value that the adjustment can take

  • modification_type (String) (defaults to: 'Multiplier') —

    Options are ‘Multiplier’, which multiples by the value, and ‘Sum’ which adds by the value

Returns:

  • (OpenStudio::Model::ScheduleRuleset) —

    OpenStudio ScheduleRuleset object



58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
 
# File 'lib/openstudio-standards/schedules/modify.rb', line 58

def self.schedule_ruleset_conditional_adjust_value(schedule_ruleset, test_value, pass_value, fail_value, floor_value, modification_type = 'Multiplier')
  # gather profiles
  profiles = []
  default_profile = schedule_ruleset.to_ScheduleRuleset.get.defaultDaySchedule
  profiles << default_profile
  rules = schedule_ruleset.scheduleRules
  rules.each do |rule|
    profiles << rule.daySchedule
  end

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

    profile.values.each do |sch_value|
      # run test on this sch_value
      if sch_value < test_value
        adjust_value = pass_value
      else
        adjust_value = fail_value
      end

      # skip if sch_value is floor or less
      next if sch_value <= floor_value

      case modification_type
      when 'Multiplier'
        # take the max of the floor or resulting value
        profile.addValue(times[i], [sch_value * adjust_value, floor_value].max)
      when 'Sum'
        # take the max of the floor or resulting value
        profile.addValue(times[i], [sch_value + adjust_value, floor_value].max)
      end
      i += 1
    end
  end

  return schedule_ruleset
end

.schedule_ruleset_get_min_max(schedule_ruleset) ⇒ Hash

returns the ScheduleRuleset minimum and maximum values

Parameters:

  • schedule_ruleset (OpenStudio::Model::ScheduleRuleset) —

    OpenStudio ScheduleRuleset object

Returns:

  • (Hash) —

    returns as hash with ‘min’ and ‘max’ values



13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
 
# File 'lib/openstudio-standards/schedules/information.rb', line 13

def self.schedule_ruleset_get_min_max(schedule_ruleset)
  # validate schedule
  if schedule_ruleset.to_ScheduleRuleset.is_initialized
    schedule = schedule_ruleset.to_ScheduleRuleset.get

    # gather profiles
    profiles = []
    profiles << schedule.defaultDaySchedule
    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

.schedule_ruleset_get_start_and_end_times(schedule_ruleset) ⇒ Hash<OpenStudio:Time>

Determine the hour when the schedule first exceeds the starting value and when it goes back down to the ending value at the end of the day. This method only works for ScheduleRuleset schedules.

Parameters:

  • schedule_ruleset (OpenStudio::Model::ScheduleRuleset) —

    OpenStudio ScheduleRuleset object

Returns:

  • (Hash<OpenStudio:Time>) —

    returns as hash with ‘start_time’, ‘end time’]



81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
 
# File 'lib/openstudio-standards/schedules/information.rb', line 81

def self.schedule_ruleset_get_start_and_end_times(schedule_ruleset)
  # Ensure that this is a ScheduleRuleset
  schedule_ruleset = schedule_ruleset.to_ScheduleRuleset
  return [nil, nil] if schedule_ruleset.empty?

  schedule_ruleset = schedule_ruleset.get

  # Define the start and end date
  if schedule_ruleset.model.yearDescription.is_initialized
    year_description = schedule_ruleset.model.yearDescription.get
    year = year_description.assumedYear
    year_start_date = OpenStudio::Date.new(OpenStudio::MonthOfYear.new('January'), 1, year)
    year_end_date = OpenStudio::Date.new(OpenStudio::MonthOfYear.new('December'), 31, year)
  else
    year_start_date = OpenStudio::Date.new(OpenStudio::MonthOfYear.new('January'), 1, 2009)
    year_end_date = OpenStudio::Date.new(OpenStudio::MonthOfYear.new('December'), 31, 2009)
  end

  # Get the ordered list of all the day schedules that are used by this schedule ruleset
  day_schs = schedule_ruleset.getDaySchedules(year_start_date, year_end_date)

  # Get a 365-value array of which schedule is used on each day of the year,
  day_schs_used_each_day = schedule_ruleset.getActiveRuleIndices(year_start_date, year_end_date)

  # Create a map that shows how many days each schedule is used
  day_sch_freq = day_schs_used_each_day.group_by { |n| n }
  day_sch_freq = day_sch_freq.sort_by { |freq| freq[1].size }
  common_day_freq = day_sch_freq.last

  # Build a hash that maps schedule day index to schedule day
  schedule_index_to_day = {}
  day_schs.each_with_index do |day_sch, i|
    schedule_index_to_day[day_schs_used_each_day[i]] = day_sch
  end

  # Get the most common day schedule
  sch_index = common_day_freq[0]
  number_of_days_sch_used = common_day_freq[1].size

  # Get the day schedule at this index
  day_sch = if sch_index == -1 # If index = -1, this day uses the default day schedule (not a rule)
              schedule_ruleset.defaultDaySchedule
            else
              schedule_index_to_day[sch_index]
            end

  # Determine the full load hours for just one day
  values = []
  times = []
  day_sch.times.each_with_index do |time, i|
    times << day_sch.times[i]
    values << day_sch.values[i]
  end

  # Get the minimum value
  start_val = values.first
  end_val = values.last

  # Get the start time (first time value goes above minimum)
  start_time = nil
  values.each_with_index do |val, i|
    break if i == values.size - 1 # Stop if we reach end of array

    if val == start_val && values[i + 1] > start_val
      start_time = times[i]
      break
    end
  end

  # Get the end time (first time value goes back down to minimum)
  end_time = nil
  values.each_with_index do |val, i|
    if i < values.size - 1
      if val > end_val && values[i + 1] == end_val
        end_time = times[i]
        break
      end
    else
      if val > end_val && values[0] == start_val # Check first hour of day for schedules that end at midnight
        end_time = OpenStudio::Time.new(0, 24, 0, 0)
        break
      end
    end
  end

  return { 'start_time' => start_time, 'end_time' => end_time }
end

.schedule_ruleset_get_timeseries(schedule_ruleset) ⇒ OpenStudio::TimeSeries

create OpenStudio TimeSeries object from ScheduleRuleset values

Parameters:

  • schedule_ruleset (OpenStudio::Model::ScheduleRuleset) —

    OpenStudio ScheduleRuleset object

Returns:

  • (OpenStudio::TimeSeries) —

    OpenStudio TimeSeries object of schedule values



55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
 
# File 'lib/openstudio-standards/schedules/information.rb', line 55

def self.schedule_ruleset_get_timeseries(schedule_ruleset)
  yd = schedule_ruleset.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
  timeseries = OpenStudio::TimeSeries.new(start_date, interval, OpenStudio.createVector(values), '')
  return timeseries
end

.schedule_ruleset_simple_value_adjust(schedule_ruleset, value, modification_type = 'Multiplier') ⇒ OpenStudio::Model::ScheduleRuleset

TODO:

add in design day adjustments, maybe as an optional argument

TODO:

provide option to clone existing schedule

Increase/decrease by percentage or static value

Parameters:

  • schedule_ruleset (OpenStudio::Model::ScheduleRuleset) —

    OpenStudio ScheduleRuleset object

  • value (Double) —

    Hash of name and time value pairs

  • modification_type (String) (defaults to: 'Multiplier') —

    Options are ‘Multiplier’, which multiples by the value, and ‘Sum’ which adds by the value

Returns:

  • (OpenStudio::Model::ScheduleRuleset) —

    OpenStudio ScheduleRuleset object



15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
 
# File 'lib/openstudio-standards/schedules/modify.rb', line 15

def self.schedule_ruleset_simple_value_adjust(schedule_ruleset, value, modification_type = 'Multiplier')
  # gather profiles
  profiles = []
  default_profile = schedule_ruleset.to_ScheduleRuleset.get.defaultDaySchedule
  profiles << default_profile
  rules = schedule_ruleset.scheduleRules
  rules.each do |rule|
    profiles << rule.daySchedule
  end

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

  return schedule_ruleset
end

.schedule_ruleset_time_conditional_adjust_value(schedule_ruleset, hhmm_before, hhmm_after, inside_value, outside_value, modification_type = 'Sum') ⇒ OpenStudio::Model::ScheduleRuleset

Increase/decrease by percentage or static value change value when time passes test

Parameters:

  • schedule_ruleset (OpenStudio::Model::ScheduleRuleset) —

    OpenStudio ScheduleRuleset object

  • hhmm_before (String) —

    time before string in hhmm format, e.g. 1530

  • hhmm_after (String) —

    string in hhmm format, e.g. 1530

  • inside_value (Double)
  • outside_value (Double)
  • modification_type (String) (defaults to: 'Sum') —

    Options are ‘Sum’, which adds to the value, and ‘Replace’ which replaces the value

Returns:

  • (OpenStudio::Model::ScheduleRuleset) —

    OpenStudio ScheduleRuleset object



110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
 
# File 'lib/openstudio-standards/schedules/modify.rb', line 110

def self.schedule_ruleset_time_conditional_adjust_value(schedule_ruleset, hhmm_before, hhmm_after, inside_value, outside_value, modification_type = 'Sum')
  # 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_ruleset.to_ScheduleRuleset.get
  default_profile = schedule_ruleset.defaultDaySchedule
  profiles << default_profile
  rules = schedule_ruleset.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
    sch_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..(sch_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_value.nil?
          new_values << sch_values[i]
        elsif modification_type == 'Sum'
          new_values << inside_value + sch_values[i]
        elsif modification_type == 'Replace'
          new_values << inside_value
        else # should be Multiplier
          new_values << inside_value * sch_values[i]
        end
      else
        if outside_value.nil?
          new_values << sch_values[i]
        elsif modification_type == 'Sum'
          new_values << outside_value + sch_values[i]
        elsif modification_type == 'Replace'
          new_values << outside_value
        else # should be Multiplier
          new_values << outside_value * sch_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

  return schedule_ruleset
end