openstudio-extension 0.7.1 → 0.8.0

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

@@ -1,129 +0,0 @@
-# *******************************************************************************
-# OpenStudio(R), Copyright (c) Alliance for Sustainable Energy, LLC.
-# See also https://openstudio.net/license
-# *******************************************************************************
-
-module OsLib_QAQC
-  # Check the plant loop operational vs. sizing temperatures
-  # and make sure everything is coordinated.  This identifies problems
-  # caused by sizing to one set of conditions and operating at a different set.
-  def check_plant_temps(category, target_standard, max_sizing_temp_delta = 0.1, name_only = false)
-    # summary of the check
-    check_elems = OpenStudio::AttributeVector.new
-    check_elems << OpenStudio::Attribute.new('name', 'Plant Loop Temperatures')
-    check_elems << OpenStudio::Attribute.new('category', category)
-    check_elems << OpenStudio::Attribute.new('description', 'Check that plant loop sizing and operation temperatures are coordinated.')
-
-    # 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
-      # Check each plant loop in the model
-      @model.getPlantLoops.sort.each do |plant_loop|
-        loop_name = plant_loop.name.to_s
-
-        # Get the central heating and cooling SAT for sizing
-        sizing_plant = plant_loop.sizingPlant
-        loop_siz_f = OpenStudio.convert(sizing_plant.designLoopExitTemperature, 'C', 'F').get
-
-        # Determine the min and max operational temperatures
-        loop_op_min_f = nil
-        loop_op_max_f = nil
-        plant_loop.supplyOutletNode.setpointManagers.each do |spm|
-          obj_type = spm.iddObjectType.valueName.to_s
-          case obj_type
-          when 'OS_SetpointManager_Scheduled'
-            sch = spm.to_SetpointManagerScheduled.get.schedule
-            if sch.to_ScheduleRuleset.is_initialized
-              min_c = std.schedule_ruleset_annual_min_max_value(sch.to_ScheduleRuleset.get)['min']
-              max_c = std.schedule_ruleset_annual_min_max_value(sch.to_ScheduleRuleset.get)['max']
-            elsif sch.to_ScheduleConstant.is_initialized
-              min_c = std.schedule_constant_annual_min_max_value(sch.to_ScheduleConstant.get)['min']
-              max_c = std.schedule_constant_annual_min_max_value(sch.to_ScheduleConstant.get)['max']
-            else
-              next
-            end
-            loop_op_min_f = OpenStudio.convert(min_c, 'C', 'F').get
-            loop_op_max_f = OpenStudio.convert(max_c, 'C', 'F').get
-          when 'OS_SetpointManager_Scheduled_DualSetpoint'
-            spm = spm.to_SetpointManagerSingleZoneReheat.get
-            # Lowest setpoint is minimum of low schedule
-            low_sch = spm.to_SetpointManagerScheduled.get.lowSetpointSchedule
-            next if low_sch.empty?
-            low_sch = low_sch.get
-            if low_sch.to_ScheduleRuleset.is_initialized
-              min_c = std.schedule_ruleset_annual_min_max_value(low_sch.to_ScheduleRuleset.get)['min']
-              max_c = std.schedule_ruleset_annual_min_max_value(low_sch.to_ScheduleRuleset.get)['max']
-            elsif low_sch.to_ScheduleConstant.is_initialized
-              min_c = std.schedule_constant_annual_min_max_value(low_sch.to_ScheduleConstant.get)['min']
-              max_c = std.schedule_constant_annual_min_max_value(low_sch.to_ScheduleConstant.get)['max']
-            else
-              next
-            end
-            loop_op_min_f = OpenStudio.convert(min_c, 'C', 'F').get
-            # Highest setpoint it maximum of high schedule
-            high_sch = spm.to_SetpointManagerScheduled.get.highSetpointSchedule
-            next if high_sch.empty?
-            high_sch = high_sch.get
-            if high_sch.to_ScheduleRuleset.is_initialized
-              min_c = std.schedule_ruleset_annual_min_max_value(high_sch.to_ScheduleRuleset.get)['min']
-              max_c = std.schedule_ruleset_annual_min_max_value(high_sch.to_ScheduleRuleset.get)['max']
-            elsif high_sch.to_ScheduleConstant.is_initialized
-              min_c = std.schedule_constant_annual_min_max_value(high_sch.to_ScheduleConstant.get)['min']
-              max_c = std.schedule_constant_annual_min_max_value(high_sch.to_ScheduleConstant.get)['max']
-            else
-              next
-            end
-            loop_op_max_f = OpenStudio.convert(max_c, 'C', 'F').get
-          when 'OS_SetpointManager_OutdoorAirReset'
-            spm = spm.to_SetpointManagerOutdoorAirReset.get
-            temp_1_f = OpenStudio.convert(spm.setpointatOutdoorHighTemperature, 'C', 'F').get
-            temp_2_f = OpenStudio.convert(spm.setpointatOutdoorLowTemperature, 'C', 'F').get
-            loop_op_min_f = [temp_1_f, temp_2_f].min
-            loop_op_max_f = [temp_1_f, temp_2_f].max
-          else
-            next # Only check the commonly used setpoint managers
-          end
-        end
-
-        # Compare plant loop sizing temperatures to operational temperatures
-        case sizing_plant.loopType
-        when 'Heating'
-          if loop_op_max_f
-            if ((loop_op_max_f - loop_siz_f) / loop_op_max_f).abs > max_sizing_temp_delta
-              check_elems << OpenStudio::Attribute.new('flag', "For #{plant_loop.name}, the sizing is done with a supply water temp of #{loop_siz_f.round(2)}F, but the setpoint manager controlling the loop operates up to #{loop_op_max_f.round(2)}F. These are farther apart than the acceptable #{(max_sizing_temp_delta * 100.0).round(2)}% difference.")
-            end
-          end
-        when 'Cooling'
-          if loop_op_min_f
-            if ((loop_op_min_f - loop_siz_f) / loop_op_min_f).abs > max_sizing_temp_delta
-              check_elems << OpenStudio::Attribute.new('flag', "For #{plant_loop.name}, the sizing is done with a supply water temp of #{loop_siz_f.round(2)}F, but the setpoint manager controlling the loop operates down to #{loop_op_min_f.round(2)}F. These are farther apart than the acceptable #{(max_sizing_temp_delta * 100.0).round(2)}% difference.")
-            end
-          end
-        when 'Condenser'
-          # Not checking sizing of condenser loops
-        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
-    # note: registerWarning and registerValue will be added for checks downstream using os_lib_reporting_qaqc.rb
-  end
-end

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

