openstudio-calibration 0.3.1 → 0.5.1

data/lib/measures/zone_report/measure.rb

@@ -1,706 +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.
-# *******************************************************************************
-
-require 'erb'
-# require 'pry'
-
-# start the measure
-class ZoneReport < OpenStudio::Measure::ReportingMeasure
-  # define the name that a user will see, this method may be deprecated as
-  # the display name in PAT comes from the name field in measure.xml
-  def name
-    'Zone Report'
-  end
-
-  # define the arguments that the user will input
-  def arguments
-    args = OpenStudio::Measure::OSArgumentVector.new
-    args
-  end # end the arguments method
-
-  # return a vector of IdfObject's to request EnergyPlus objects needed by the run method
-  def energyPlusOutputRequests(runner, user_arguments)
-    super(runner, user_arguments)
-
-    result = OpenStudio::IdfObjectVector.new
-
-    # use the built-in error checking
-    return result unless runner.validateUserArguments(arguments, user_arguments)
-
-    request = OpenStudio::IdfObject.load('Output:Table:SummaryReports,AllSummaryAndSizingPeriod;').get
-    result << request
-
-    result
-  end
-
-  # Method to make class names nicer (remove OS and _)
-  def niceClassName(class_name)
-    class_name = class_name.gsub('OS_', '')
-    class_name = class_name.tr('_', ' ')
-    class_name
-  end
-
-  # Convert a value from the view TabularDataWithStrings from the unit represented there to the given unit.
-  # We make a bunch of special cases for unit aliases used by EnergyPlus which are not in the default
-  # list of OpenStudio conversions
-  # We also special case a few conversions for unitless 'units' so that our final display makes more sense to the user.
-  # When the property is not present (for instance, cooled beams don't have properties in the sql file under 1.5)
-  # this method will return "-" as a placeholder.
-  def eplus_to_openstudio(unitstr)
-    unitstr.gsub('m3', 'm^3').gsub('pa', 'Pa').gsub('m2', 'm^2').gsub(' per ', '/')
-  end
-
-  def convert_prop(property, final_units)
-    return ['-', '-'] unless property
-
-    return [property[0].to_f.round(2), ''] if final_units.empty?
-    return [(property[0].to_f * 100).round(2), '%'] if final_units == '%'
-    return [property[0].to_f.round(2), 'COP'] if final_units == 'COP'
-
-    initial_units = eplus_to_openstudio(property[1])
-    converted = OpenStudio.convert(property[0].to_f, initial_units, final_units)
-    if converted.empty?
-      "Could not convert from #{initial_units} to #{final_units}"
-    else
-      final_units = final_units.gsub('inH_{2}O', 'in. w.c.')
-      [converted.get.round(2), final_units]
-    end
-  end
-
-  def properties_for_cooling_coil(e, props, parent)
-    autosized = case e.iddObjectType
-                when OpenStudio::Model::CoilCoolingDXSingleSpeed.iddObjectType
-                  coil = e.to_CoilCoolingDXSingleSpeed.get
-                  coil.isRatedTotalCoolingCapacityAutosized && coil.isRatedSensibleHeatRatioAutosized && coil.isRatedAirFlowRateAutosized ? 'Yes' : 'No'
-                when OpenStudio::Model::CoilCoolingWater.iddObjectType
-                  coil = e.to_CoilCoolingWater.get
-                  coil.isDesignWaterFlowRateAutosized && coil.isDesignAirFlowRateAutosized && coil.isDesignInletWaterTemperatureAutosized ? 'Yes' : 'No'
-                when OpenStudio::Model::CoilCoolingWaterToAirHeatPumpEquationFit.iddObjectType
-                  coil = e.to_CoilCoolingWaterToAirHeatPumpEquationFit.get
-                  coil.isRatedTotalCoolingCapacityAutosized && coil.isRatedSensibleHeatRatioAutosized && coil.isRatedAirFlowRateAutosized ? 'Yes' : 'No'
-                else
-                  '?'
-                end
-
-    coolingcap = convert_prop(props['Nominal Total Capacity'], 'kBtu/hr')
-    coolingeff = convert_prop(props['Nominal Efficiency'], 'COP')
-    sensibleheatratio = convert_prop(props['Nominal Sensible Heat Ratio'], '')
-    parent_name = parent.name.get
-    name = e.name.get
-    coiltype = niceClassName(e.iddObjectType.valueName)
-
-    { 'Terminal/Zone Equip Name' => parent_name, 'Coil Type' => coiltype, 'Name' => name, 'Autosized' => autosized, 'Nominal Capacity' => coolingcap, 'Nominal Efficiency' => coolingeff, 'Nominal SHR' => sensibleheatratio }
-  end
-
-  def properties_for_heating_coil(e, props, parent)
-    autosized = '-'
-    eff_units = 'COP'
-    heatingcap = ['-', '-']
-    heatingeff = ['-', '-']
-    case e.iddObjectType
-    when OpenStudio::Model::CoilHeatingElectric.iddObjectType
-      coil = e.to_CoilHeatingElectric.get
-      autosized = coil.isNominalCapacityAutosized ? 'Yes' : 'No'
-      heatingcap = convert_prop(props['Nominal Total Capacity'], 'kW')
-      heatingeff = convert_prop(props['Nominal Efficiency'], '%')
-    when OpenStudio::Model::CoilHeatingGas.iddObjectType
-      coil = e.to_CoilHeatingGas.get
-      autosized = coil.isNominalCapacityAutosized ? 'Yes' : 'No'
-      heatingcap = convert_prop(props['Nominal Total Capacity'], 'kBtu/hr')
-      heatingeff = convert_prop(props['Nominal Efficiency'], 'COP')
-    when OpenStudio::Model::CoilHeatingDXSingleSpeed.iddObjectType
-      coil = e.to_CoilHeatingDXSingleSpeed.get
-      autosized = coil.isRatedTotalHeatingCapacityAutosized && coil.isRatedAirFlowRateAutosized ? 'Yes' : 'No'
-      heatingcap = convert_prop(props['Nominal Total Capacity'], 'kBtu/hr')
-      heatingeff = convert_prop(props['Nominal Efficiency'], 'COP')
-    when OpenStudio::Model::CoilHeatingWater.iddObjectType
-      coil = e.to_CoilHeatingWater.get
-      autosized = coil.isMaximumWaterFlowRateAutosized && coil.isRatedCapacityAutosized && coil.isUFactorTimesAreaValueAutosized ? 'Yes' : 'No'
-      heatingcap = convert_prop(props['Nominal Total Capacity'], 'kBtu/hr')
-      heatingeff = ['-', '-']
-    when OpenStudio::Model::CoilHeatingWaterBaseboard.iddObjectType
-      coil = e.to_CoilHeatingWaterBaseboard.get
-      autosized = coil.isMaximumWaterFlowRateAutosized && coil.isUFactorTimesAreaValueAutosized ? 'Yes' : 'No'
-      heatingcap = convert_prop(props['Nominal Total Capacity'], 'kBtu/hr')
-      heatingeff = ['-', '-']
-    when OpenStudio::Model::CoilHeatingWaterToAirHeatPumpEquationFit.iddObjectType
-      coil = e.to_CoilHeatingWaterToAirHeatPumpEquationFit.get
-      autosized = coil.isRatedHeatingCapacityAutosized && coil.isRatedAirFlowRateAutosized && coil.isRatedWaterFlowRateAutosized ? 'Yes' : 'No'
-      heatingcap = convert_prop(props['Nominal Total Capacity'], 'kBtu/hr')
-      heatingeff = convert_prop(props['Nominal Efficiency'], 'COP')
-    else
-      autosized = '?'
-    end
-
-    parent_name = parent.name.get
-    name = e.name.get
-    coiltype = niceClassName(e.iddObjectType.valueName)
-
-    { 'Terminal/Zone Equip Name' => parent_name, 'Coil Type' => coiltype, 'Name' => name, 'Autosized' => autosized, 'Nominal Capacity' => heatingcap, 'Nominal Efficiency' => heatingeff }
-  end
-
-  def properties_for_fan(equipment, properties, parent)
-    autosized = case equipment.iddObjectType
-                when OpenStudio::Model::FanConstantVolume.iddObjectType
-                  fan = equipment.to_FanConstantVolume.get
-                  fan.isMaximumFlowRateAutosized ? 'Yes' : 'No'
-                when OpenStudio::Model::FanVariableVolume.iddObjectType
-                  fan = equipment.to_FanVariableVolume.get
-                  fan.isMaximumFlowRateAutosized ? 'Yes' : 'No'
-                when OpenStudio::Model::FanOnOff.iddObjectType
-                  fan = equipment.to_FanOnOff.get
-                  fan.isMaximumFlowRateAutosized ? 'Yes' : 'No'
-                when OpenStudio::Model::FanZoneExhaust.iddObjectType
-                  'N/A'
-                else
-                  '?'
-                end
-
-    name = equipment.name.get
-    parent_name = parent.name.get
-    maxflowrate = convert_prop(properties['Max Air Flow Rate'], 'cfm')
-    fanpressure = convert_prop(properties['Delta Pressure'], 'inH_{2}O')
-    totalefficiency = convert_prop(properties['Total Efficiency'], '%')
-    ratedfanpower = convert_prop(properties['Rated Electric Power'], 'W')
-    { 'Terminal/Zone Equip Name' => parent_name, 'Fan Type' => niceClassName(equipment.iddObjectType.valueName), 'Name' => name, 'Autosized' => autosized, 'Max Flow' => maxflowrate, 'Efficiency' => totalefficiency, 'Pressure' => fanpressure, 'Power' => ratedfanpower }
-  end
-
-  # Each equipment is grouped into Heating, Cooling or Fans and has properties extracted appropriate for that group.
-  # This method returns a tuple [equipment group, properties] where properties is a hash of name, value or name, [value, units] pairs
-  def properties_for_zone_equipment(equipment, equipment_properties, parent)
-    # Make properties an empty hash if it was nil
-    equipment_properties ||= {}
-    if /^OS_Coil_Cooling/ =~ equipment.iddObjectType.valueName
-      return 'Cooling', properties_for_cooling_coil(equipment, equipment_properties, parent)
-    elsif /^OS_Coil_Heating/ =~ equipment.iddObjectType.valueName
-      return 'Heating', properties_for_heating_coil(equipment, equipment_properties, parent)
-    elsif /^OS_Fan/ =~ equipment.iddObjectType.valueName
-      return 'Fans', properties_for_fan(equipment, equipment_properties, parent)
-    elsif OpenStudio::Model::ZoneHVACBaseboardConvectiveElectric.iddObjectType == equipment.iddObjectType
-      baseboard = equipment.to_ZoneHVACBaseboardConvectiveElectric.get
-      autosized = baseboard.isNominalCapacityAutosized ? 'Yes' : 'No'
-      heatingcap = convert_prop(equipment_properties['Design Size Nominal Capacity'], 'kW')
-      name = baseboard.name.get
-      coiltype = niceClassName(baseboard.iddObjectType.valueName)
-      return 'Heating', { 'Terminal/Zone Equip Name' => name, 'Coil Type' => coiltype, 'Name' => name, 'Autosized' => autosized, 'Nominal Capacity' => heatingcap, 'Nominal Efficiency' => [100, '%'] }
-    else
-      return nil, nil
-    end
-  end
-
-  # define what happens when the measure is run
-  def run(runner, user_arguments)
-    super(runner, user_arguments)
-
-    # use the built-in error checking
-    return false unless runner.validateUserArguments(arguments, user_arguments)
-
-    @runner = runner
-
-    # get the last model and sql file
-
-    model = runner.lastOpenStudioModel
-    if model.empty?
-      runner.registerError('Cannot find last model.')
-      return false
-    end
-    model = model.get
-
-    @sqlFile = runner.lastEnergyPlusSqlFile
-    if @sqlFile.empty?
-      runner.registerError('Cannot find last sql file.')
-      return false
-    end
-    @sqlFile = @sqlFile.get
-    model.setSqlFile(@sqlFile)
-
-    @graph_data = []
-
-    # Collect and collate information about the hvac equipment
-    # When we are done we will have a hash of equipment keyed by equipment name
-    # who's values are hashes keyed by the property name.  The values of the
-    # property hashes are [value, unit] pairs
-    # Some types of equipment (for instance CoilCoolingCooledBeams) are not present
-    # in the database as of OS 1.5
-
-    # find table names, etc. in the SupportZoneHVACEquipFields
-    tableNames = getDataByColumn('TableName')
-    columnNames = getDataByColumn('ColumnName')
-    rowNames = getDataByColumn('RowName')
-    units = getDataByColumn('Units')
-    values = getDataByColumn('Value')
-    equipment_rows = tableNames.zip(columnNames, rowNames, units, values)
-    equipment = {}
-    equipment_rows.each do |r|
-      _, field, name, units, value = r
-      next unless name != 'None'
-      eh = equipment[name] || {}
-      eh[field] = [value, units]
-      equipment[name] = eh
-    end
-
-    @zone_collection = []
-
-    @testData = {}
-
-    # Go through each zone in the model and collect all the zone equipment
-    model.getThermalZones.sort.each do |thermalZone|
-      # Skip unconditioned zones
-      if thermalZone.thermostatSetpointDualSetpoint.empty?
-        @runner.registerInfo("Skipping #{thermalZone.name} because it is unconditioned.")
-        next
-      end
-
-      # Skip plenums
-      if thermalZone.isPlenum == true
-        @runner.registerInfo("Skipping #{thermalZone.name} because it is a plenum.")
-        next
-      end
-
-      zone_equipment = {}
-
-      thermalZone.equipment.each do |e|
-        childquipment = e.to_ParentObject.get.children
-        # Look for data on the top level equipment and each of that equipment's children
-        found_primary_heat = false
-        ([e] + childquipment).each do |ce|
-          ename = ce.name.get.upcase
-          reporting_type, equipment_properties = properties_for_zone_equipment(ce, equipment[ename], e)
-          next unless equipment_properties
-          # The first heating coil in a zone equipment chain will be primary heating; all
-          # following heating coils will be marked as Backup Heating.
-          if reporting_type == 'Heating'
-            reporting_type = 'Backup Heating' if found_primary_heat
-            found_primary_heat = true
-          end
-          # Find the priority for heating or cooling equipment - the priority is based on the 'parent' zone equipment priority
-          if reporting_type == 'Heating'
-            equipment_properties['Priority'] = (thermalZone.equipmentInHeatingOrder.index { |ze| ze.name.get == e.name.get && ze.iddObjectType == e.iddObjectType }) + 1
-          end
-          if reporting_type == 'Cooling'
-            equipment_properties['Priority'] = (thermalZone.equipmentInCoolingOrder.index { |ze| ze.name.get == e.name.get && ze.iddObjectType == e.iddObjectType }) + 1
-          end
-          # If we don't yet have equipment of this type, make a new array.  Then add
-          # our equipment information to the array and update our zone equipment hash.
-          equip_of_type = zone_equipment[reporting_type] || []
-          equip_of_type << equipment_properties
-          zone_equipment[reporting_type] = equip_of_type
-        end
-      end
-
-      zoneMetrics = {}
-      zoneMetrics[:name] = !thermalZone.name.empty? ? thermalZone.name.get : ''
-      zoneMetrics[:equipment] = zone_equipment
-      zoneMetrics[:area] = OpenStudio.convert(thermalZone.floorArea, 'm^2', 'ft^2').get.round(2)
-
-      @currentZoneName = zoneMetrics[:name]
-
-      vals = {}
-
-      vals[:va] = getDetailsData('LightingSummary', 'Entire Facility', 'Interior Lighting', "#{zoneMetrics[:name]}%", 'Lighting Power Density', 'W/m2', 'W/ft^2').round(2)
-      vals[:vb] = getDetailsData('LightingSummary', 'Entire Facility', 'Interior Lighting', "#{zoneMetrics[:name]}%", 'Full Load Hours/Week', 'hr', 'hr').round(2)
-
-      vals[:vc] = getDetailsData('EnergyMeters', 'Entire Facility', 'Annual and Peak Values - Electricity', "InteriorLights:Electricity:Zone:#{zoneMetrics[:name]}", 'Electricity Annual Value', 'GJ', 'kWh').round(2)
-
-      vals[:vd] = getDetailsData('InputVerificationandResultsSummary', 'Entire Facility', 'Zone Summary', zoneMetrics[:name], 'Plug and Process', 'W/m2', 'W/ft^2').round(2)
-
-      vals[:ve] = getDetailsData('InputVerificationandResultsSummary', 'Entire Facility', 'Zone Summary', zoneMetrics[:name], 'Area', 'm2', 'ft^2').round(2)
-
-      vals[:vf] = getDetailsData('InputVerificationandResultsSummary', 'Entire Facility', 'Zone Summary', zoneMetrics[:name], 'Conditioned (Y/N)', '', 's')
-      vals[:vf] = 'No' if vals[:vf] == ''
-
-      vals[:vg] = getDetailsData('HVACSizingSummary', 'Entire Facility', 'Zone Heating', zoneMetrics[:name], 'User Design Load', 'W', 'kBtu/hr').round(2)
-      vals[:vh] = getDetailsData('HVACSizingSummary', 'Entire Facility', 'Zone Heating', zoneMetrics[:name], 'User Design Air Flow', 'm3/s', 'ft^3/s').round(2)
-      vals[:vi] = getDetailsData('HVACSizingSummary', 'Entire Facility', 'Zone Cooling', zoneMetrics[:name], 'User Design Load', 'W', 'kBtu/hr').round(2)
-      vals[:vj] = getDetailsData('HVACSizingSummary', 'Entire Facility', 'Zone Cooling', zoneMetrics[:name], 'User Design Air Flow', 'm3/s', 'ft^3/s').round(2)
-
-      vals[:vk] = getDetailsData('OutdoorAirSummary', 'Entire Facility', 'Average Outdoor Air During Occupied Hours', zoneMetrics[:name], 'Mechanical Ventilation', 'ach', 'ach').round(2)
-      vals[:vl] = getDetailsData('OutdoorAirSummary', 'Entire Facility', 'Average Outdoor Air During Occupied Hours', zoneMetrics[:name], 'Infiltration', 'ach', 'ach').round(2)
-
-      vals[:vm] = getDetailsData('InputVerificationandResultsSummary', 'Entire Facility', 'Zone Summary', zoneMetrics[:name], 'People', 'm2 per person', 'ft^2/person').round(2)
-
-      vals[:vn] = getDetailsData('HVACSizingSummary', 'Entire Facility', 'Zone Cooling', zoneMetrics[:name], 'Date/Time Of Peak', '', 's')
-      vals[:vo] = getDetailsData('HVACSizingSummary', 'Entire Facility', 'Zone Heating', zoneMetrics[:name], 'Date/Time Of Peak', '', 's')
-
-      vals[:vp] = getDetailsData('SystemSummary', 'Entire Facility', 'Time Setpoint Not Met', zoneMetrics[:name], 'During Heating', 'hr', 'hr')
-      vals[:vq] = getDetailsData('SystemSummary', 'Entire Facility', 'Time Setpoint Not Met', zoneMetrics[:name], 'During Cooling', 'hr', 'hr')
-
-      vals[:vr] = getDetailsData('EnergyMeters', 'Entire Facility', 'Annual and Peak Values - Gas', "InteriorEquipment:Gas:Zone:#{zoneMetrics[:name]}", 'Electricity Annual Value', 'GJ', 'Therm').round(2)
-      vals[:vs] = getDetailsData('EnergyMeters', 'Entire Facility', 'Annual and Peak Values - Electricity', "InteriorEquipment:Electricity:Zone:#{zoneMetrics[:name]}", 'Electricity Annual Value', 'GJ', 'kWh').round(2)
-
-      vals[:vt] = getDetailsData('EnergyMeters', 'Entire Facility', 'Annual and Peak Values - Gas', "InteriorEquipment:Gas:Zone:#{zoneMetrics[:name]}", 'Gas Maximum  Value', 'W', 'kBtu/hr').round(2)
-      vals[:vu] = getDetailsData('EnergyMeters', 'Entire Facility', 'Annual and Peak Values - Gas', "InteriorEquipment:Gas:Zone:#{zoneMetrics[:name]}", 'Timestamp of Maximum', '', 's')
-
-      vals[:vv] = getDetailsData('EnergyMeters', 'Entire Facility', 'Annual and Peak Values - Electricity', "InteriorLights:Electricity:Zone:#{zoneMetrics[:name]}", 'Electricity Maximum Value', 'W', 'kW').round(2)
-      vals[:vw] = getDetailsData('EnergyMeters', 'Entire Facility', 'Annual and Peak Values - Electricity', "InteriorLights:Electricity:Zone:#{zoneMetrics[:name]}", 'Timestamp of Maximum', '', 's')
-
-      # X unused
-
-      vals[:vy] = getDetailsData('EnergyMeters', 'Entire Facility', 'Annual and Peak Values - Electricity', "InteriorEquipment:Electricity:Zone:#{zoneMetrics[:name]}", 'Electricity Maximum Value', 'W', 'kW').round(2)
-      vals[:vz] = getDetailsData('EnergyMeters', 'Entire Facility', 'Annual and Peak Values - Electricity', "InteriorEquipment:Electricity:Zone:#{zoneMetrics[:name]}", 'Timestamp of Maximum', '', 's')
-
-      vals[:vaa] = getDetailsData('EnergyMeters', 'Entire Facility', 'Annual and Peak Values - Other', "InteriorEquipment:DistrictHeating:Zone:#{zoneMetrics[:name]}", 'Annual Value', 'GJ', 'kBtu').round(2)
-      vals[:vab] = getDetailsData('EnergyMeters', 'Entire Facility', 'Annual and Peak Values - Other', "InteriorEquipment:DistrictHeating:Zone:#{zoneMetrics[:name]}", 'Maximum Value', 'W', 'kBtu/hr').round(2)
-      vals[:vac] = getDetailsData('EnergyMeters', 'Entire Facility', 'Annual and Peak Values - Other', "InteriorEquipment:DistrictHeating:Zone:#{zoneMetrics[:name]}", 'Timestamp of Maximum', '', 's')
-
-      vals[:vad] = getDetailsData('EnergyMeters', 'Entire Facility', 'Annual and Peak Values - Other', "Heating:EnergyTransfer:Zone:#{zoneMetrics[:name]}", 'Annual Value', 'GJ', 'kBtu').round(2)
-      vals[:vae] = (getDetailsData('EnergyMeters', 'Entire Facility', 'Annual and Peak Values - Other', "Heating:EnergyTransfer:Zone:#{zoneMetrics[:name]}", 'Maximum Value', 'W', 'kBtu/hr') / zoneMetrics[:area]).round(2)
-      vals[:vaf] = getDetailsData('EnergyMeters', 'Entire Facility', 'Annual and Peak Values - Other', "Heating:EnergyTransfer:Zone:#{zoneMetrics[:name]}", 'Timestamp of Maximum', '', 's')
-
-      vals[:vag] = getDetailsData('EnergyMeters', 'Entire Facility', 'Annual and Peak Values - Other', "Cooling:EnergyTransfer:Zone:#{zoneMetrics[:name]}", 'Annual Value', 'GJ', 'kBtu').round(2)
-      vals[:vah] = (getDetailsData('EnergyMeters', 'Entire Facility', 'Annual and Peak Values - Other', "Cooling:EnergyTransfer:Zone:#{zoneMetrics[:name]}", 'Maximum Value', 'W', 'kBtu/hr') / zoneMetrics[:area]).round(2)
-      vals[:vai] = getDetailsData('EnergyMeters', 'Entire Facility', 'Annual and Peak Values - Other', "Cooling:EnergyTransfer:Zone:#{zoneMetrics[:name]}", 'Timestamp of Maximum', '', 's')
-
-      vals[:vaj] = zoneHeatComponentCalc('People', zoneMetrics)
-      vals[:vak] = zoneHeatComponentCalc('Lights', zoneMetrics)
-      vals[:val] = zoneHeatComponentCalc('Equipment', zoneMetrics)
-      vals[:vam] = zoneHeatComponentCalc('Refrigeration', zoneMetrics)
-      vals[:van] = zoneHeatComponentCalc('Water Use Equipment', zoneMetrics)
-      vals[:vao] = zoneHeatComponentCalc('HVAC Equipment Losses', zoneMetrics)
-      vals[:vap] = zoneHeatComponentCalc('Power Generation Equipment', zoneMetrics)
-      vals[:vaq] = zoneHeatComponentCalc('Infiltration', zoneMetrics)
-      vals[:var] = zoneHeatComponentCalc('Zone Ventilation', zoneMetrics)
-      vals[:vas] = zoneHeatComponentCalc('Interzone Mixing', zoneMetrics)
-      vals[:vat] = zoneHeatComponentCalc('Exterior Wall', zoneMetrics)
-      vals[:vau] = zoneHeatComponentCalc('Interzone Wall', zoneMetrics)
-      vals[:vav] = zoneHeatComponentCalc('Ground Contact Wall', zoneMetrics)
-      vals[:vaw] = zoneHeatComponentCalc('Other Wall', zoneMetrics)
-      vals[:vax] = zoneHeatComponentCalc('Opaque Door', zoneMetrics)
-      vals[:vay] = zoneHeatComponentCalc('Roof', zoneMetrics)
-      vals[:vaz] = zoneHeatComponentCalc('Interzone Ceiling', zoneMetrics)
-      vals[:vba] = zoneHeatComponentCalc('Other Roof', zoneMetrics)
-      vals[:vbb] = zoneHeatComponentCalc('Exterior Floor', zoneMetrics)
-      vals[:vbc] = zoneHeatComponentCalc('Interzone Floor', zoneMetrics)
-      vals[:vbd] = zoneHeatComponentCalc('Ground Contact Floor', zoneMetrics)
-      vals[:vbe] = zoneHeatComponentCalc('Other Floor', zoneMetrics)
-      vals[:vbf] = zoneHeatComponentCalc('Fenestration Conduction', zoneMetrics)
-      vals[:vbg] = zoneHeatComponentCalc('Fenestration Solar', zoneMetrics)
-
-      vals[:vbh] = getDetailsData('ZoneComponentLoadSummary', (zoneMetrics[:name]).to_s, 'Heating Peak Conditions', 'Time of Peak Load', 'Value', '', 's')
-
-      vals[:vbi] = zoneCoolComponentCalc('People', zoneMetrics)
-      vals[:vbj] = zoneCoolComponentCalc('Lights', zoneMetrics)
-      vals[:vbk] = zoneCoolComponentCalc('Equipment', zoneMetrics)
-      vals[:vbl] = zoneCoolComponentCalc('Refrigeration', zoneMetrics)
-      vals[:vbm] = zoneCoolComponentCalc('Water Use Equipment', zoneMetrics)
-      vals[:vbn] = zoneCoolComponentCalc('HVAC Equipment Losses', zoneMetrics)
-      vals[:vbo] = zoneCoolComponentCalc('Power Generation Equipment', zoneMetrics)
-      vals[:vbp] = zoneCoolComponentCalc('Infiltration', zoneMetrics)
-      vals[:vbq] = zoneCoolComponentCalc('Zone Ventilation', zoneMetrics)
-      vals[:vbr] = zoneCoolComponentCalc('Interzone Mixing', zoneMetrics)
-      vals[:vbs] = zoneCoolComponentCalc('Exterior Wall', zoneMetrics)
-      vals[:vbt] = zoneCoolComponentCalc('Interzone Wall', zoneMetrics)
-      vals[:vbu] = zoneCoolComponentCalc('Ground Contact Wall', zoneMetrics)
-      vals[:vbv] = zoneCoolComponentCalc('Other Wall', zoneMetrics)
-      vals[:vbw] = zoneCoolComponentCalc('Opaque Door', zoneMetrics)
-      vals[:vbx] = zoneCoolComponentCalc('Roof', zoneMetrics)
-      vals[:vby] = zoneCoolComponentCalc('Interzone Ceiling', zoneMetrics)
-      vals[:vbz] = zoneCoolComponentCalc('Other Roof', zoneMetrics)
-      vals[:vca] = zoneCoolComponentCalc('Exterior Floor', zoneMetrics)
-      vals[:vcb] = zoneCoolComponentCalc('Interzone Floor', zoneMetrics)
-      vals[:vcc] = zoneCoolComponentCalc('Ground Contact Floor', zoneMetrics)
-      vals[:vcd] = zoneCoolComponentCalc('Other Floor', zoneMetrics)
-      vals[:vce] = zoneCoolComponentCalc('Fenestration Conduction', zoneMetrics)
-      vals[:vcf] = zoneCoolComponentCalc('Fenestration Solar', zoneMetrics)
-
-      vals[:vcg] = getDetailsData('ZoneComponentLoadSummary', (zoneMetrics[:name]).to_s, 'Cooling Peak Conditions', 'Time of Peak Load', 'Value', '', 's')
-
-      # vals = loadTestVals( vals )
-
-      vals[:sumBasicHeating] = (vals[:vaj] + vals[:vak] + vals[:val] + vals[:vam] + vals[:vaq] + vals[:var] + vals[:vas]).round(2)
-      vals[:sumBasicCooling] = (vals[:vbi] + vals[:vbj] + vals[:vbk] + vals[:vbl] + vals[:vbp] + vals[:vbq] + vals[:vbr]).round(2)
-
-      vals[:sumOtherHeating] = (vals[:van] + vals[:vao] + vals[:vap]).round(2)
-      vals[:sumOtherCooling] = (vals[:vbm] + vals[:vbn] + vals[:vbo]).round(2)
-
-      vals[:sumWallDoorHeating] = (vals[:vat] + vals[:vau] + vals[:vav] + vals[:vaw] + vals[:vax]).round(2)
-      vals[:sumWallDoorCooling] = (vals[:vbs] + vals[:vbt] + vals[:vbu] + vals[:vbv] + vals[:vbw]).round(2)
-
-      vals[:sumRoofCeilingHeating] = (vals[:vay] + vals[:vaz] + vals[:vba]).round(2)
-      vals[:sumRoofCeilingCooling] = (vals[:vbx] + vals[:vby] + vals[:vbz]).round(2)
-
-      vals[:sumFloorHeating] = (vals[:vbb] + vals[:vbc] + vals[:vbd] + vals[:vbe]).round(2)
-      vals[:sumFloorCooling] = (vals[:vca] + vals[:vcb] + vals[:vcc] + vals[:vcd]).round(2)
-
-      vals[:sumWindowsHeating] = (vals[:vbf] + vals[:vbg]).round(2)
-      vals[:sumWindowsCooling] = (vals[:vce] + vals[:vcf]).round(2)
-
-      vals[:sumHeatingTotal] = (vals[:sumBasicHeating] + vals[:sumOtherHeating] + vals[:sumWallDoorHeating] + vals[:sumRoofCeilingHeating] + vals[:sumFloorHeating] + vals[:sumWindowsHeating]).round(2)
-      vals[:sumCoolingTotal] = (vals[:sumBasicCooling] + vals[:sumOtherCooling] + vals[:sumWallDoorCooling] + vals[:sumRoofCeilingCooling] + vals[:sumFloorCooling] + vals[:sumWindowsCooling]).round(2)
-
-      zoneMetrics[:vals] = vals
-
-      @zone_collection.push(zoneMetrics)
-
-      stacked_bars(zoneMetrics)
-    end
-
-    @zone_collection = @zone_collection.sort_by { |z| z[:name] }
-
-    equipment_lengths = @zone_collection.map { |z| z[:equipment].values.map(&:length) }
-    max_zone_equipments = equipment_lengths.flatten.max
-
-    # Convert the graph data to JSON
-    # This measure requires ruby 2.0.0 to create the JSON for the report graph
-    if RUBY_VERSION >= '2.0.0'
-      require 'json'
-      @graph_data = @graph_data.to_json
-    else
-      runner.registerInfo("This Measure needs Ruby 2.0.0 to generate timeseries graphs on the report.  You have Ruby #{RUBY_VERSION}.  OpenStudio 1.4.2 and higher user Ruby 2.0.0.")
-    end
-
-    web_asset_path = OpenStudio.getSharedResourcesPath / OpenStudio::Path.new('web_assets')
-
-    html_in = getResourceFileData('report.html.in')
-
-    # configure template with variable values
-    renderer = ERB.new(html_in)
-    html_out = renderer.result(binding)
-
-    writeResourceFileData('report.html', html_out)
-    # copyResourceFile( "graph_resource.js" )
-    # copyResourceFile( "style_resource.css" )
-
-    # closing the sql file
-    @sqlFile.close
-
-    # reporting final condition
-    runner.registerFinalCondition("Successfully finished writing 'Zone Report'.")
-
-    true
-  end # end the run method
-
-  def zoneHeatComponentCalc(component, zoneMetrics)
-    (getDetailsData('ZoneComponentLoadSummary', (zoneMetrics[:name]).to_s, 'Estimated Heating Peak Load Components', component, 'Total', 'W', 'Btu/hr') / zoneMetrics[:area]).round(2)
-  end
-
-  def zoneCoolComponentCalc(component, zoneMetrics)
-    (getDetailsData('ZoneComponentLoadSummary', (zoneMetrics[:name]).to_s, 'Estimated Cooling Peak Load Components', component, 'Total', 'W', 'Btu/hr') / zoneMetrics[:area]).round(2)
-  end
-
-  def stacked_bars(zoneMetrics)
-    # people, lights, equipment, refrigeration, other, infiltration, zone ventilation,
-    # interzone mixing, walls/doors, roof/ceiling, floor, windows
-
-    vals = zoneMetrics[:vals]
-
-    heatingVals = [vals[:vaj],
-                   vals[:vak],
-                   vals[:val],
-                   vals[:vam],
-                   vals[:sumOtherHeating],
-                   vals[:vaq],
-                   vals[:var],
-                   vals[:vas],
-                   vals[:sumWallDoorHeating],
-                   vals[:sumRoofCeilingHeating],
-                   vals[:sumFloorHeating],
-                   vals[:sumWindowsHeating]]
-
-    coolingVals = [vals[:vbi],
-                   vals[:vbj],
-                   vals[:vbk],
-                   vals[:vbl],
-                   vals[:sumOtherCooling],
-                   vals[:vbp],
-                   vals[:vbq],
-                   vals[:vbr],
-                   vals[:sumWallDoorCooling],
-                   vals[:sumRoofCeilingCooling],
-                   vals[:sumFloorCooling],
-                   vals[:sumWindowsCooling]]
-
-    positiveHeating = heatingVals.select { |v| v >= 0 }.inject { |sum, x| sum + x } || 0
-    negativeHeating = heatingVals.select { |v| v < 0 }.inject { |sum, x| sum + x } || 0
-
-    positiveCooling = coolingVals.select { |v| v >= 0 }.inject { |sum, x| sum + x } || 0
-    negativeCooling = coolingVals.select { |v| v < 0 }.inject { |sum, x| sum + x } || 0
-
-    maxPositive = positiveHeating > positiveCooling ? positiveHeating : positiveCooling
-    maxNegative = negativeHeating < negativeCooling ? negativeHeating : negativeCooling
-
-    maxPositive = maxPositive == 0 ? maxNegative * -0.20 : maxPositive
-    maxNegative = maxNegative == 0 ? maxPositive * -0.10 : maxNegative
-
-    maxPositive += (maxPositive * 0.20).round(2)
-    maxNegative += (maxNegative * 0.10).round(2)
-
-    stacked_vals = [[0, maxPositive, maxNegative, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-                    [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, vals[:sumHeatingTotal], 0],
-                    [2,
-                     vals[:vaj],
-                     vals[:vak],
-                     vals[:val],
-                     vals[:vam],
-                     vals[:sumOtherHeating],
-                     vals[:vaq],
-                     vals[:var],
-                     vals[:vas],
-                     vals[:sumWallDoorHeating],
-                     vals[:sumRoofCeilingHeating],
-                     vals[:sumFloorHeating],
-                     vals[:sumWindowsHeating],
-                     0,
-                     0],
-                    [3,
-                     vals[:vbi],
-                     vals[:vbj],
-                     vals[:vbk],
-                     vals[:vbl],
-                     vals[:sumOtherCooling],
-                     vals[:vbp],
-                     vals[:vbq],
-                     vals[:vbr],
-                     vals[:sumWallDoorCooling],
-                     vals[:sumRoofCeilingCooling],
-                     vals[:sumFloorCooling],
-                     vals[:sumWindowsCooling],
-                     0,
-                     0],
-                    [4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, vals[:sumCoolingTotal]],
-                    [5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]
-
-    # Add the hourly load data to JSON for the report.html
-    graph = {}
-    graph['title'] = ''
-    graph['xaxislabel'] = ''
-    graph['yaxislabel'] = 'Contribution Btu/hr/ft2'
-    graph['labels'] = ['index', 'people', 'lights', 'equipment', 'refrigeration', 'other', 'infiltration', 'zone_ventilation', 'interzone_mixing', 'walls/doors', 'roof/ceiling', 'floor', 'windows', 'net/heating', 'net/cooling']
-    graph['colors'] = ['#888855', '#AAAA55', '#3333AA', '#8888FF', '#888888', '#9999FF', '#AAAAFF', '#AA6666', '#777733', '#888833', '#999933', '#9999FF', '#FF9999', '#9999FF']
-    graph['data'] = stacked_vals
-
-    @graph_data << graph
-end
-
-  def getPctLoad(val, total)
-    if val != '' && total != 0
-      (val * 100 / total).round(2)
-    else
-      0
-    end
-  end
-
-  def getResourceFileData(fileName)
-    data_in_path = "#{File.dirname(__FILE__)}/resources/#{fileName}"
-    unless File.exist?(data_in_path)
-      data_in_path = "#{File.dirname(__FILE__)}/#{fileName}"
-    end
-
-    html_in = ''
-    File.open(data_in_path, 'r') do |file|
-      html_in = file.read
-    end
-
-    html_in
-  end
-
-  def writeResourceFileData(fileName, data)
-    File.open("./#{fileName}", 'w') do |file|
-      file << data
-      # make sure data is written to the disk one way or the other
-      begin
-        file.fsync
-      rescue StandardError
-        file.flush
-      end
-    end
-  end
-
-  # Fetch a value from the tabulardatawithstrings database view
-  # If final_units is "s" the value is returned unchanged as a string
-  # Otherwise the value is converted from units to final_units - units is specified in energy plus style (m2, m3, etc)
-  # and final_units should be open studio style (m^2, m^3, ...)
-  # If the data is not found or cannot be converted a warning is registered and "" or 0.0 is returned.
-  def getDetailsData(report, forstring, table, row, column, units, final_units)
-    forstring.upcase! if report == 'ZoneComponentLoadSummary'
-
-    str_HVACEquipment_query = 'SELECT Value FROM tabulardatawithstrings WHERE '
-    str_HVACEquipment_query << "ReportName='#{report}' AND "
-    str_HVACEquipment_query << "ReportForString='#{forstring}' AND "
-    str_HVACEquipment_query << "TableName='#{table}' AND "
-    str_HVACEquipment_query << "RowName LIKE '#{row}' AND "
-    str_HVACEquipment_query << "ColumnName='#{column}' AND "
-    str_HVACEquipment_query << "Units='#{units}'"
-
-    query_results = @sqlFile.execAndReturnFirstString(str_HVACEquipment_query)
-
-    if query_results.empty?
-
-      @runner.registerWarning("Could not get data for #{report} #{forstring} #{table} #{row} #{column}.")
-      return final_units == 's' ? '' : 0.0
-
-    else
-      r = query_results.get
-      if report == 'ZoneComponentLoadSummary'
-        @testData["#{@currentZoneName}_#{table}_#{row}"] = r
-      end
-
-      if final_units == 's'
-        return r
-      else
-        converted = OpenStudio.convert(r.to_f, eplus_to_openstudio(units), final_units)
-        if converted.empty?
-          @runner.registerError("Could not convert #{r} from #{units} to #{final_units}")
-          return 0.0
-        else
-          return converted.get.round(2)
-        end
-      end
-
-    end
-  end
-
-  def getDataByColumn(colName)
-    strvec_HVACEquipment_query = "SELECT #{colName} FROM tabulardatawithstrings WHERE "
-    strvec_HVACEquipment_query << "ReportName='EquipmentSummary' and "
-    strvec_HVACEquipment_query << "ReportForString='Entire Facility'"
-    strvec_HVACEquipment_query << 'ORDER BY TableName, ColumnName, RowName, Units, Value'
-
-    query_results = @sqlFile.execAndReturnVectorOfString(strvec_HVACEquipment_query).get
-
-    if query_results.empty?
-      @runner.registerError("Could not get data for requested Column #{colName}.")
-      return []
-    else
-      return query_results
-    end
-  end
-
-  # Accessor to support unit tests
-  attr_reader :zone_collection
-end # end the measure
-
-# this allows the measure to be use by the application
-ZoneReport.new.registerWithApplication