Class: Honeybee::ScheduleRulesetAbridged

Inherits:
ModelObject show all
Defined in:
lib/honeybee/schedule/ruleset.rb,
lib/to_openstudio/schedule/ruleset.rb,
lib/from_openstudio/schedule/ruleset.rb

Instance Attribute Summary

Attributes inherited from ModelObject

#errors, #openstudio_object, #warnings

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from ModelObject

#allowable_types, clean_identifier, clean_name, #initialize, #method_missing, read_from_disk, truncate

Constructor Details

This class inherits a constructor from Honeybee::ModelObject

Dynamic Method Handling

This class handles dynamic methods through the method_missing method in the class Honeybee::ModelObject

Class Method Details

.from_day_schedule(day_schedule) ⇒ Object 



102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
 
# File 'lib/from_openstudio/schedule/ruleset.rb', line 102

def self.from_day_schedule(day_schedule)
  hash = {}
  hash[:type] = 'ScheduleDay'
  hash[:identifier] = clean_name(day_schedule.nameString)
  hash[:interpolate] = day_schedule.interpolatetoTimestep
  hash[:values] = day_schedule.values
  time_until = [[0,0]]
  day_schedule.times.each do |time|
    time_until << [time.hours, time.minutes]
  end
  time_until.delete_at(-1)
  hash[:times] = time_until

  hash
end

.from_schedule_rule(schedule_rule) ⇒ Object 



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
 
# File 'lib/from_openstudio/schedule/ruleset.rb', line 118

def self.from_schedule_rule(schedule_rule)
  hash = {}
  hash[:type] = 'ScheduleRuleAbridged'
  hash[:schedule_day] = clean_name(schedule_rule.daySchedule.nameString)
  hash[:apply_sunday] = schedule_rule.applySunday
  hash[:apply_monday] = schedule_rule.applyMonday
  hash[:apply_tuesday] = schedule_rule.applyTuesday
  hash[:apply_wednesday] = schedule_rule.applyWednesday
  hash[:apply_thursday] = schedule_rule.applyThursday
  hash[:apply_friday] = schedule_rule.applyFriday
  hash[:apply_saturday] = schedule_rule.applySaturday
  
  #boost optional
  unless schedule_rule.startDate.empty?
    start_date = schedule_rule.startDate.get       
    hash[:start_date] = [(start_date.monthOfYear).value, start_date.dayOfMonth]
    if start_date.isLeapYear
      hash[:start_date] << 1
    end
  end

  #boost optional
  unless schedule_rule.endDate.empty?
    end_date = schedule_rule.endDate.get
    hash[:end_date] = [(end_date.monthOfYear).value, end_date.dayOfMonth]
    if start_date.isLeapYear
      hash[:end_date] << 1
    end
  end

  hash
end

.from_schedule_ruleset(schedule_ruleset) ⇒ Object 



38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
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
98
99
100
 
# File 'lib/from_openstudio/schedule/ruleset.rb', line 38