@@ -1,57 +0,0 @@
-# *******************************************************************************
-# OpenStudio(R), Copyright (c) Alliance for Sustainable Energy, LLC.
-# See also https://openstudio.net/license
-# *******************************************************************************
-
-module OsLib_QAQC
-  # Check that there are no people or lights in plenums.
-  def 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.each do |zone|
-        # Only check plenums
-        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
-    # note: registerWarning and registerValue will be added for checks downstream using os_lib_reporting_qaqc.rb
-  end
-end

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

@@ -1,78 +0,0 @@
-# *******************************************************************************
-# OpenStudio(R), Copyright (c) Alliance for Sustainable Energy, LLC.
-# See also https://openstudio.net/license
-# *******************************************************************************
-
-module OsLib_QAQC
-  # Check the pumping power (W/gpm) for each pump in the model to identify
-  # unrealistically sized pumps.
-  def check_pump_pwr(category, target_standard, max_pwr_delta = 0.1, name_only = false)
-    # summary of the check
-    check_elems = OpenStudio::AttributeVector.new
-    check_elems << OpenStudio::Attribute.new('name', 'Pump Power')
-    check_elems << OpenStudio::Attribute.new('category', category)
-    check_elems << OpenStudio::Attribute.new('description', 'Check that pump power vs flow makes sense.')
-
-    # 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
-      # Check each plant loop
-      @model.getPlantLoops.each do |plant_loop|
-        # Set the expected/typical W/gpm
-        loop_type = plant_loop.sizingPlant.loopType
-        case loop_type
-        when 'Heating'
-          expected_w_per_gpm = 19.0
-        when 'Cooling'
-          expected_w_per_gpm = 22.0
-        when 'Condenser'
-          expected_w_per_gpm = 19.0
-        end
-
-        # Check the W/gpm for each pump on each plant loop
-        plant_loop.supplyComponents.each do |sc|
-          # Get the W/gpm for the pump
-          obj_type = sc.iddObjectType.valueName.to_s
-          case obj_type
-          when 'OS_Pump_ConstantSpeed'
-            actual_w_per_gpm = std.pump_rated_w_per_gpm(sc.to_PumpConstantSpeed.get)
-          when 'OS_Pump_VariableSpeed'
-            actual_w_per_gpm = std.pump_rated_w_per_gpm(sc.to_PumpVariableSpeed.get)
-          when 'OS_HeaderedPumps_ConstantSpeed'
-            actual_w_per_gpm = std.pump_rated_w_per_gpm(sc.to_HeaderedPumpsConstantSpeed.get)
-          when 'OS_HeaderedPumps_VariableSpeed'
-            actual_w_per_gpm = std.pump_rated_w_per_gpm(sc.to_HeaderedPumpsVariableSpeed.get)
-          else
-            next # Skip non-pump objects
-          end
-
-          # Compare W/gpm to expected/typical values
-          if ((expected_w_per_gpm - actual_w_per_gpm) / actual_w_per_gpm).abs > max_pwr_delta
-            check_elems << OpenStudio::Attribute.new('flag', "For #{sc.name} on #{plant_loop.name}, the actual pumping power of #{actual_w_per_gpm.round(1)} W/gpm is more than #{(max_pwr_delta * 100.0).round(2)}% different from the expected #{expected_w_per_gpm} W/gpm for a #{loop_type} plant loop.")
-          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
-    # note: registerWarning and registerValue will be added for checks downstream using os_lib_reporting_qaqc.rb
-  end
-end

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

