openstudio-calibration 0.1.2

data/lib/measures/WaterHeaterMixedPercentChange/measure.xml

@@ -0,0 +1,180 @@
+<measure>
+  <schema_version>3.0</schema_version>
+  <name>water_heater_mixed_percent_change</name>
+  <uid>c42bf4e7-2bbb-44c6-ab91-e6ddb53e050d</uid>
+  <version_id>414fa696-b1c4-41b2-a1e2-1904af51cf16</version_id>
+  <version_modified>20200325T030949Z</version_modified>
+  <xml_checksum>D28BCE9C</xml_checksum>
+  <class_name>WaterHeaterMixedPercentChange</class_name>
+  <display_name>Water Heater Mixed Percent Change</display_name>
+  <description>This is a general purpose measure to calibrate WaterHeaterMixed with a Percent Change.</description>
+  <modeler_description>It will be used for calibration of WaterHeaterMixed. User can choose between a SINGLE WaterHeaterMixed or ALL the WaterHeaterMixed objects.</modeler_description>
+  <arguments>
+    <argument>
+      <name>water_heater</name>
+      <display_name>Apply the Measure to a SINGLE WaterHeaterMixed, ALL the WaterHeaterMixeds or NONE.</display_name>
+      <type>Choice</type>
+      <required>true</required>
+      <model_dependent>false</model_dependent>
+      <default_value>*All WaterHeaterMixeds*</default_value>
+      <choices>
+        <choice>
+          <value>{ae86c587-54d9-4c1a-b9f4-b9c4b80a0059}</value>
+          <display_name>*All WaterHeaterMixeds*</display_name>
+        </choice>
+        <choice>
+          <value>0</value>
+          <display_name>*None*</display_name>
+        </choice>
+      </choices>
+    </argument>
+    <argument>
+      <name>maximum_capacity_multiplier</name>
+      <display_name>Percent Change for Heater Maximum Capacity.</display_name>
+      <description>Percent Change for Heater Maximum Capacity.</description>
+      <type>Double</type>
+      <required>true</required>
+      <model_dependent>false</model_dependent>
+      <default_value>0</default_value>
+    </argument>
+    <argument>
+      <name>minimum_capacity_multiplier</name>
+      <display_name>Percent Change for Heater Minimum Capacity.</display_name>
+      <description>Percent Change for Heater Minimum Capacity.</description>
+      <type>Double</type>
+      <required>true</required>
+      <model_dependent>false</model_dependent>
+      <default_value>0</default_value>
+    </argument>
+    <argument>
+      <name>thermal_efficiency_multiplier</name>
+      <display_name>Percent Change for Thermal Efficiency.</display_name>
+      <description>Percent Change for Thermal Efficiency.</description>
+      <type>Double</type>
+      <required>true</required>
+      <model_dependent>false</model_dependent>
+      <default_value>0</default_value>
+    </argument>
+    <argument>
+      <name>fuel_type</name>
+      <display_name>Heater Fuel Type.</display_name>
+      <description>Heater Fuel Type.</description>
+      <type>Choice</type>
+      <required>true</required>
+      <model_dependent>false</model_dependent>
+      <default_value>NaturalGas</default_value>
+      <choices>
+        <choice>
+          <value>NaturalGas</value>
+          <display_name>NaturalGas</display_name>
+        </choice>
+        <choice>
+          <value>Electricity</value>
+          <display_name>Electricity</display_name>
+        </choice>
+        <choice>
+          <value>PropaneGas</value>
+          <display_name>PropaneGas</display_name>
+        </choice>
+      </choices>
+    </argument>
+  </arguments>
+  <outputs/>
+  <provenances/>
+  <tags>
+    <tag>Service Water Heating.Water Heating</tag>
+  </tags>
+  <attributes>
+    <attribute>
+      <name>Intended Software Tool</name>
+      <value>Analysis Spreadsheet</value>
+      <datatype>string</datatype>
+    </attribute>
+    <attribute>
+      <name>Intended Use Case</name>
+      <value>Model Articulation</value>
+      <datatype>string</datatype>
+    </attribute>
+    <attribute>
+      <name>Intended Use Case</name>
+      <value>Calibration</value>
+      <datatype>string</datatype>
+    </attribute>
+    <attribute>
+      <name>Intended Use Case</name>
+      <value>Sensitivity Analysis</value>
+      <datatype>string</datatype>
+    </attribute>
+    <attribute>
+      <name>Measure Type</name>
+      <value>ModelMeasure</value>
+      <datatype>string</datatype>
+    </attribute>
+    <attribute>
+      <name>Intended Software Tool</name>
+      <value>Apply Measure Now</value>
+      <datatype>string</datatype>
+    </attribute>
+    <attribute>
+      <name>Intended Software Tool</name>
+      <value>OpenStudio Application</value>
+      <datatype>string</datatype>
+    </attribute>
+    <attribute>
+      <name>Intended Software Tool</name>
+      <value>Parametric Analysis Tool</value>
+      <datatype>string</datatype>
+    </attribute>
+    <attribute>
+      <name>Intended Software Tool</name>
+      <value>Analysis Spreadsheet</value>
+      <datatype>string</datatype>
+    </attribute>
+    <attribute>
+      <name>Intended Use Case</name>
+      <value>Model Articulation</value>
+      <datatype>string</datatype>
+    </attribute>
+    <attribute>
+      <name>Intended Use Case</name>
+      <value>Calibration</value>
+      <datatype>string</datatype>
+    </attribute>
+    <attribute>
+      <name>Intended Use Case</name>
+      <value>Sensitivity Analysis</value>
+      <datatype>string</datatype>
+    </attribute>
+  </attributes>
+  <files>
+    <file>
+      <filename>LICENSE.md</filename>
+      <filetype>md</filetype>
+      <usage_type>license</usage_type>
+      <checksum>E0468DD6</checksum>
+    </file>
+    <file>
+      <filename>README.md.erb</filename>
+      <filetype>erb</filetype>
+      <usage_type>readmeerb</usage_type>
+      <checksum>703C9964</checksum>
+    </file>
+    <file>
+      <filename>README.md</filename>
+      <filetype>md</filetype>
+      <usage_type>readme</usage_type>
+      <checksum>04987893</checksum>
+    </file>
+    <file>
+      <version>
+        <software_program>OpenStudio</software_program>
+        <identifier>2.1.0</identifier>
+        <min_compatible>2.1.0</min_compatible>
+      </version>
+      <filename>measure.rb</filename>
+      <filetype>rb</filetype>
+      <usage_type>script</usage_type>
+      <checksum>019A4EE1</checksum>
+    </file>
+  </files>
+</measure>

