Class: ZoneReport

Inherits:
OpenStudio::Measure::ReportingMeasure
  • Object
show all
Defined in:
lib/measures/ZoneReport/measure.rb

Overview

start the measure

Instance Attribute Summary collapse

Instance Method Summary collapse

Instance Attribute Details

#component_loads ⇒ Object (readonly)

Returns the value of attribute component_loads.



12
13
14
 
# File 'lib/measures/ZoneReport/measure.rb', line 12

def component_loads
  @component_loads
end

#zone_collection ⇒ Object (readonly)

Returns the value of attribute zone_collection.



13
14
15
 
# File 'lib/measures/ZoneReport/measure.rb', line 13

def zone_collection
  @zone_collection
end

Instance Method Details

#arguments(model = nil) ⇒ Object

define the arguments that the user will input



22
23
24
25
 
# File 'lib/measures/ZoneReport/measure.rb', line 22

def arguments(model = nil)
  args = OpenStudio::Measure::OSArgumentVector.new
  return args
end

#convert_prop(property, final_units) ⇒ Object 



61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
 
# File 'lib/measures/ZoneReport/measure.rb', line 61

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

#energyPlusOutputRequests(runner, user_arguments) ⇒ Object

return a vector of IdfObject’s to request EnergyPlus objects needed by the run method



28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
 
# File 'lib/measures/ZoneReport/measure.rb', line 28

def energyPlusOutputRequests(runner, user_arguments)
  super(runner, user_arguments)

  result = OpenStudio::IdfObjectVector.new

  # use the built-in error checking
  if !runner.validateUserArguments(arguments, user_arguments)
    return result
  end

  request = OpenStudio::IdfObject.load('Output:Table:SummaryReports,AllSummaryAndSizingPeriod;').get
  result << request

  return result
end

#eplus_to_openstudio(unitstr) ⇒ Object

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.



57
58
59
 
# File 'lib/measures/ZoneReport/measure.rb', line 57

def eplus_to_openstudio(unitstr)
  unitstr.gsub('m3', 'm^3').gsub('pa', 'Pa').gsub('m2', 'm^2').gsub(' per ', '/')
end

#getDataByColumn(colName) ⇒ Object 



691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
 
# File 'lib/measures/ZoneReport/measure.rb', line 691

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 false
  else
    return query_results
  end
end

#getDetailsData(report, forstring, table, row, column, units, final_units) ⇒ Object

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.



649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
 
# File 'lib/measures/ZoneReport/measure.rb', line 649

def getDetailsData(report, forstring, table, row, column, units, final_units)
  if report == 'Zone Component Load Summary'
    forstring.upcase!
  end

  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?

    # todo - is there any valid reason data might not be found? If not then make error isntead of warning
    @runner.registerWarning("Could not get data for report:#{report} For:#{forstring} table:#{table} row:#{row} column:#{column}.")
    return final_units == 's' ? '' : 0.0

  else
    r = query_results.get
    if report == 'Zone Component Load Summary'
      @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 false
      else
        return converted.get.round(2)
      end
    end

  end
end

#getPctLoad(val, total) ⇒ Object 



610
611
612
613
614
615
616
 
# File 'lib/measures/ZoneReport/measure.rb', line 610

def getPctLoad(val, total)
  if val != '' && total != 0
    return (val * 100 / total).round(2)
  else
    return 0
  end
end

#getResourceFileData(fileName) ⇒ Object 



618
619
620
621
622
623
624
625
626
627
628
629
630
 
# File 'lib/measures/ZoneReport/measure.rb', line 618

def getResourceFileData(fileName)
  data_in_path = "#{File.dirname(__FILE__)}/resources/#{fileName}"
  if !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

#name ⇒ Object

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



17
18
19
 
# File 'lib/measures/ZoneReport/measure.rb', line 17

def name
  return 'Zone Report'
end

#niceClassName(class_name) ⇒ Object

Method to make class names nicer (remove OS and _)



45
46
47
48
49
 
# File 'lib/measures/ZoneReport/measure.rb', line 45

def niceClassName(class_name)
  class_name = class_name.gsub('OS_', '')
  class_name = class_name.tr('_', ' ')
  return class_name
end

#properties_for_cooling_coil(e, props, parent) ⇒ Object 



78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
 
# File 'lib/measures/ZoneReport/measure.rb', line 78

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

#properties_for_fan(equipment, properties, parent) ⇒ Object 



150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
 
# File 'lib/measures/ZoneReport/measure.rb', line 150

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

#properties_for_heating_coil(e, props, parent) ⇒ Object 



103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
 
# File 'lib/measures/ZoneReport/measure.rb', line 103

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

#properties_for_zone_equipment(equipment, equipment_properties, parent) ⇒ Object

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



178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
 
# File 'lib/measures/ZoneReport/measure.rb', line 178