def self.from_schedule_ruleset(schedule_ruleset)
  # create an empty hash
  hash = {}
  hash[:type] = 'ScheduleRulesetAbridged'
  # set the primary (required) day schedules of the object
  hash[:identifier] = clean_name(schedule_ruleset.nameString)
  unless schedule_ruleset.displayName.empty?
    hash[:display_name] = (schedule_ruleset.displayName.get).force_encoding("UTF-8")
  end
  hash[:default_day_schedule] = clean_name(schedule_ruleset.defaultDaySchedule.nameString)
  hash[:summer_designday_schedule] = clean_name(schedule_ruleset.summerDesignDaySchedule.nameString)
  hash[:winter_designday_schedule] = clean_name(schedule_ruleset.winterDesignDaySchedule.nameString)
  hash[:holiday_schedule] = clean_name(schedule_ruleset.holidaySchedule.nameString)

  # create a list of all day schedules referenced in the Ruleset
  schedule_days, day_ids = [], []
  required_days = [
    schedule_ruleset.defaultDaySchedule,
    schedule_ruleset.summerDesignDaySchedule,
    schedule_ruleset.winterDesignDaySchedule,
    schedule_ruleset.holidaySchedule
  ]
  required_days.each do |day_sch|
    unless day_ids.include? day_sch.nameString
      schedule_days << day_sch
      day_ids << day_sch.nameString
    end
  end

  # loop through the rules and add them along with their day schedules
  hash[:schedule_rules] = []
  schedule_ruleset.scheduleRules.each do |schedule_rule|
    hash[:schedule_rules] << ScheduleRulesetAbridged.from_schedule_rule(schedule_rule)
    day_sch = schedule_rule.daySchedule
    unless day_ids.include? day_sch.nameString
      schedule_days << day_sch
      day_ids << day_sch.nameString
    end
  end

  # write all of the day schedule specifications into the hash
  hash[:day_schedules] = []
  schedule_days.each do |schedule_day|
    hash[:day_schedules] << ScheduleRulesetAbridged.from_day_schedule(schedule_day)
  end

  # remove the bogus default day schedule that OpenStudio adds upon import from IDF
  if hash[:default_day_schedule].start_with?('Schedule Day ')
    if hash[:day_schedules][0][:values] == [0] && hash[:schedule_rules].length() > 0
      hash[:default_day_schedule] = hash[:schedule_rules][0][:schedule_day]
      hash[:schedule_rules].pop(0)
      hash[:day_schedules].pop(0)
    end
  end

  # assing any schedule type limits if they exist
  unless schedule_ruleset.scheduleTypeLimits.empty?
    typ_lim = schedule_ruleset.scheduleTypeLimits.get
    hash[:schedule_type_limit] = clean_name(typ_lim.nameString)
  end

  hash
end

Instance Method Details

#defaults ⇒ Object 



37
38
39
 
# File 'lib/honeybee/schedule/ruleset.rb', line 37

def defaults
  @@schema[:components][:schemas][:ScheduleRulesetAbridged][:properties]
end

#find_existing_openstudio_object(openstudio_model) ⇒ Object 



39
40
41
42
43
 
# File 'lib/to_openstudio/schedule/ruleset.rb', line 39

def find_existing_openstudio_object(openstudio_model)
  object = openstudio_model.getScheduleRulesetByName(@hash[:identifier])
  return object.get if object.is_initialized
  nil
end

#to_openstudio(openstudio_model, schedule_csv_dir = nil, include_datetimes = nil, schedule_csvs = nil) ⇒ Object 



45
46
47
48
49
50
51
52
53
54
55
56
57
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
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
168
169
170
171
 
# File 'lib/to_openstudio/schedule/ruleset.rb', line 45

