openstudio-standards 0.4.0 → 0.5.0

data/lib/openstudio-standards/qaqc/zone_conditions.rb

@@ -0,0 +1,278 @@
+# Module to apply QAQC checks to a model
+module OpenstudioStandards
+  module QAQC
+    # @!group Zone Conditions
+
+    # Check that there are no people or lights in plenums.
+    #
+    # @param category [String] category to bin this check into
+    # @param target_standard [String] standard template, e.g. '90.1-2013'
+    # @param name_only [Boolean] If true, only return the name of this check
+    # @return [OpenStudio::Attribute] OpenStudio Attribute object containing check results
+    def self.check_plenum_loads(category, target_standard, name_only: false)
+      # summary of the check
+      check_elems = OpenStudio::AttributeVector.new
+      check_elems << OpenStudio::Attribute.new('name', 'Plenum Loads')
+      check_elems << OpenStudio::Attribute.new('category', category)
+      check_elems << OpenStudio::Attribute.new('description', 'Check that the plenums do not have people or lights.')
+
+      # stop here if only name is requested this is used to populate display name for arguments
+      if name_only == true
+        results = []
+        check_elems.each do |elem|
+          results << elem.valueAsString
+        end
+        return results
+      end
+
+      std = Standard.build(target_standard)
+
+      begin
+        @model.getThermalZones.sort.each do |zone|
+          next unless std.thermal_zone_plenum?(zone)
+
+          # people
+          num_people = zone.numberOfPeople
+          if num_people > 0
+            check_elems << OpenStudio::Attribute.new('flag', "#{zone.name} is a plenum, but has #{num_people.round(1)} people.  Plenums should not contain people.")
+          end
+          # lights
+          lights_w = zone.lightingPower
+          if lights_w > 0
+            check_elems << OpenStudio::Attribute.new('flag', "#{zone.name} is a plenum, but has #{lights_w.round(1)} W of lights.  Plenums should not contain lights.")
+          end
+        end
+      rescue StandardError => e
+        # brief description of ruby error
+        check_elems << OpenStudio::Attribute.new('flag', "Error prevented QAQC check from running (#{e}).")
+
+        # backtrace of ruby error for diagnostic use
+        if @error_backtrace then check_elems << OpenStudio::Attribute.new('flag', e.backtrace.join("\n").to_s) end
+      end
+
+      # add check_elms to new attribute
+      check_elem = OpenStudio::Attribute.new('check', check_elems)
+
+      return check_elem
+    end
+
+    # Check for excess simulataneous heating and cooling
+    #
+    # @param category [String] category to bin this check into
+    # @param target_standard [String] standard template, e.g. '90.1-2013'
+    # @param max_delta [Double] threshold for throwing an error for temperature difference
+    # @param name_only [Boolean] If true, only return the name of this check
+    # @return [OpenStudio::Attribute] OpenStudio Attribute object containing check results
+    def self.check_supply_air_and_thermostat_temperature_difference(category, target_standard, max_delta: 2.0, name_only: false)
+      # G3.1.2.9 requires a 20 degree F delta between supply air temperature and zone temperature.
+      target_clg_delta = 20.0
+
+      # summary of the check
+      check_elems = OpenStudio::AttributeVector.new
+      check_elems << OpenStudio::Attribute.new('name', 'Supply and Zone Air Temperature')
+      check_elems << OpenStudio::Attribute.new('category', category)
+      if @utility_name.nil?
+        check_elems << OpenStudio::Attribute.new('description', "Check if fans modeled to ASHRAE 90.1 2013 Section G3.1.2.9 requirements. Compare the supply air temperature for each thermal zone against the thermostat setpoints. Throw flag if temperature difference excedes threshold of #{target_clg_delta}F plus the selected tolerance.")
+      else
+        check_elems << OpenStudio::Attribute.new('description', "Check if fans modeled to ASHRAE 90.1 2013 Section G3.1.2.9 requirements. Compare the supply air temperature for each thermal zone against the thermostat setpoints. Throw flag if temperature difference excedes threshold set by #{@utility_name}.")
+      end
+
+      # stop here if only name is requested this is used to populate display name for arguments
+      if name_only == true
+        results = []
+        check_elems.each do |elem|
+          results << elem.valueAsString
+        end
+        return results
+      end
+
+      std = Standard.build(target_standard)
+
+      begin
+        # loop through thermal zones
+        @model.getThermalZones.sort.each do |thermal_zone|
+          # skip plenums
+          next if std.thermal_zone_plenum?(thermal_zone)
+
+          # populate thermostat ranges
+          model_clg_min = nil
+          if thermal_zone.thermostatSetpointDualSetpoint.is_initialized
+
+            thermostat = thermal_zone.thermostatSetpointDualSetpoint.get
+            if thermostat.coolingSetpointTemperatureSchedule.is_initialized
+
+              clg_sch = thermostat.coolingSetpointTemperatureSchedule.get
+              schedule_values = nil
+              if clg_sch.to_ScheduleRuleset.is_initialized
+                schedule_values = std.schedule_ruleset_annual_min_max_value(clg_sch.to_ScheduleRuleset.get)
+              elsif clg_sch.to_ScheduleConstant.is_initialized
+                schedule_values = std.schedule_constant_annual_min_max_value(clg_sch.to_ScheduleConstant.get)
+              end
+
+              unless schedule_values.nil?
+                model_clg_min = schedule_values['min']
+              end
+            end
+
+          else
+            # go to next zone if not conditioned
+            next
+
+          end
+
+          # flag if there is setpoint schedule can't be inspected (isn't ruleset)
+          if model_clg_min.nil?
+            check_elems << OpenStudio::Attribute.new('flag', "Can't inspect thermostat schedules for #{thermal_zone.name}")
+          else
+
+            # get supply air temps from thermal zone sizing
+            sizing_zone = thermal_zone.sizingZone
+            clg_supply_air_temp = sizing_zone.zoneCoolingDesignSupplyAirTemperature
+
+            # convert model values to IP
+            model_clg_min_ip = OpenStudio.convert(model_clg_min, 'C', 'F').get
+            clg_supply_air_temp_ip = OpenStudio.convert(clg_supply_air_temp, 'C', 'F').get
+
+            # check supply air against zone temperature (only check against min setpoint, assume max is night setback)
+            if model_clg_min_ip - clg_supply_air_temp_ip > target_clg_delta + max_delta
+              check_elems << OpenStudio::Attribute.new('flag', "For #{thermal_zone.name} the delta temp between the cooling supply air temp of #{clg_supply_air_temp_ip.round(2)} (F) and the minimum thermostat cooling temp of #{model_clg_min_ip.round(2)} (F) is more than #{max_delta} (F) larger than the expected delta of #{target_clg_delta} (F)")
+            elsif model_clg_min_ip - clg_supply_air_temp_ip < target_clg_delta - max_delta
+              check_elems << OpenStudio::Attribute.new('flag', "For #{thermal_zone.name} the delta temp between the cooling supply air temp of #{clg_supply_air_temp_ip.round(2)} (F) and the minimum thermostat cooling temp of #{model_clg_min_ip.round(2)} (F) is more than #{max_delta} (F) smaller than the expected delta of #{target_clg_delta} (F)")
+            end
+
+          end
+        end
+      rescue StandardError => e
+        # brief description of ruby error
+        check_elems << OpenStudio::Attribute.new('flag', "Error prevented QAQC check from running (#{e}).")
+
+        # backtrace of ruby error for diagnostic use
+        if @error_backtrace then check_elems << OpenStudio::Attribute.new('flag', e.backtrace.join("\n").to_s) end
+      end
+
+      # add check_elms to new attribute
+      check_elem = OpenStudio::Attribute.new('check', check_elems)
+
+      return check_elem
+    end
+
+    # Check that all zones with people are conditioned (have a thermostat with setpoints)
+    #
+    # @param category [String] category to bin this check into
+    # @param target_standard [String] standard template, e.g. '90.1-2013'
+    # @param name_only [Boolean] If true, only return the name of this check
+    # @return [OpenStudio::Attribute] OpenStudio Attribute object containing check results
+    def self.check_occupied_zones_conditioned(category, target_standard, name_only: false)
+      # summary of the check
+      check_elems = OpenStudio::AttributeVector.new
+      check_elems << OpenStudio::Attribute.new('name', 'Conditioned Zones')
+      check_elems << OpenStudio::Attribute.new('category', category)
+      check_elems << OpenStudio::Attribute.new('description', 'Check that all zones with people have thermostats.')
+
+      # stop here if only name is requested this is used to populate display name for arguments
+      if name_only == true
+        results = []
+        check_elems.each do |elem|
+          results << elem.valueAsString
+        end
+        return results
+      end
+
+      std = Standard.build(target_standard)
+
+      begin
+        @model.getThermalZones.sort.each do |zone|
+          # only check zones with people
+          num_ppl = zone.numberOfPeople
+          next unless zone.numberOfPeople > 0
+
+          # Check that the zone is heated (at a minimum) by checking that the heating setpoint is at least 41F.
+          # Sometimes people include thermostats but use setpoints such that the system never comes on.
+          unless std.thermal_zone_heated?(zone)
+            check_elems << OpenStudio::Attribute.new('flag', "#{zone.name} has #{num_ppl} people but is not heated.  Zones containing people are expected to be conditioned, heated-only at a minimum.  Heating setpoint must be at least 41F to be considered heated.")
+          end
+        end
+      rescue StandardError => e
+        # brief description of ruby error
+        check_elems << OpenStudio::Attribute.new('flag', "Error prevented QAQC check from running (#{e}).")
+
+        # backtrace of ruby error for diagnostic use
+        if @error_backtrace then check_elems << OpenStudio::Attribute.new('flag', e.backtrace.join("\n").to_s) end
+      end
+
+      # add check_elms to new attribute
+      check_elem = OpenStudio::Attribute.new('check', check_elems)
+
+      return check_elem
+    end
+
+    # Check unmet hours
+    #
+    # @param category [String] category to bin this check into
+    # @param target_standard [String] standard template, e.g. '90.1-2013'
+    # @param max_unmet_hrs [Double] threshold for unmet hours reporting
+    # @param expect_clg_unmet_hrs [Bool] boolean on whether to expect unmet cooling hours for a model without a cooling system
+    # @param expect_htg_unmet_hrs [Bool] boolean on whether to expect unmet heating hours for a model without a heating system
+    # @param name_only [Boolean] If true, only return the name of this check
+    # @return [OpenStudio::Attribute] OpenStudio Attribute object containing check results
+    def self.check_unmet_hours(category, target_standard,
+                               max_unmet_hrs: 550.0,
+                               expect_clg_unmet_hrs: false,
+                               expect_htg_unmet_hrs: false,
+                               name_only: false)
+      # summary of the check
+      check_elems = OpenStudio::AttributeVector.new
+      check_elems << OpenStudio::Attribute.new('name', 'Unmet Hours')
+      check_elems << OpenStudio::Attribute.new('category', category)
+      check_elems << OpenStudio::Attribute.new('description', 'Check model unmet hours.')
+
+      # stop here if only name is requested this is used to populate display name for arguments
+      if name_only == true
+        results = []
+        check_elems.each do |elem|
+          results << elem.valueAsString
+        end
+        return results
+      end
+
+      std = Standard.build(target_standard)
+
+      begin
+        unmet_heating_hrs = std.model_annual_occupied_unmet_heating_hours(@model)
+        unmet_cooling_hrs = std.model_annual_occupied_unmet_cooling_hours(@model)
+        unmet_hrs = std.model_annual_occupied_unmet_hours(@model)
+
+        if unmet_hrs
+          if unmet_hrs > max_unmet_hrs
+            if expect_clg_unmet_hrs && expect_htg_unmet_hrs
+              check_elems << OpenStudio::Attribute.new('flag', "Warning: Unmet heating and cooling hours expected.  There were #{unmet_heating_hrs.round(1)} unmet occupied heating hours and #{unmet_cooling_hrs.round(1)} unmet occupied cooling hours (total: #{unmet_hrs.round(1)}).")
+            elsif expect_clg_unmet_hrs && !expect_htg_unmet_hrs && unmet_heating_hrs >= max_unmet_hrs
+              check_elems << OpenStudio::Attribute.new('flag', "Major Error: Unmet cooling hours expected, but unmet heating hours exceeds limit of #{max_unmet_hrs}.  There were #{unmet_heating_hrs.round(1)} unmet occupied heating hours and #{unmet_cooling_hrs.round(1)} unmet occupied cooling hours (total: #{unmet_hrs.round(1)}).")
+            elsif expect_clg_unmet_hrs && !expect_htg_unmet_hrs && unmet_heating_hrs < max_unmet_hrs
+              check_elems << OpenStudio::Attribute.new('flag', "Warning: Unmet cooling hours expected.  There were #{unmet_heating_hrs.round(1)} unmet occupied heating hours and #{unmet_cooling_hrs.round(1)} unmet occupied cooling hours (total: #{unmet_hrs.round(1)}).")
+            elsif expect_htg_unmet_hrs && !expect_clg_unmet_hrs && unmet_cooling_hrs >= max_unmet_hrs
+              check_elems << OpenStudio::Attribute.new('flag', "Major Error: Unmet heating hours expected, but unmet cooling hours exceeds limit of #{max_unmet_hrs}.  There were #{unmet_heating_hrs.round(1)} unmet occupied heating hours and #{unmet_cooling_hrs.round(1)} unmet occupied cooling hours (total: #{unmet_hrs.round(1)}).")
+            elsif expect_htg_unmet_hrs && !expect_clg_unmet_hrs && unmet_cooling_hrs < max_unmet_hrs
+              check_elems << OpenStudio::Attribute.new('flag', "Warning: Unmet heating hours expected.  There were #{unmet_heating_hrs.round(1)} unmet occupied heating hours and #{unmet_cooling_hrs.round(1)} unmet occupied cooling hours (total: #{unmet_hrs.round(1)}).")
+            else
+              check_elems << OpenStudio::Attribute.new('flag', "Major Error: There were #{unmet_heating_hrs.round(1)} unmet occupied heating hours and #{unmet_cooling_hrs.round(1)} unmet occupied cooling hours (total: #{unmet_hrs.round(1)}), more than the limit of #{max_unmet_hrs}.")
+            end
+          end
+        else
+          check_elems << OpenStudio::Attribute.new('flag', 'Warning: Could not determine unmet hours; simulation may have failed.')
+        end
+      rescue StandardError => e
+        # brief description of ruby error
+        check_elems << OpenStudio::Attribute.new('flag', "Error prevented QAQC check from running (#{e}).")
+
+        # backtrace of ruby error for diagnostic use
+        if @error_backtrace then check_elems << OpenStudio::Attribute.new('flag', e.backtrace.join("\n").to_s) end
+      end
+
+      # add check_elms to new attribute
+      check_elem = OpenStudio::Attribute.new('check', check_elems)
+
+      return check_elem
+    end
+  end
+end

