honeybee-openstudio 2.10.4 → 2.12.0

data/lib/to_openstudio/hvac/template.rb

@@ -35,6 +35,14 @@ require 'to_openstudio/model_object'
 
 module Honeybee
   class TemplateHVAC
+    @@vintage_mapper = {
+      DOE_Ref_Pre_1980: 'DOE Ref Pre-1980',
+      DOE_Ref_1980_2004: 'DOE Ref 1980-2004',
+      ASHRAE_2004: '90.1-2004',
+      ASHRAE_2007: '90.1-2007',
+      ASHRAE_2010: '90.1-2010',
+      ASHRAE_2013: '90.1-2013'
+    }
 
     def to_openstudio(openstudio_model, room_ids)
 
@@ -47,9 +55,9 @@ module Honeybee
 
       # make the standard applier
       if @hash[:vintage]
-        standard = Standard.build(@hash[:vintage])
+        standard = Standard.build(@@vintage_mapper[@hash[:vintage].to_sym])
       else
-        standard = Standard.build(hvac_defaults[:vintage][:default])
+        standard = Standard.build(@@vintage_mapper[hvac_defaults[:vintage][:default].to_sym])
       end
 
       # get the default equipment type

data/lib/to_openstudio/load/daylight.rb

@@ -0,0 +1,100 @@
+# *******************************************************************************
+# Honeybee OpenStudio Gem, Copyright (c) 2020, Alliance for Sustainable
+# Energy, LLC, Ladybug Tools LLC and other contributors. All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# (1) Redistributions of source code must retain the above copyright notice,
+# this list of conditions and the following disclaimer.
+#
+# (2) Redistributions in binary form must reproduce the above copyright notice,
+# this list of conditions and the following disclaimer in the documentation
+# and/or other materials provided with the distribution.
+#
+# (3) Neither the name of the copyright holder nor the names of any contributors
+# may be used to endorse or promote products derived from this software without
+# specific prior written permission from the respective party.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) AND ANY CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S), ANY CONTRIBUTORS, THE
+# UNITED STATES GOVERNMENT, OR THE UNITED STATES DEPARTMENT OF ENERGY, NOR ANY OF
+# THEIR EMPLOYEES, BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+# OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+# STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+# OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+# *******************************************************************************
+
+require 'honeybee/load/daylight'
+
+require 'to_openstudio/model_object'
+
+module Honeybee
+  class DaylightingControl
+
+    def find_existing_openstudio_object(openstudio_model, parent_space_name)
+      dl_cntrl_name = parent_space_name + '_Daylighting'
+      model_dl_cntrl = openstudio_model.getDaylightingControlByName(dl_cntrl_name)
+      return model_dl_cntrl.get unless model_dl_cntrl.empty?
+      nil
+    end
+
+    def to_openstudio(openstudio_model, parent_zone, parent_space)
+      # create daylighting control openstudio object and set identifier
+      os_dl_control = OpenStudio::Model::DaylightingControl.new(openstudio_model)
+      space_name = parent_space.name
+      unless space_name.empty?
+        os_dl_control.setName(parent_space.name.get + '_Daylighting')
+      end
+      os_dl_control.setSpace(parent_space)
+      parent_zone.setPrimaryDaylightingControl(os_dl_control)
+
+      # assign the position of the sensor point
+      os_dl_control.setPositionXCoordinate(@hash[:sensor_position][0])
+      os_dl_control.setPositionYCoordinate(@hash[:sensor_position][1])
+      os_dl_control.setPositionZCoordinate(@hash[:sensor_position][2])
+
+      # assign the illuminance setpoint if it exists
+      if @hash[:illuminance_setpoint]
+        os_dl_control.setIlluminanceSetpoint(@hash[:illuminance_setpoint])
+      else
+        os_dl_control.setIlluminanceSetpoint(defaults[:illuminance_setpoint][:default])
+      end
+
+      # assign power fraction if it exists
+      if @hash[:min_power_input]
+        os_dl_control.setMinimumInputPowerFractionforContinuousDimmingControl(@hash[:min_power_input])
+      else
+        os_dl_control.setMinimumInputPowerFractionforContinuousDimmingControl(defaults[:min_power_input][:default])
+      end
+
+      # assign light output fraction if it exists
+      if @hash[:min_power_input]
+        os_dl_control.setMinimumLightOutputFractionforContinuousDimmingControl(@hash[:min_light_output])
+      else
+        os_dl_control.setMinimumLightOutputFractionforContinuousDimmingControl(defaults[:min_light_output][:default])
+      end
+
+      # set whether the lights go off when they reach their minimum
+      if @hash[:off_at_minimum]
+        os_dl_control.setLightingControlType('Continuous/Off')
+      else
+        os_dl_control.setLightingControlType('Continuous')
+      end
+
+      # set the fraction of the zone lights that are dimmed
+      if @hash[:control_fraction]
+        parent_zone.setFractionofZoneControlledbyPrimaryDaylightingControl(@hash[:control_fraction])
+      else
+        parent_zone.setFractionofZoneControlledbyPrimaryDaylightingControl(defaults[:control_fraction][:default])
+      end
+
+      os_dl_control
+    end
+
+  end #DaylightingControl
+end #Honeybee

