openstudio-common-measures 0.3.2 → 0.4.0

data/lib/measures/openstudio_results/resources/os_lib_helper_methods.rb

@@ -1,399 +0,0 @@
-# *******************************************************************************
-# OpenStudio(R), Copyright (c) 2008-2020, 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_HelperMethods
-  # populate choice argument from model objects
-  def self.populateChoiceArgFromModelObjects(model, modelObject_args_hash, includeBuilding = nil)
-    # populate choice argument for constructions that are applied to surfaces in the model
-    modelObject_handles = OpenStudio::StringVector.new
-    modelObject_display_names = OpenStudio::StringVector.new
-
-    # looping through sorted hash of constructions
-    modelObject_args_hash.sort.map do |key, value|
-      modelObject_handles << value.handle.to_s
-      modelObject_display_names << key
-    end
-
-    unless includeBuilding.nil?
-      # add building to string vector with space type
-      building = model.getBuilding
-      modelObject_handles << building.handle.to_s
-      modelObject_display_names << includeBuilding
-    end
-
-    result = { 'modelObject_handles' => modelObject_handles, 'modelObject_display_names' => modelObject_display_names }
-    return result
-  end
-
-  # create variables in run from user arguments
-  def self.createRunVariables(runner, model, user_arguments, arguments)
-    result = {}
-
-    error = false
-    # use the built-in error checking
-    unless runner.validateUserArguments(arguments, user_arguments)
-      error = true
-      runner.registerError('Invalid argument values.')
-    end
-
-    user_arguments.each do |argument|
-      # get argument info
-      arg = user_arguments[argument]
-      arg_type = arg.print.lines($/)[1]
-
-      # create argument variable
-      if arg_type.include? 'Double, Required'
-        eval("result[\"#{arg.name}\"] = runner.getDoubleArgumentValue(\"#{arg.name}\", user_arguments)")
-      elsif arg_type.include? 'Integer, Required'
-        eval("result[\"#{arg.name}\"] = runner.getIntegerArgumentValue(\"#{arg.name}\", user_arguments)")
-      elsif arg_type.include? 'String, Required'
-        eval("result[\"#{arg.name}\"] = runner.getStringArgumentValue(\"#{arg.name}\", user_arguments)")
-      elsif arg_type.include? 'Boolean, Required'
-        eval("result[\"#{arg.name}\"] = runner.getBoolArgumentValue(\"#{arg.name}\", user_arguments)")
-      elsif arg_type.include? 'Choice, Required'
-        eval("result[\"#{arg.name}\"] = runner.getStringArgumentValue(\"#{arg.name}\", user_arguments)")
-      else
-        puts 'not setup to handle all argument types yet, or any optional arguments'
-      end
-    end
-
-    if error
-      return false
-    else
-      return result
-    end
-  end
-
-  # check choice argument made from model objects
-  def self.checkChoiceArgFromModelObjects(object, variableName, to_ObjectType, runner, user_arguments)
-    apply_to_building = false
-    modelObject = nil
-    if object.empty?
-      handle = runner.getStringArgumentValue(variableName, user_arguments)
-      if handle.empty?
-        runner.registerError("No #{variableName} was chosen.") # this logic makes this not work on an optional model object argument
-      else
-        runner.registerError("The selected #{variableName} with handle '#{handle}' was not found in the model. It may have been removed by another measure.")
-      end
-      return false
-    else
-      if !eval("object.get.#{to_ObjectType}").empty?
-        modelObject = eval("object.get.#{to_ObjectType}").get
-      elsif !object.get.to_Building.empty?
-        apply_to_building = true
-      else
-        runner.registerError("Script Error - argument not showing up as #{variableName}.")
-        return false
-      end
-    end
-
-    result = { 'modelObject' => modelObject, 'apply_to_building' => apply_to_building }
-  end
-
-  # check choice argument made from model objects
-  def self.checkOptionalChoiceArgFromModelObjects(object, variableName, to_ObjectType, runner, user_arguments)
-    apply_to_building = false
-    modelObject = nil
-    if object.empty?
-      handle = runner.getOptionalStringArgumentValue(variableName, user_arguments)
-      if handle.empty?
-        # do nothing, this is a valid option
-        puts 'hello'
-        modelObject = nil
-        apply_to_building = false
-      else
-        runner.registerError("The selected #{variableName} with handle '#{handle}' was not found in the model. It may have been removed by another measure.")
-        return false
-      end
-    else
-      if !eval("object.get.#{to_ObjectType}").empty?
-        modelObject = eval("object.get.#{to_ObjectType}").get
-      elsif !object.get.to_Building.empty?
-        apply_to_building = true
-      else
-        runner.registerError("Script Error - argument not showing up as #{variableName}.")
-        return false
-      end
-    end
-
-    result = { 'modelObject' => modelObject, 'apply_to_building' => apply_to_building }
-  end
-
-  # check value of double arguments
-  def self.checkDoubleAndIntegerArguments(runner, user_arguments, arg_check_hash)
-    error = false
-
-    # get hash values
-    min = arg_check_hash['min']
-    max = arg_check_hash['max']
-    min_eq_bool = arg_check_hash['min_eq_bool']
-    max_eq_bool = arg_check_hash['max_eq_bool']
-
-    arg_check_hash['arg_array'].each do |argument|
-      argument = user_arguments[argument]
-
-      # get arg values
-      arg_value = nil
-      if argument.hasValue
-        arg_value = argument.valueDisplayName.to_f # instead of valueAsDouble so it allows integer arguments as well
-      elsif argument.hasDefaultValue
-        arg_value = argument.defaultValueDisplayName.to_f
-      end
-      arg_display = argument.displayName
-
-      unless min.nil?
-        if min_eq_bool
-          if arg_value < min
-            runner.registerError("Please enter value greater than or equal to #{min} for #{arg_display}.") # add in argument display name
-            error = true
-          end
-        else
-          if arg_value <= min
-            runner.registerError("Please enter value greater than #{min} for #{arg_display}.") # add in argument display name
-            error = true
-          end
-        end
-      end
-      unless max.nil?
-        if max_eq_bool
-          if arg_value > max
-            runner.registerError("Please enter value less than or equal to #{max} for #{arg_display}.") # add in argument display name
-            error = true
-          end
-        else
-          if arg_value >= max
-            runner.registerError("Please enter value less than #{max} for #{arg_display}.") # add in argument display name
-            error = true
-          end
-        end
-      end
-    end
-
-    # check for any errors
-    if error
-      return false
-    else
-      return true
-    end
-  end
-
-  # open channel to log info/warning/error messages
-  def self.setup_log_msgs(runner, debug = false)
-    # Open a channel to log info/warning/error messages
-    @msg_log = OpenStudio::StringStreamLogSink.new
-    if debug
-      @msg_log.setLogLevel(OpenStudio::Debug)
-    else
-      @msg_log.setLogLevel(OpenStudio::Info)
-    end
-    @start_time = Time.new
-    @runner = runner
-  end
-
-  # Get all the log messages and put into output
-  # for users to see.
-  def self.log_msgs
-    @msg_log.logMessages.each do |msg|
-      # DLM: you can filter on log channel here for now
-      if /openstudio.*/.match(msg.logChannel) # /openstudio\.model\..*/
-        # Skip certain messages that are irrelevant/misleading
-        next if msg.logMessage.include?('Skipping layer') || # Annoying/bogus "Skipping layer" warnings
-                msg.logChannel.include?('runmanager') || # RunManager messages
-                msg.logChannel.include?('setFileExtension') || # .ddy extension unexpected
-                msg.logChannel.include?('Translator') || # Forward translator and geometry translator
-                msg.logMessage.include?('UseWeatherFile') # 'UseWeatherFile' is not yet a supported option for YearDescription
-
-        # Report the message in the correct way
-        if msg.logLevel == OpenStudio::Info
-          @runner.registerInfo(msg.logMessage)
-        elsif msg.logLevel == OpenStudio::Warn
-          @runner.registerWarning("[#{msg.logChannel}] #{msg.logMessage}")
-        elsif msg.logLevel == OpenStudio::Error
-          @runner.registerError("[#{msg.logChannel}] #{msg.logMessage}")
-        elsif msg.logLevel == OpenStudio::Debug && @debug
-          @runner.registerInfo("DEBUG - #{msg.logMessage}")
-        end
-      end
-    end
-    @runner.registerInfo("Total Time = #{(Time.new - @start_time).round}sec.")
-  end
-
-  def self.check_upstream_measure_for_arg(runner, arg_name)
-    # 2.x methods (currently setup for measure display name but snake_case arg names)
-    arg_name_value = {}
-    runner.workflow.workflowSteps.each do |step|
-      if step.to_MeasureStep.is_initialized
-        measure_step = step.to_MeasureStep.get
-
-        measure_name = measure_step.measureDirName
-        if measure_step.name.is_initialized
-          measure_name = measure_step.name.get # this is instance name in PAT
-        end
-        if measure_step.result.is_initialized
-          result = measure_step.result.get
-          result.stepValues.each do |arg|
-            name = arg.name
-            value = arg.valueAsVariant.to_s
-            if name == arg_name
-              arg_name_value[:value] = value
-              arg_name_value[:measure_name] = measure_name
-              return arg_name_value # stop after find first one
-            end
-          end
-        else
-          # puts "No result for #{measure_name}"
-        end
-      else
-        # puts "This step is not a measure"
-      end
-    end
-
-    return arg_name_value
-  end
-
-  # populate choice argument from model objects. areaType should be string like "floorArea" or "exteriorArea"
-  # note: it seems like spaceType.floorArea does account for multiplier, so I don't have to call this method unless I have a custom collection of spaces.
-  def self.getAreaOfSpacesInArray(model, spaceArray, areaType = 'floorArea')
-    # find selected floor spaces, make array and get floor area.
-    totalArea = 0
-    spaceAreaHash = {}
-    spaceArray.each do |space|
-      spaceArea = eval("space.#{areaType}*space.multiplier")
-      spaceAreaHash[space] = spaceArea
-      totalArea += spaceArea
-    end
-
-    result = { 'totalArea' => totalArea, 'spaceAreaHash' => spaceAreaHash }
-    return result
-  end
-
-  # runs conversion and neat string, and returns value with units in string, optionally before or after the value
-  def self.neatConvertWithUnitDisplay(double, fromString, toString, digits, unitBefore = false, unitAfter = true, space = true, parentheses = true)
-    # convert units
-    doubleConverted = OpenStudio.convert(double, fromString, toString)
-    if !doubleConverted.nil?
-      doubleConverted = doubleConverted.get
-    else
-      puts "Couldn't convert values, check string choices passed in. From: #{fromString}, To: #{toString}"
-    end
-
-    # get neat version of converted
-    neatConverted = OpenStudio.toNeatString(doubleConverted, digits, true)
-
-    # add prefix
-    if unitBefore
-      if space == true && parentheses == true
-        prefix = "(#{toString}) "
-      elsif space == true && parentheses == false
-        prefix = "(#{toString})"
-      elsif space == false && parentheses == true
-        prefix = "#{toString} "
-      else
-        prefix = toString.to_s
-      end
-    else
-      prefix = ''
-    end
-
-    # add suffix
-    if unitAfter
-      if space == true && parentheses == true
-        suffix = " (#{toString})"
-      elsif space == true && parentheses == false
-        suffix = "(#{toString})"
-      elsif space == false && parentheses == true
-        suffix = " #{toString}"
-      else
-        suffix = toString.to_s
-      end
-    else
-      suffix = ''
-    end
-
-    finalString = "#{prefix}#{neatConverted}#{suffix}"
-
-    return finalString
-  end
-
-  # helper that loops through lifecycle costs getting total costs under "Construction" and add to counter if occurs during year 0
-  def self.getTotalCostForObjects(objectArray, category = 'Construction', onlyYearFromStartZero = true)
-    counter = 0
-    objectArray.each do |object|
-      object_LCCs = object.lifeCycleCosts
-      object_LCCs.each do |object_LCC|
-        if object_LCC.category == category
-          if onlyYearFromStartZero == false || object_LCC.yearsFromStart == 0
-            counter += object_LCC.totalCost
-          end
-        end
-      end
-    end
-
-    return counter
-  end
-
-  # helper that loops through lifecycle costs getting total costs under "Construction" and add to counter if occurs during year 0
-  def self.getSpaceTypeStandardsInformation(spaceTypeArray)
-    # hash of space types
-    spaceTypeStandardsInfoHash = {}
-
-    spaceTypeArray.each do |spaceType|
-      # get standards building
-      if !spaceType.standardsBuildingType.empty?
-        standardsBuilding = spaceType.standardsBuildingType.get
-      else
-        standardsBuilding = nil
-      end
-
-      # get standards space type
-      if !spaceType.standardsSpaceType.empty?
-        standardsSpaceType = spaceType.standardsSpaceType.get
-      else
-        standardsSpaceType = nil
-      end
-
-      # populate hash
-      spaceTypeStandardsInfoHash[spaceType] = [standardsBuilding, standardsSpaceType]
-    end
-
-    return spaceTypeStandardsInfoHash
-  end
-
-  # OpenStudio has built in toNeatString method
-  # OpenStudio::toNeatString(double,2,true)# double,decimals, show commas
-
-  # OpenStudio has built in helper for unit conversion. That can be done using OpenStudio::convert() as shown below.
-  # OpenStudio::convert(double,"from unit string","to unit string").get
-end

data/lib/measures/openstudio_results/resources/os_lib_schedules.rb

@@ -1,962 +0,0 @@
-# *******************************************************************************
-# OpenStudio(R), Copyright (c) 2008-2020, 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