data/lib/openstudio-standards/schedules/create.rb

@@ -0,0 +1,364 @@
+# Methods to create Schedule objects
+module OpenstudioStandards
+  module Schedules
+    # @!group Create
+
+    # create a ruleset schedule with a basic profile
+    #
+    # @param model [OpenStudio::Model::Model] OpenStudio model object
+    # @param options [Hash] Hash of name and time value pairs
+    # @return [OpenStudio::Model::ScheduleRuleset] OpenStudio ScheduleRuleset object
+    def self.create_simple_schedule(model, options = {})
+      defaults = {
+        'name' => nil,
+        'winter_time_value_pairs' => { 24.0 => 0.0 },
+        'summer_time_value_pairs' => { 24.0 => 1.0 },
+        'default_time_value_pairs' => { 24.0 => 1.0 }
+      }
+
+      # merge user inputs with defaults
+      options = defaults.merge(options)
+
+      # ScheduleRuleset
+      sch_ruleset = OpenStudio::Model::ScheduleRuleset.new(model)
+      if name
+        sch_ruleset.setName(options['name'])
+      end
+
+      # Winter Design Day
+      winter_dsn_day = OpenStudio::Model::ScheduleDay.new(model)
+      sch_ruleset.setWinterDesignDaySchedule(winter_dsn_day)
+      winter_dsn_day = sch_ruleset.winterDesignDaySchedule
+      winter_dsn_day.setName("#{sch_ruleset.name} Winter Design Day")
+      options['winter_time_value_pairs'].each do |k, v|
+        hour = k.truncate
+        min = ((k - hour) * 60).to_i
+        winter_dsn_day.addValue(OpenStudio::Time.new(0, hour, min, 0), v)
+      end
+
+      # Summer Design Day
+      summer_dsn_day = OpenStudio::Model::ScheduleDay.new(model)
+      sch_ruleset.setSummerDesignDaySchedule(summer_dsn_day)
+      summer_dsn_day = sch_ruleset.summerDesignDaySchedule
+      summer_dsn_day.setName("#{sch_ruleset.name} Summer Design Day")
+      options['summer_time_value_pairs'].each do |k, v|
+        hour = k.truncate
+        min = ((k - hour) * 60).to_i
+        summer_dsn_day.addValue(OpenStudio::Time.new(0, hour, min, 0), v)
+      end
+
+      # All Days
+      default_day = sch_ruleset.defaultDaySchedule
+      default_day.setName("#{sch_ruleset.name} Schedule Week Day")
+      options['default_time_value_pairs'].each do |k, v|
+        hour = k.truncate
+        min = ((k - hour) * 60).to_i
+        default_day.addValue(OpenStudio::Time.new(0, hour, min, 0), v)
+      end
+
+      return sch_ruleset
+    end
+
+    # create a ruleset schedule with a complex profile
+    #
+    # @param model [OpenStudio::Model::Model] OpenStudio model object
+    # @param options [Hash] Hash of name and time value pairs
+    # @return [OpenStudio::Model::ScheduleRuleset] OpenStudio ruleset schedule object
+    def self.create_complex_schedule(model, options = {})
+      defaults = {
+        'name' => nil,
+        'default_day' => ['always_on', [24.0, 1.0]]
+      }
+
+      # merge user inputs with defaults
+      options = defaults.merge(options)
+
+      # ScheduleRuleset
+      sch_ruleset = OpenStudio::Model::ScheduleRuleset.new(model)
+      if name
+        sch_ruleset.setName(options['name'])
+      end
+
+      # Winter Design Day
+      unless options['winter_design_day'].nil?
+        winter_dsn_day = OpenStudio::Model::ScheduleDay.new(model)
+        sch_ruleset.setWinterDesignDaySchedule(winter_dsn_day)
+        winter_dsn_day = sch_ruleset.winterDesignDaySchedule
+        winter_dsn_day.setName("#{sch_ruleset.name} Winter Design Day")
+        options['winter_design_day'].each do |data_pair|
+          hour = data_pair[0].truncate
+          min = ((data_pair[0] - hour) * 60).to_i
+          winter_dsn_day.addValue(OpenStudio::Time.new(0, hour, min, 0), data_pair[1])
+        end
+      end
+
+      # Summer Design Day
+      unless options['summer_design_day'].nil?
+        summer_dsn_day = OpenStudio::Model::ScheduleDay.new(model)
+        sch_ruleset.setSummerDesignDaySchedule(summer_dsn_day)
+        summer_dsn_day = sch_ruleset.summerDesignDaySchedule
+        summer_dsn_day.setName("#{sch_ruleset.name} Summer Design Day")
+        options['summer_design_day'].each do |data_pair|
+          hour = data_pair[0].truncate
+          min = ((data_pair[0] - hour) * 60).to_i
+          summer_dsn_day.addValue(OpenStudio::Time.new(0, hour, min, 0), data_pair[1])
+        end
+      end
+
+      # Default Day
+      default_day = sch_ruleset.defaultDaySchedule
+      default_day.setName("#{sch_ruleset.name} #{options['default_day'][0]}")
+      default_data_array = options['default_day']
+      default_data_array.delete_at(0)
+      default_data_array.each do |data_pair|
+        hour = data_pair[0].truncate
+        min = ((data_pair[0] - hour) * 60).to_i
+        default_day.addValue(OpenStudio::Time.new(0, hour, min, 0), data_pair[1])
+      end
+
+      # Rules
+      unless options['rules'].nil?
+        options['rules'].each do |data_array|
+          rule = OpenStudio::Model::ScheduleRule.new(sch_ruleset)
+          rule.setName("#{sch_ruleset.name} #{data_array[0]} Rule")
+          date_range = data_array[1].split('-')
+          start_date = date_range[0].split('/')
+          end_date = date_range[1].split('/')
+          rule.setStartDate(model.getYearDescription.makeDate(start_date[0].to_i, start_date[1].to_i))
+          rule.setEndDate(model.getYearDescription.makeDate(end_date[0].to_i, end_date[1].to_i))
+          days = data_array[2].split('/')
+          rule.setApplySunday(true) if days.include? 'Sun'
+          rule.setApplyMonday(true) if days.include? 'Mon'
+          rule.setApplyTuesday(true) if days.include? 'Tue'
+          rule.setApplyWednesday(true) if days.include? 'Wed'
+          rule.setApplyThursday(true) if days.include? 'Thu'
+          rule.setApplyFriday(true) if days.include? 'Fri'
+          rule.setApplySaturday(true) if days.include? 'Sat'
+          day_schedule = rule.daySchedule
+          day_schedule.setName("#{sch_ruleset.name} #{data_array[0]}")
+          data_array.delete_at(0)
+          data_array.delete_at(0)
+          data_array.delete_at(0)
+          data_array.each do |data_pair|
+            hour = data_pair[0].truncate
+            min = ((data_pair[0] - hour) * 60).to_i
+            day_schedule.addValue(OpenStudio::Time.new(0, hour, min, 0), data_pair[1])
+          end
+        end
+      end
+
+      return sch_ruleset
+    end
+
+    # create a new schedule using absolute velocity of existing schedule
+    #
+    # @param model [OpenStudio::Model::Model] OpenStudio model object
+    # @param schedule_ruleset [OpenStudio::Model::ScheduleRuleset] OpenStudio ruleset schedule object
+    # @return [OpenStudio::Model::ScheduleRuleset] OpenStudio ScheduleRuleset object
+    # @todo fix velocity so it isn't fraction change per step, but per hour
+    #   (I need to count hours between times and divide value by this)
+    def self.create_schedule_from_rate_of_change(model, schedule_ruleset)
+      # clone source schedule
+      new_schedule = schedule_ruleset.clone(model)
+      new_schedule.setName("#{schedule_ruleset.name} - Rate of Change")
+      new_schedule = new_schedule.to_ScheduleRuleset.get
+
+      # create array of all profiles to change. This includes summer, winter, default, and rules
+      profiles = []
+      profiles << new_schedule.winterDesignDaySchedule
+      profiles << new_schedule.summerDesignDaySchedule
+      profiles << new_schedule.defaultDaySchedule
+
+      # time values may need
+      end_profile_time = OpenStudio::Time.new(0, 24, 0, 0)
+      hour_bump_time = OpenStudio::Time.new(0, 1, 0, 0)
+      one_hour_left_time = OpenStudio::Time.new(0, 23, 0, 0)
+
+      rules = new_schedule.scheduleRules
+      rules.each do |rule|
+        profiles << rule.daySchedule
+      end
+
+      profiles.uniq.each do |profile|
+        times = profile.times
+        values = profile.values
+
+        i = 0
+        values_intermediate = []
+        times_intermediate = []
+        until i == values.size
+          if i == 0
+            values_intermediate << 0.0
+            if times[i] > hour_bump_time
+              times_intermediate << times[i] - hour_bump_time
+              if times[i + 1].nil?
+                time_step_value = end_profile_time.hours + end_profile_time.minutes / 60 - times[i].hours - times[i].minutes / 60
+              else
+                time_step_value = times[i + 1].hours + times[i + 1].minutes / 60 - times[i].hours - times[i].minutes / 60
+              end
+              values_intermediate << (values[i + 1].to_f - values[i].to_f).abs / (time_step_value * 2)
+            end
+            times_intermediate << times[i]
+          elsif i == (values.size - 1)
+            if times[times.size - 2] < one_hour_left_time
+              times_intermediate << times[times.size - 2] + hour_bump_time # this should be the second to last time
+              time_step_value = times[i - 1].hours + times[i - 1].minutes / 60 - times[i - 2].hours - times[i - 2].minutes / 60
+              values_intermediate << (values[i - 1].to_f - values[i - 2].to_f).abs / (time_step_value * 2)
+            end
+            values_intermediate << 0.0
+            times_intermediate << times[i] # this should be the last time
+          else
+            # get value multiplier based on how many hours it is spread over
+            time_step_value = times[i].hours + times[i].minutes / 60 - times[i - 1].hours - times[i - 1].minutes / 60
+            values_intermediate << (values[i].to_f - values[i - 1].to_f).abs / time_step_value
+            times_intermediate << times[i]
+          end
+          i += 1
+        end
+
+        # delete all profile values
+        profile.clearValues
+
+        i = 0
+        until i == times_intermediate.size
+          if i == (times_intermediate.size - 1)
+            profile.addValue(times_intermediate[i], values_intermediate[i].to_f)
+          else
+            profile.addValue(times_intermediate[i], values_intermediate[i].to_f)
+          end
+          i += 1
+        end
+      end
+
+      return new_schedule
+    end
+
+    # merge multiple schedules into one using load or other value to weight each schedules influence on the merge
+    #
+    # @param model [OpenStudio::Model::Model] OpenStudio model object
+    # @param schedule_weights_hash [Hash] Hash of OpenStudio::Model::ScheduleRuleset, Double
+    # @param sch_name [String] Optional name of new schedule
+    # @return [Hash] Hash of merged schedule and the total denominator
+    # @todo apply weights to schedule rules as well, not just winter, summer, and default profile
+    def self.create_weighted_merge_schedules(model, schedule_weights_hash, sch_name: 'Merged Schedule')
+      # get denominator for weight
+      denominator = 0.0
+      schedule_weights_hash.each do |schedule, weight|
+        denominator += weight
+      end
+
+      # create new schedule
+      sch_ruleset = OpenStudio::Model::ScheduleRuleset.new(model)
+      sch_ruleset.setName(sch_name)
+
+      # create winter design day profile
+      winter_dsn_day = OpenStudio::Model::ScheduleDay.new(model)
+      sch_ruleset.setWinterDesignDaySchedule(winter_dsn_day)
+      winter_dsn_day = sch_ruleset.winterDesignDaySchedule
+      winter_dsn_day.setName("#{sch_ruleset.name} Winter Design Day")
+
+      # create  summer design day profile
+      summer_dsn_day = OpenStudio::Model::ScheduleDay.new(model)
+      sch_ruleset.setSummerDesignDaySchedule(summer_dsn_day)
+      summer_dsn_day = sch_ruleset.summerDesignDaySchedule
+      summer_dsn_day.setName("#{sch_ruleset.name} Summer Design Day")
+
+      # create default profile
+      default_day = sch_ruleset.defaultDaySchedule
+      default_day.setName("#{sch_ruleset.name} Schedule Week Day")
+
+      # hash of schedule rules
+      rules_hash = {} # mon, tue, wed, thur, fri, sat, sun, startDate, endDate
+      # to avoid stacking order issues across schedules, I may need to make a rule for each day of the week for each date range
+
+      schedule_weights_hash.each do |schedule, weight|
+        # populate winter design day profile
+        old_winter_profile = schedule.to_ScheduleRuleset.get.winterDesignDaySchedule
+        times_final = summer_dsn_day.times
+        i = 0
+        value_updated_array = []
+        # loop through times already in profile and update values
+        until i > times_final.size - 1
+          value = old_winter_profile.getValue(times_final[i]) * weight / denominator
+          starting_value = winter_dsn_day.getValue(times_final[i])
+          winter_dsn_day.addValue(times_final[i], value + starting_value)
+          value_updated_array << times_final[i]
+          i += 1
+        end
+        # loop through any new times unique to the current old profile to be merged
+        j = 0
+        times = old_winter_profile.times
+        values = old_winter_profile.values
+        until j > times.size - 1
+          unless value_updated_array.include? times[j]
+            value = values[j] * weight / denominator
+            starting_value = winter_dsn_day.getValue(times[j])
+            winter_dsn_day.addValue(times[j], value + starting_value)
+          end
+          j += 1
+        end
+
+        # populate summer design day profile
+        old_summer_profile = schedule.to_ScheduleRuleset.get.summerDesignDaySchedule
+        times_final = summer_dsn_day.times
+        i = 0
+        value_updated_array = []
+        # loop through times already in profile and update values
+        until i > times_final.size - 1
+          value = old_summer_profile.getValue(times_final[i]) * weight / denominator
+          starting_value = summer_dsn_day.getValue(times_final[i])
+          summer_dsn_day.addValue(times_final[i], value + starting_value)
+          value_updated_array << times_final[i]
+          i += 1
+        end
+        # loop through any new times unique to the current old profile to be merged
+        j = 0
+        times = old_summer_profile.times
+        values = old_summer_profile.values
+        until j > times.size - 1
+          unless value_updated_array.include? times[j]
+            value = values[j] * weight / denominator
+            starting_value = summer_dsn_day.getValue(times[j])
+            summer_dsn_day.addValue(times[j], value + starting_value)
+          end
+          j += 1
+        end
+
+        # populate default profile
+        old_default_profile = schedule.to_ScheduleRuleset.get.defaultDaySchedule
+        times_final = default_day.times
+        i = 0
+        value_updated_array = []
+        # loop through times already in profile and update values
+        until i > times_final.size - 1
+          value = old_default_profile.getValue(times_final[i]) * weight / denominator
+          starting_value = default_day.getValue(times_final[i])
+          default_day.addValue(times_final[i], value + starting_value)
+          value_updated_array << times_final[i]
+          i += 1
+        end
+        # loop through any new times unique to the current old profile to be merged
+        j = 0
+        times = old_default_profile.times
+        values = old_default_profile.values
+        until j > times.size - 1
+          unless value_updated_array.include? times[j]
+            value = values[j] * weight / denominator
+            starting_value = default_day.getValue(times[j])
+            default_day.addValue(times[j], value + starting_value)
+          end
+          j += 1
+        end
+
+        # create rules
+
+        # gather data for rule profiles
+
+        # populate rule profiles
+      end
+
+      result = { 'mergedSchedule' => sch_ruleset, 'denominator' => denominator }
+      return result
+    end
+  end
+end