@@ -1,211 +0,0 @@
-# *******************************************************************************
-# OpenStudio(R), Copyright (c) Alliance for Sustainable Energy, LLC.
-# See also https://openstudio.net/license
-# *******************************************************************************
-
-module OsLib_QAQC
-  # Determine the hour when the schedule first exceeds the starting value and when
-  # it goes back down to the ending value at the end of the day.
-  # This method only works for ScheduleRuleset schedules.
-  def get_start_and_end_times(schedule_ruleset)
-    # Ensure that this is a ScheduleRuleset
-    schedule_ruleset = schedule_ruleset.to_ScheduleRuleset
-    return [nil, nil] if schedule_ruleset.empty?
-    schedule_ruleset = schedule_ruleset.get
-
-    # Define the start and end date
-    year_start_date = nil
-    year_end_date = nil
-    if schedule_ruleset.model.yearDescription.is_initialized
-      year_description = schedule_ruleset.model.yearDescription.get
-      year = year_description.assumedYear
-      year_start_date = OpenStudio::Date.new(OpenStudio::MonthOfYear.new('January'), 1, year)
-      year_end_date = OpenStudio::Date.new(OpenStudio::MonthOfYear.new('December'), 31, year)
-    else
-      year_start_date = OpenStudio::Date.new(OpenStudio::MonthOfYear.new('January'), 1, 2009)
-      year_end_date = OpenStudio::Date.new(OpenStudio::MonthOfYear.new('December'), 31, 2009)
-    end
-
-    # Get the ordered list of all the day schedules that are used by this schedule ruleset
-    day_schs = schedule_ruleset.getDaySchedules(year_start_date, year_end_date)
-
-    # Get a 365-value array of which schedule is used on each day of the year,
-    day_schs_used_each_day = schedule_ruleset.getActiveRuleIndices(year_start_date, year_end_date)
-
-    # Create a map that shows how many days each schedule is used
-    day_sch_freq = day_schs_used_each_day.group_by { |n| n }
-    day_sch_freq = day_sch_freq.sort_by { |freq| freq[1].size }
-    common_day_freq = day_sch_freq.last
-
-    # Build a hash that maps schedule day index to schedule day
-    schedule_index_to_day = {}
-    day_schs.each_with_index do |day_sch, i|
-      schedule_index_to_day[day_schs_used_each_day[i]] = day_sch
-    end
-
-    # Get the most common day schedule
-    sch_index = common_day_freq[0]
-    number_of_days_sch_used = common_day_freq[1].size
-
-    # Get the day schedule at this index
-    day_sch = if sch_index == -1 # If index = -1, this day uses the default day schedule (not a rule)
-                schedule_ruleset.defaultDaySchedule
-              else
-                schedule_index_to_day[sch_index]
-              end
-
-    # Determine the full load hours for just one day
-    values = []
-    times = []
-    day_sch.times.each_with_index do |time, i|
-      times << day_sch.times[i]
-      values << day_sch.values[i]
-    end
-
-    # Get the minimum value
-    start_val = values.first
-    end_val = values.last
-
-    # Get the start time (first time value goes above minimum)
-    start_time = nil
-    values.each_with_index do |val, i|
-      break if i == values.size - 1 # Stop if we reach end of array
-      if val == start_val && values[i + 1] > start_val
-        start_time = times[i + 1]
-        break
-      end
-    end
-
-    # Get the end time (first time value goes back down to minimum)
-    end_time = nil
-    values.each_with_index do |val, i|
-      if i < values.size - 1
-        if val > end_val && values[i + 1] == end_val
-          end_time = times[i]
-          break
-        end
-      else
-        if val > end_val && values[0] == start_val # Check first hour of day for schedules that end at midnight
-          end_time = OpenStudio::Time.new(0, 24, 0, 0)
-          break
-        end
-      end
-    end
-
-    return [start_time, end_time]
-  end
-
-  # Check that the lighting, equipment, and HVAC setpoint schedules
-  # coordinate with the occupancy schedules.  This is defined as having start and end
-  # times within the specified number of hours away from the occupancy schedule.
-  def check_sch_coord(category, target_standard, max_hrs, 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 lighting, equipment, and HVAC schedules coordinate with occupancy.')
-
-    # 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
-      # Convert max hr limit to OpenStudio Time
-      max_hrs = OpenStudio::Time.new(0, max_hrs, 0, 0)
-
-      # Check schedules in each space
-      @model.getSpaces.each do |space|
-        # Occupancy, Lighting, and Equipment Schedules
-        coord_schs = []
-        occ_schs = []
-        # Get the space type (optional)
-        space_type = space.spaceType
-
-        # Occupancy
-        occs = []
-        occs += space.people # From space directly
-        occs += space_type.get.people if space_type.is_initialized # Inherited from space type
-        occs.each do |occ|
-          occ_schs << occ.numberofPeopleSchedule.get if occ.numberofPeopleSchedule.is_initialized
-        end
-
-        # Lights
-        lts = []
-        lts += space.lights # From space directly
-        lts += space_type.get.lights if space_type.is_initialized # Inherited from space type
-        lts.each do |lt|
-          coord_schs << lt.schedule.get if lt.schedule.is_initialized
-        end
-
-        # Equip
-        plugs = []
-        plugs += space.electricEquipment # From space directly
-        plugs += space_type.get.electricEquipment if space_type.is_initialized # Inherited from space type
-        plugs.each do |plug|
-          coord_schs << plug.schedule.get if plug.schedule.is_initialized
-        end
-
-        # HVAC Schedule (airloop-served zones only)
-        if space.thermalZone.is_initialized
-          zone = space.thermalZone.get
-          if zone.airLoopHVAC.is_initialized
-            coord_schs << zone.airLoopHVAC.get.availabilitySchedule
-          end
-        end
-
-        # Cannot check spaces with no occupancy schedule to compare against
-        next if occ_schs.empty?
-
-        # Get start and end occupancy times from the first occupancy schedule
-        occ_start_time, occ_end_time = get_start_and_end_times(occ_schs[0])
-
-        # Cannot check a space where the occupancy start time or end time cannot be determined
-        next if occ_start_time.nil? || occ_end_time.nil?
-
-        # Check all schedules against occupancy
-
-        # Lights should have a start and end within X hrs of the occupancy start and end
-        coord_schs.each do |coord_sch|
-          # Get start and end time of load/HVAC schedule
-          start_time, end_time = get_start_and_end_times(coord_sch)
-          if start_time.nil?
-            check_elems << OpenStudio::Attribute.new('flag', "Could not determine start time of a schedule called #{coord_sch.name}, cannot determine if schedule coordinates with occupancy schedule.")
-            next
-          elsif end_time.nil?
-            check_elems << OpenStudio::Attribute.new('flag', "Could not determine end time of a schedule called #{coord_sch.name}, cannot determine if schedule coordinates with occupancy schedule.")
-            next
-          end
-
-          # Check start time
-          if (occ_start_time - start_time) > max_hrs || (start_time - occ_start_time) > max_hrs
-            check_elems << OpenStudio::Attribute.new('flag', "The start time of #{coord_sch.name} is #{start_time}, which is more than #{max_hrs} away from the occupancy schedule start time of #{occ_start_time} for #{occ_schs[0].name} in #{space.name}.  Schedules do not coordinate.")
-          end
-
-          # Check end time
-          if (occ_end_time - end_time) > max_hrs || (end_time - occ_end_time) > max_hrs
-            check_elems << OpenStudio::Attribute.new('flag', "The end time of #{coord_sch.name} is #{end_time}, which is more than #{max_hrs} away from the occupancy schedule end time of #{occ_end_time} for #{occ_schs[0].name} in #{space.name}.  Schedules do not coordinate.")
-          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
-    # note: registerWarning and registerValue will be added for checks downstream using os_lib_reporting_qaqc.rb
-  end
-end