openstudio-extension 0.1.0 → 0.1.1

data/lib/openstudio/extension/core/os_lib_reporting_qaqc.rb

@@ -0,0 +1,200 @@
+# *******************************************************************************
+# OpenStudio(R), Copyright (c) 2008-2019, Alliance for Sustainable Energy, LLC.
+# 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.
+#
+# (4) Other than as required in clauses (1) and (2), distributions in any form
+# of modifications or other derivative works may not use the "OpenStudio"
+# trademark, "OS", "os", or any other confusingly similar designation without
+# specific prior written permission from Alliance for Sustainable Energy, LLC.
+#
+# 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 'json'
+
+module OsLib_Reporting
+  # setup - get model, sql, and setup web assets path
+  def self.setup(runner)
+    results = {}
+
+    # get the last model
+    model = runner.lastOpenStudioModel
+    if model.empty?
+      runner.registerError('Cannot find last model.')
+      return false
+    end
+    model = model.get
+
+    # get the last idf
+    workspace = runner.lastEnergyPlusWorkspace
+    if workspace.empty?
+      runner.registerError('Cannot find last idf file.')
+      return false
+    end
+    workspace = workspace.get
+
+    # get the last sql file
+    sqlFile = runner.lastEnergyPlusSqlFile
+    if sqlFile.empty?
+      runner.registerError('Cannot find last sql file.')
+      return false
+    end
+    sqlFile = sqlFile.get
+    model.setSqlFile(sqlFile)
+
+    # populate hash to pass to measure
+    results[:model] = model
+    # results[:workspace] = workspace
+    results[:sqlFile] = sqlFile
+    results[:web_asset_path] = OpenStudio.getSharedResourcesPath / OpenStudio::Path.new('web_assets')
+
+    return results
+  end
+
+  # cleanup - prep html
+  def self.gen_html(html_in_path, web_asset_path, sections, name)
+    # instance variables for erb
+    @sections = sections
+    @name = name
+
+    # read in template
+    if File.exist?(html_in_path)
+      html_in_path = html_in_path
+    else
+      html_in_path = "#{File.dirname(__FILE__)}/report.html.erb"
+    end
+    html_in = ''
+    File.open(html_in_path, 'r') do |file|
+      html_in = file.read
+    end
+
+    # configure template with variable values
+    renderer = ERB.new(html_in)
+    html_out = renderer.result(binding)
+
+    # write html file
+    html_out_path = './report.html'
+    File.open(html_out_path, 'w') do |file|
+      file << html_out
+      # make sure data is written to the disk one way or the other
+      begin
+        file.fsync
+      rescue StandardError
+        file.flush
+      end
+    end
+
+    return html_out_path
+  end
+
+  # developer notes
+  # method below is custom version of standard OpenStudio results methods. It passes an array of sections vs. a single section.
+  # It doesn't use the model or SQL file. It just gets data form OpenStudio attributes passed in
+  # It doesn't have a name_only section since it doesn't populate user arguments
+
+  def self.sections_from_check_attributes(check_elems, runner)
+    # inspecting check attributes
+    # make single table with checks.
+    # make second table with flag description (with column for where it came from)
+
+    # array to hold sections
+    sections = []
+
+    # gather data for section
+    qaqc_check_summary = {}
+    qaqc_check_summary[:title] = 'List of Checks in Measure'
+    qaqc_check_summary[:header] = ['Name', 'Category', 'Flags', 'Description']
+    qaqc_check_summary[:data] = []
+    qaqc_check_summary[:data_color] = []
+    @qaqc_check_section = {}
+    @qaqc_check_section[:title] = 'QAQC Check Summary'
+    @qaqc_check_section[:tables] = [qaqc_check_summary]
+
+    # add sections to array
+    sections << @qaqc_check_section
+
+    # counter for flags thrown
+    num_flags = 0
+
+    check_elems.each do |check|
+      # gather data for section
+      qaqc_flag_details = {}
+      qaqc_flag_details[:title] = "List of Flags Triggered for #{check.valueAsAttributeVector.first.valueAsString}."
+      qaqc_flag_details[:header] = ['Flag Detail']
+      qaqc_flag_details[:data] = []
+      @qaqc_flag_section = {}
+      @qaqc_flag_section[:title] = check.valueAsAttributeVector.first.valueAsString.to_s
+      @qaqc_flag_section[:tables] = [qaqc_flag_details]
+
+      check_name = nil
+      check_cat = nil
+      check_desc = nil
+      flags = []
+      # loop through attributes (name,category,description,then optionally one or more flag attributes)
+      check.valueAsAttributeVector.each_with_index do |value, index|
+        if index == 0
+          check_name = value.valueAsString
+        elsif index == 1
+          check_cat = value.valueAsString
+        elsif index == 2
+          check_desc = value.valueAsString
+        else # should be flag
+          flags << value.valueAsString
+          qaqc_flag_details[:data] << [value.valueAsString]
+          runner.registerWarning("#{check_name} - #{value.valueAsString}")
+          num_flags += 1
+        end
+      end
+
+      # add row to table for this check
+      qaqc_check_summary[:data] << [check_name, check_cat, flags.size, check_desc]
+
+      # add info message for check if no flags found (this way user still knows what ran)
+      if check.valueAsAttributeVector.size < 4
+        runner.registerInfo("#{check_name} - no flags.")
+      end
+
+      # color cells based and add runner register values based on flag status
+      if !flags.empty?
+        qaqc_check_summary[:data_color] << ['', '', 'indianred', '']
+        runner.registerValue(check_name.downcase.tr(' ', '_'), flags.size, 'flags')
+      else
+        qaqc_check_summary[:data_color] << ['', '', 'lightgreen', '']
+        runner.registerValue(check_name.downcase.tr(' ', '_'), flags.size, 'flags')
+      end
+
+      # add table for this check if there are flags
+      if !qaqc_flag_details[:data].empty?
+        sections << @qaqc_flag_section
+      end
+    end
+
+    # add total flags registerValue
+    runner.registerValue('total_qaqc_flags', num_flags, 'flags')
+
+    return sections
+  end
+end

data/lib/openstudio/extension/core/os_lib_schedules.rb

@@ -0,0 +1,963 @@
+# *******************************************************************************
+# OpenStudio(R), Copyright (c) 2008-2019, Alliance for Sustainable Energy, LLC.
+# 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.
+#
+# (4) Other than as required in clauses (1) and (2), distributions in any form
+# of modifications or other derivative works may not use the "OpenStudio"
+# trademark, "OS", "os", or any other confusingly similar designation without
+# specific prior written permission from Alliance for Sustainable Energy, LLC.
+#
+# 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.
+# *******************************************************************************
+
+module OsLib_Schedules
+  # create a ruleset schedule with a basic profile
+  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
+
+  # find the maximum profile value for a schedule
+  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
+
+  # find the maximum profile value for a schedule
+  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
+
+  # change value when value passes/fails test
+  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
+
+  # change value when time passes test
+  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
+
+  # merge multiple schedules into one using load or other value to weight each schedules influence on the merge
+  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
+
+  # create a new schedule using absolute velocity of existing schedule
+  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
+
+  # create a complex ruleset schedule
+  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
+
+  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
+
+  # create TimeSeries from ScheduleRuleset
+  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
+
+  # create ScheduleVariableInterval from TimeSeries
+  def self.create_schedule_variable_interval_from_time_series(model, time_series)
+    result = OpenStudio::Model::ScheduleInterval.fromTimeSeries(time_series, model).get
+  end
+
+  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
+  end