def properties_for_zone_equipment(equipment, equipment_properties, parent)
  # Make properties an empty hash if it was nil
  equipment_properties ||= {}
  if /^OS_Coil_Cooling/.match?(equipment.iddObjectType.valueName)
    return 'Cooling', properties_for_cooling_coil(equipment, equipment_properties, parent)
  elsif /^OS_Coil_Heating/.match?(equipment.iddObjectType.valueName)
    return 'Heating', properties_for_heating_coil(equipment, equipment_properties, parent)
  elsif /^OS_Fan/.match?(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

#run(runner, user_arguments) ⇒ Object

define what happens when the measure is run



200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
 
# File 'lib/measures/ZoneReport/measure.rb', line 200

def run(runner, user_arguments)
  super(runner, user_arguments)

  # use the built-in error checking
  if !runner.validateUserArguments(arguments, user_arguments)
    return false
  end

  @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

  # check if the Component Load Summary reports have been produced by EnergyPlus,
  # which are needed for the Peak Heating Load and Peak Cooling Load tables
  @component_loads = {}
  if model.getOutputTableSummaryReports.summaryReports.any? { |r| r.include?('SizingPeriod') }
    @component_loads[:report] = true
  else
    @component_loads[:report] = false
    message = 'WARNING: The Component Load Summary reports were not produced by EnergyPlus, which are required by the Peak Heating Load and Peak Cooling Load tables.'
    @component_loads[:message] = message
    runner.registerWarning(message)
  end

  @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
    if name != 'None'
      eh = equipment[name] || {}
      eh[field] = [value, units]
      equipment[name] = eh
    end
  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)
        if 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
    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('Input Verification and Results Summary', 'Entire Facility', 'Zone Summary', "#{zoneMetrics[:name].upcase}", 'Lighting[W/m2]', 'W/m2', 'W/ft^2').round(2)
    #vals[:va] = getDetailsData('Initialization Summary', 'Entire Facility', 'Zone Internal Gains Nominal', "#{zoneMetrics[:name].upcase}", 'Interior Lighting', 'W/m2', 'W/ft^2').round(2)
    # 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')
    if vals[:vf] == '' then vals[:vf] = 'No' end

    vals[:vg] = getDetailsData('HVACSizingSummary', 'Entire Facility', 'Zone Sensible Heating', zoneMetrics[:name], 'User Design Load', 'W', 'kBtu/hr').round(2)
    vals[:vh] = getDetailsData('HVACSizingSummary', 'Entire Facility', 'Zone Sensible Heating', zoneMetrics[:name], 'User Design Air Flow', 'm3/s', 'ft^3/s').round(2)
    vals[:vi] = getDetailsData('HVACSizingSummary', 'Entire Facility', 'Zone Sensible Cooling', zoneMetrics[:name], 'User Design Load', 'W', 'kBtu/hr').round(2)
    vals[:vj] = getDetailsData('HVACSizingSummary', 'Entire Facility', 'Zone Sensible 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 Sensible Cooling', zoneMetrics[:name], 'Date/Time Of Peak {TIMESTAMP}', '', 's')
    vals[:vo] = getDetailsData('HVACSizingSummary', 'Entire Facility', 'Zone Sensible Heating', zoneMetrics[:name], 'Date/Time Of Peak {TIMESTAMP}', '', '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 - Natural Gas', "InteriorEquipment:NaturalGas:Zone:#{zoneMetrics[:name]}", 'Natural Gas 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 - Natural Gas', "InteriorEquipment:NaturalGas:Zone:#{zoneMetrics[:name]}", 'Natural Gas Maximum Value', 'W', 'kBtu/hr').round(2)
    vals[:vu] = getDetailsData('EnergyMeters', 'Entire Facility', 'Annual and Peak Values - Natural Gas', "InteriorEquipment:NaturalGas:Zone:#{zoneMetrics[:name]}", 'Timestamp of Maximum {TIMESTAMP}', '', '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 {TIMESTAMP}', '', 's')

    # calculate lighting values based on EnergyMeters, which has data by zone
    # instead of Lighting Summary, which has data by space

    # W/ft2
    vals[:va] = (vals[:vv] * 1000 / zoneMetrics[:area]).round(2)

    # kWh / kW = full load hours
    vals[:vb] = (vals[:vc] / vals[:vv]).round(2)

    # 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 {TIMESTAMP}', '', 's')

    # vals[:vaa] = getDetailsData('EnergyMeters', 'Entire Facility', 'Annual and Peak Values - Other', "InteriorEquipment:DistrictHeatingWater:Zone:#{zoneMetrics[:name]}", 'Annual Value', 'GJ', 'kBtu').round(2)
    # vals[:vab] = getDetailsData('EnergyMeters', 'Entire Facility', 'Annual and Peak Values - Other', "InteriorEquipment:DistrictHeatingWater:Zone:#{zoneMetrics[:name]}", 'Maximum Value', 'W', 'kBtu/hr').round(2)
    # vals[:vac] = getDetailsData('EnergyMeters', 'Entire Facility', 'Annual and Peak Values - Other', "InteriorEquipment:DistrictHeatingWater:Zone:#{zoneMetrics[:name]}", 'Timestamp of Maximum {TIMESTAMP}', '', '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 {TIMESTAMP}', '', '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 {TIMESTAMP}', '', '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('Zone Component Load Summary', (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('Zone Component Load Summary', (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'.")

  return true
end

#stacked_bars(zoneMetrics) ⇒ Object 



516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
 
# File 'lib/measures/ZoneReport/measure.rb', line 516

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

#writeResourceFileData(fileName, data) ⇒ Object 



632
633
634
635
636
637
638
639
640
641
642
 
# File 'lib/measures/ZoneReport/measure.rb', line 632

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

#zoneCoolComponentCalc(component, zoneMetrics) ⇒ Object 



512
513
514
 
# File 'lib/measures/ZoneReport/measure.rb', line 512

def zoneCoolComponentCalc(component, zoneMetrics)
  (getDetailsData('Zone Component Load Summary', (zoneMetrics[:name]).to_s, 'Estimated Cooling Peak Load Components', component, 'Total', 'W', 'Btu/hr') / zoneMetrics[:area]).round(2)
end

#zoneHeatComponentCalc(component, zoneMetrics) ⇒ Object 



508
509
510
 
# File 'lib/measures/ZoneReport/measure.rb', line 508

def zoneHeatComponentCalc(component, zoneMetrics)
  (getDetailsData('Zone Component Load Summary', (zoneMetrics[:name]).to_s, 'Estimated Heating Peak Load Components', component, 'Total', 'W', 'Btu/hr') / zoneMetrics[:area]).round(2)
end