def to_openstudio(openstudio_model, schedule_csv_dir = nil, include_datetimes = nil, schedule_csvs = nil)

  # create openstudio schedule ruleset object
  os_sch_ruleset = OpenStudio::Model::ScheduleRuleset.new(openstudio_model)
  os_sch_ruleset.setName(@hash[:identifier])
  unless @hash[:display_name].nil?
    os_sch_ruleset.setDisplayName(@hash[:display_name])
  end
  # assign schedule type limit
  sch_type_limit_obj = nil
  if @hash[:schedule_type_limit]
    schedule_type_limit = openstudio_model.getScheduleTypeLimitsByName(@hash[:schedule_type_limit])
    unless schedule_type_limit.empty?
      sch_type_limit_obj = schedule_type_limit.get
      os_sch_ruleset.setScheduleTypeLimits(sch_type_limit_obj)
    end
  end

  # loop through day schedules and create openstudio schedule day object
  day_schs = Hash.new
  def_day_id = @hash[:default_day_schedule]
  def_day_hash = nil
  @hash[:day_schedules].each do |day_schedule|
    if day_schedule[:identifier] != def_day_id
      day_schedule_new = OpenStudio::Model::ScheduleDay.new(openstudio_model)
      exist_sch = openstudio_model.getScheduleDayByName(day_schedule[:identifier])
      if exist_sch.empty?  # make sure we don't overwrite an existing schedule day
        day_schedule_new.setName(day_schedule[:identifier])
      end
      unless @hash[:display_name].nil?
        day_schedule_new.setDisplayName(@hash[:display_name])
      end
      unless sch_type_limit_obj.nil?
        day_schedule_new.setScheduleTypeLimits(sch_type_limit_obj)
      end
      values_day_new = day_schedule[:values]
      times_day_new = day_schedule[:times]
      times_day_new.delete_at(0)  # Remove [0, 0] from array at index 0.
      times_day_new.push([24, 0])  # Add [24, 0] at index 0
      values_day_new.each_index do |i|
        time_until = OpenStudio::Time.new(0, times_day_new[i][0], times_day_new[i][1], 0)
        day_schedule_new.addValue(time_until, values_day_new[i])
      end
      day_schs[day_schedule[:identifier]] = day_schedule_new
    else
      def_day_hash = day_schedule
    end
  end

  # assign default day schedule
  def_day_sch = os_sch_ruleset.defaultDaySchedule
  exist_sch = openstudio_model.getScheduleDayByName(def_day_id)
  if exist_sch.empty?  # make sure we don't overwrite an existing schedule day
    def_day_sch.setName(def_day_id)
  end
  unless sch_type_limit_obj.nil?
    def_day_sch.setScheduleTypeLimits(sch_type_limit_obj)
  end
  values_day_new = def_day_hash[:values]
  times_day_new = def_day_hash[:times]
  times_day_new.delete_at(0)  # Remove [0, 0] from array at index 0.
  times_day_new.push([24, 0])  # Add [24, 0] at index 0
  values_day_new.each_index do |i|
    time_until = OpenStudio::Time.new(0, times_day_new[i][0], times_day_new[i][1], 0)
    def_day_sch.addValue(time_until, values_day_new[i])
  end
  day_schs[def_day_id] = def_day_sch

  # assign holiday schedule
  if @hash[:holiday_schedule]
    holiday_schedule = day_schs[@hash[:holiday_schedule]]
    unless holiday_schedule.nil?
      os_sch_ruleset.setHolidaySchedule(holiday_schedule)
    end
  end

  # assign summer design day schedule
  if @hash[:summer_designday_schedule]
    summer_design_day = day_schs[@hash[:summer_designday_schedule]]
    unless summer_design_day.nil?
      os_sch_ruleset.setSummerDesignDaySchedule(summer_design_day)
    end
  end

  # assign winter design day schedule
  if @hash[:winter_designday_schedule]
    winter_design_day = day_schs[@hash[:winter_designday_schedule]]
    unless winter_design_day.nil?
      os_sch_ruleset.setWinterDesignDaySchedule(winter_design_day)
    end
  end

  # assign schedule rules
  if @hash[:schedule_rules]
    @hash[:schedule_rules].each do |rule|
      openstudio_schedule_rule = OpenStudio::Model::ScheduleRule.new(os_sch_ruleset)
      openstudio_schedule_rule.setApplySunday(rule[:apply_sunday])
      openstudio_schedule_rule.setApplyMonday(rule[:apply_monday])
      openstudio_schedule_rule.setApplyTuesday(rule[:apply_tuesday])
      openstudio_schedule_rule.setApplyWednesday(rule[:apply_wednesday])
      openstudio_schedule_rule.setApplyThursday(rule[:apply_thursday])
      openstudio_schedule_rule.setApplyFriday(rule[:apply_friday])
      openstudio_schedule_rule.setApplySaturday(rule[:apply_saturday])
      year_description = openstudio_model.getYearDescription
      start_date = year_description.makeDate(rule[:start_date][0], rule[:start_date][1])
      end_date = year_description.makeDate(rule[:end_date][0], rule[:end_date][1])
      openstudio_schedule_rule.setStartDate(start_date)
      openstudio_schedule_rule.setEndDate(end_date)

      schedule_rule_day = day_schs[rule[:schedule_day]]
      unless schedule_rule_day.nil?
        values_day = schedule_rule_day.values
        times_day = schedule_rule_day.times

        values_day.each_index do |i|
          openstudio_schedule_rule.daySchedule.addValue(times_day[i], values_day[i])
        end
      end

      #set schedule rule index
      index = @hash[:schedule_rules].find_index(rule)
      os_sch_ruleset.setScheduleRuleIndex(openstudio_schedule_rule, index)
    end
  end

  os_sch_ruleset
end