data/lib/to_openstudio/model.rb

@@ -34,9 +34,38 @@ require 'honeybee/model'
 require 'openstudio'
 
 module Honeybee
+
+  def self.write_schedule_csv(schedule_csv_dir, schedule_csv)
+    filename = schedule_csv[:filename]
+    columns = schedule_csv[:columns]
+    if !columns.empty?
+      n = columns[0].size
+      path = File.join(schedule_csv_dir, filename)
+      File.open(path, 'w') do |file|
+        (0...n).each do |i|
+          row = []
+          columns.each do |column|
+            row << column[i]
+          end
+          file.puts row.join(',')
+        end
+      end
+    end
+  end
+
   class Model
 
     attr_reader :openstudio_model
+    attr_reader :schedule_csv_dir, :include_datetimes, :schedule_csvs
+
+    # if a schedule csv dir is specified then ScheduleFixedIntervalAbridged objects
+    # will be translated to ScheduleFile objects instead of ScheduleFixedInterval
+    # the optional schedule_csv_include_datetimes argument controls whether schedule csv
+    # files include a first column of date times for verification
+    def set_schedule_csv_dir(schedule_csv_dir, include_datetimes = false)
+      @schedule_csv_dir = schedule_csv_dir
+      @include_datetimes = include_datetimes
+    end
 
     # convert to openstudio model, clears errors and warnings
     def to_openstudio_model(openstudio_model=nil, log_report=true)
@@ -99,7 +128,7 @@ module Honeybee
         create_schedule_type_limits(@hash[:properties][:energy][:schedule_type_limits])
       end
       if @hash[:properties][:energy][:schedules]
-        create_schedules(@hash[:properties][:energy][:schedules])
+        create_schedules(@hash[:properties][:energy][:schedules], false, true)
       end
 
       if log_report
@@ -283,7 +312,32 @@ module Honeybee
       end
     end
 
-    def create_schedules(schedule_dicts, check_existing=false)
+    def create_schedules(schedule_dicts, check_existing=false, check_leap_year=true)
+
+      # clear out schedule_csvs
+      @schedule_csvs = {}
+
+      if check_leap_year
+        is_leap_year = :unknown
+        schedule_dicts.each do |schedule|
+          # set is leap year = true in case start date has 3 integers
+          this_leap_year = false
+          if schedule[:start_date] && schedule[:start_date][2]
+            this_leap_year = true
+          end
+          if is_leap_year == :unknown
+            is_leap_year = this_leap_year
+          elsif is_leap_year != this_leap_year
+            raise("Mixed leap year information.")
+          end
+        end
+
+        if is_leap_year != :unknown
+          year_description = openstudio_model.getYearDescription
+          year_description.setIsLeapYear(is_leap_year)
+        end
+      end
+
       schedule_dicts.each do |schedule|
         # check if there's already a schedule in the model with the identifier
         add_obj = true
@@ -305,9 +359,15 @@ module Honeybee
           else
             raise("Unknown schedule type #{schedule_type}.")
           end
-          schedule_object.to_openstudio(@openstudio_model)
+          schedule_object.to_openstudio(@openstudio_model, @schedule_csv_dir, @include_datetimes, @schedule_csvs)
         end
       end