data/lib/measures/zone_report/LICENSE.md

@@ -0,0 +1,27 @@
+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 HOLDERS AND 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, THE UNITED STATES GOVERNMENT, 
+OR ANY CONTRIBUTORS 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.

data/lib/measures/zone_report/README.md

@@ -0,0 +1,26 @@
+
+
+###### (Automatically generated documentation)
+
+# Zone Report
+
+## Description
+
+
+## Modeler Description
+
+
+## Measure Type
+ReportingMeasure
+
+## Taxonomy
+
+
+## Arguments
+
+
+
+
+This measure does not have any user arguments
+
+

data/lib/measures/zone_report/README.md.erb

@@ -0,0 +1,42 @@
+<%#= README.md.erb is used to auto-generate README.md. %>
+<%#= To manually maintain README.md throw away README.md.erb and manually edit README.md %>
+###### (Automatically generated documentation)
+
+# <%= name %>
+
+## Description
+<%= description %>
+
+## Modeler Description
+<%= modelerDescription %>
+
+## Measure Type
+<%= measureType %>
+
+## Taxonomy
+<%= taxonomy %>
+
+## Arguments
+
+<% arguments.each do |argument| %>
+### <%= argument[:display_name] %>
+<%= argument[:description] %>
+**Name:** <%= argument[:name] %>,
+**Type:** <%= argument[:type] %>,
+**Units:** <%= argument[:units] %>,
+**Required:** <%= argument[:required] %>,
+**Model Dependent:** <%= argument[:model_dependent] %>
+<% end %>
+
+<% if arguments.size == 0 %>
+<%= "This measure does not have any user arguments" %>
+<% end %>
+
+<% if outputs.size > 0 %>
+## Outputs
+<% output_names = [] %>
+<% outputs.each do |output| %>
+<% output_names << output[:display_name] %>
+<% end %>
+<%= output_names.join(", ") %>
+<% end %>

data/lib/measures/zone_report/measure.rb

@@ -0,0 +1,706 @@
+# *******************************************************************************
+# 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'] = %w[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