+
+      # write schedule csvs
+      @schedule_csvs.each_value do |schedule_csv|
+        Honeybee.write_schedule_csv(@schedule_csv_dir, schedule_csv)
+      end
+
     end
 
     def create_program_types(program_dicts, check_existing=false)
@@ -343,7 +403,7 @@ module Honeybee
       end
       @@standards[:schedules].each do |schedule|
         if schedule[:identifier] == 'Always On'
-          create_schedules([schedule], true)
+          create_schedules([schedule], true, false)
         end
       end
 

data/lib/to_openstudio/schedule/fixed_interval.rb

@@ -42,26 +42,60 @@ module Honeybee
       nil
     end
 
-    def to_openstudio(openstudio_model)
+    def to_openstudio(openstudio_model, schedule_csv_dir = nil, include_datetimes = nil, schedule_csvs = nil)
+      if schedule_csv_dir
+        to_schedule_file(openstudio_model, schedule_csv_dir, include_datetimes, schedule_csvs)
+      else
+        to_schedule_fixed_interval(openstudio_model)
+      end
+    end
+
+    def start_month
+      if @hash[:start_date]
+        return @hash[:start_date][0]
+      end
+      defaults[:start_date][:default][0]
+    end
+
+    def start_day
+      if @hash[:start_date]
+        return @hash[:start_date][1]
+      end
+      defaults[:start_date][:default][1]
+    end
+
+    def interpolate
+      if @hash[:interpolate]
+        return @hash[:interpolate]
+      end
+      defaults[:interpolate][:default]
+    end
+
+    def timestep
+      if @hash[:timestep]
+        return @hash[:timestep]
+      end
+      defaults[:timestep][:default]
+    end
+
+    def placeholder_value
+      if @hash[:placeholder_value]
+        return @hash[:placeholder_value]
+      end
+      defaults[:placeholder_value][:default]
+    end
+
+    def to_schedule_fixed_interval(openstudio_model)
       # create the new schedule
       os_fi_schedule = OpenStudio::Model::ScheduleFixedInterval.new(openstudio_model)
       os_fi_schedule.setName(@hash[:identifier])
 
       # assign start date
-      if @hash[:start_date]
-        os_fi_schedule.setStartMonth(@hash[:start_date][0])
-        os_fi_schedule.setStartDay(@hash[:start_date][1])
-      else
-        os_fi_schedule.setStartMonth(defaults[:start_date][:default][0])
-        os_fi_schedule.setStartDay(defaults[:start_date][:default][1])
-      end
+      os_fi_schedule.setStartMonth(start_month)
+      os_fi_schedule.setStartDay(start_day)
 
       # assign the interpolate value
-      unless @hash[:interpolate].nil?
-        os_fi_schedule.setInterpolatetoTimestep(@hash[:interpolate])
-      else
-        os_fi_schedule.setInterpolatetoTimestep(defaults[:interpolate][:default])
-      end
+      os_fi_schedule.setInterpolatetoTimestep(interpolate)
 
       # assign the schedule type limit
       if @hash[:schedule_type_limit]
@@ -73,32 +107,114 @@ module Honeybee
       end
 
       # assign the timestep
-      if @hash[:timestep]
-        timestep = @hash[:timestep]
-        interval_length = 60 / timestep
-        os_fi_schedule.setIntervalLength(interval_length)
-      else
-        timestep = defaults[:timestep][:default]
-        interval_length = 60 / timestep
-        os_fi_schedule.setIntervalLength(interval_length)
-      end
+      interval_length = 60 / timestep
+      os_fi_schedule.setIntervalLength(interval_length)
       openstudio_interval_length = OpenStudio::Time.new(0, 0, interval_length)
 
       # assign the values as a timeseries
       year_description = openstudio_model.getYearDescription
+      start_date = year_description.makeDate(start_month, start_day)
+      timeseries = OpenStudio::TimeSeries.new(start_date, openstudio_interval_length, OpenStudio.createVector(@hash[:values]), '')
+      os_fi_schedule.setTimeSeries(timeseries)
 
-      # set is leap year = true in case start date has 3 integers
-      if @hash[:start_date][2]
-        year_description.setIsLeapYear(true)
-      end
+      os_fi_schedule
+    end
+
+    def to_schedule_file(openstudio_model, schedule_csv_dir, include_datetimes, schedule_csvs)
+
+      # in order to combine schedules in the same csv file they must have the same key
+      schedule_key = "#{@hash[:identifier]}_#{start_month}_#{start_day}_#{timestep}"
 
-      start_date = year_description.makeDate(@hash[:start_date][0], @hash[:start_date][1])
+      # get start and end date times
+      yd = openstudio_model.getYearDescription
+      date_time = OpenStudio::DateTime.new(yd.makeDate(1, 1), OpenStudio::Time.new(0,0,0))
+      start_date_time = OpenStudio::DateTime.new(yd.makeDate(start_month, start_day), OpenStudio::Time.new(0,0,0))
+      end_date_time = OpenStudio::DateTime.new(yd.makeDate(12, 31), OpenStudio::Time.new(1,0,0))
 
+      # get timestep
+      interval_length = 60 / timestep
+      dt = OpenStudio::Time.new(0, 0, interval_length, 0)
+
+      # get values and date times
       values = @hash[:values]
-      timeseries = OpenStudio::TimeSeries.new(start_date, openstudio_interval_length, OpenStudio.createVector(values), '')
-      os_fi_schedule.setTimeSeries(timeseries)
+      num_values = values.size
+      i_values = 0
+      padded_values = []
+      date_times = []
+      pv = placeholder_value
 
-      os_fi_schedule
+      while date_time < end_date_time
+        date = date_time.date
+        time = date_time.time
+        date_times << "#{date.dayOfMonth} #{date.monthOfYear.valueName} #{time.hours.to_s.rjust(2,'0')}:#{time.minutes.to_s.rjust(2,'0')}"
+
+        if date_time < start_date_time
+          padded_values << pv
+        elsif i_values < num_values
+          padded_values << values[i_values]
+          i_values += 1
+        else
+          padded_values << pv
+        end
+
+        date_time += dt
+      end
+
+
+      # find or create the schedule csv object which will hold the filename and columns
+      filename = nil
+      columns = nil
+      os_external_file = nil
+      schedule_csv = schedule_csvs[schedule_key]
+      if schedule_csv.nil?
+        # file name to write
+        filename = "#{@hash[:identifier]}.csv".gsub(' ', '_')
+
+        # columns of data
+        columns = []
+        if include_datetimes
+          columns << ['Date Times'].concat(date_times)
+        end
+
+        # schedule csv file must exist even though it has no content yet
+        path = File.join(schedule_csv_dir, filename)
+        if !File.exist?(path)
+          File.open(path, 'w') {|f| f.puts ''}
+        end
+
+        # get the external file which points to the schedule csv file
+        os_external_file = OpenStudio::Model::ExternalFile.getExternalFile(openstudio_model, filename)
+        os_external_file = os_external_file.get
+
+        schedule_csv = {filename: filename, columns: columns, os_external_file: os_external_file}
+        schedule_csvs[schedule_key] = schedule_csv
+      else
+        filename = schedule_csv[:filename]
+        columns = schedule_csv[:columns]
+        os_external_file = schedule_csv[:os_external_file]
+      end
+
+      # insert the padded_values to write later
+      columns << [@hash[:identifier]].concat(padded_values)
+
+      # create the schedule file
+      column = columns.size # 1 based index
+      rowsToSkip = 1
+      os_schedule_file = OpenStudio::Model::ScheduleFile.new(os_external_file, column, rowsToSkip)
+      os_schedule_file.setName(@hash[:identifier])
+      os_schedule_file.setInterpolatetoTimestep(interpolate)
+      os_schedule_file.setMinutesperItem(interval_length.to_s)
+
+      # assign the schedule type limit
+      if @hash[:schedule_type_limit]
+        schedule_type_limit = openstudio_model.getScheduleTypeLimitsByName(@hash[:schedule_type_limit])
+        unless schedule_type_limit.empty?
+          schedule_type_limit_object = schedule_type_limit.get
+          os_schedule_file.setScheduleTypeLimits(schedule_type_limit_object)
+        end
+      end
+
+      os_schedule_file
     end
 
   end #ScheduleFixedIntervalAbridged

data/lib/to_openstudio/schedule/ruleset.rb

@@ -42,7 +42,8 @@ module Honeybee
       nil
     end
 
-    def to_openstudio(openstudio_model)
+    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])