urbanopt-scenario 0.1.1 → 0.3.0

data/docs/package.json

@@ -13,7 +13,7 @@
     "highlight.js": "^9.15.6",
     "json-schema-ref-parser": "^6.1.0",
     "json-schema-view-js": "git+https://git@github.com/bgschiller/json-schema-view-js.git",
-    "vuepress": "^0.14.10",
+    "vuepress": "^1.2.0",
     "webpack-dev-middleware": "^3.6.0"
   },
   "devDependencies": {

data/lib/measures/.rubocop.yml

@@ -2,4 +2,4 @@ AllCops:
   Exclude:
     - 'spec/test_measures/**/*'
 inherit_from:
-  - http://s3.amazonaws.com/openstudio-resources/styles/rubocop.yml
+  - http://s3.amazonaws.com/openstudio-resources/styles/rubocop_v3.yml

data/lib/measures/default_feature_reports/LICENSE.md

@@ -1,4 +1,4 @@
-URBANopt, Copyright (c) 2019, Alliance for Sustainable Energy, LLC, and other 
+URBANopt, Copyright (c) 2019-2020, Alliance for Sustainable Energy, LLC, and other 
 contributors. All rights reserved.
 
 Redistribution and use in source and binary forms, with or without modification, 

data/lib/measures/default_feature_reports/README.md

@@ -2,16 +2,16 @@
 
 ###### (Automatically generated documentation)
 
-# DefaultFeatureReports
+# 
 
 ## Description
-Writes default_feature_reports.json file used by URBANopt Scenario Default Post Processor
+
 
 ## Modeler Description
-This measure only allows for one feature_report per simulation. If multiple features are simulated in a single simulation, a new measure must be written to disaggregate simulation results to multiple features.
+
 
 ## Measure Type
-ReportingMeasure
+ModelMeasure
 
 ## Taxonomy
 
@@ -19,38 +19,8 @@ ReportingMeasure
 ## Arguments
 
 
-### Feature unique identifier
-
-**Name:** feature_id,
-**Type:** String,
-**Units:** ,
-**Required:** false,
-**Model Dependent:** false
-
-### Feature scenario specific name
-
-**Name:** feature_name,
-**Type:** String,
-**Units:** ,
-**Required:** false,
-**Model Dependent:** false
-
-### URBANopt Feature Type
-
-**Name:** feature_type,
-**Type:** String,
-**Units:** ,
-**Required:** false,
-**Model Dependent:** false
-
-### Reporting Frequency
-The frequency at which to report timeseries output data.
-**Name:** reporting_frequency,
-**Type:** Choice,
-**Units:** ,
-**Required:** true,
-**Model Dependent:** false
 
 
+This measure does not have any user arguments
 
 

data/lib/measures/default_feature_reports/measure.rb

@@ -44,7 +44,7 @@ class DefaultFeatureReports < OpenStudio::Measure::ReportingMeasure
 
   # human readable description
   def description
-    return 'Writes default_feature_reports.json file used by URBANopt Scenario Default Post Processor'
+    return 'Writes default_feature_reports.json and default_feature_reports.csv files used by URBANopt Scenario Default Post Processor'
   end
 
   # human readable description of modeling approach
@@ -77,7 +77,8 @@ class DefaultFeatureReports < OpenStudio::Measure::ReportingMeasure
     reporting_frequency_chs << 'Timestep'
     reporting_frequency_chs << 'Hourly'
     reporting_frequency_chs << 'Daily'
-    # reporting_frequency_chs << "BillingPeriod" # match it to utility bill object
+    # reporting_frequency_chs << 'Zone Timestep'
+    reporting_frequency_chs << 'BillingPeriod' # match it to utility bill object
     ## Utility report here to report the start and end for each fueltype
     reporting_frequency_chs << 'Monthly'
     reporting_frequency_chs << 'Runperiod'
@@ -85,17 +86,13 @@ class DefaultFeatureReports < OpenStudio::Measure::ReportingMeasure
     reporting_frequency = OpenStudio::Measure::OSArgument.makeChoiceArgument('reporting_frequency', reporting_frequency_chs, true)
     reporting_frequency.setDisplayName('Reporting Frequency')
     reporting_frequency.setDescription('The frequency at which to report timeseries output data.')
-    reporting_frequency.setDefaultValue('Hourly')
+    reporting_frequency.setDefaultValue('Timestep')
     args << reporting_frequency
 
-    # move this in the run method
-    if reporting_frequency.defaultValueDisplayName == 'BillingPeriod'
-      @@logger.error('BillingPeriod frequency is not implemented yet')
-    end
-
     return args
   end
 
+  # define fuel types
   def fuel_types
     fuel_types = [
       'Electricity',
@@ -109,6 +106,7 @@ class DefaultFeatureReports < OpenStudio::Measure::ReportingMeasure
     return fuel_types
   end
 
+  # define enduses
   def end_uses
     end_uses = [
       'Heating',
@@ -131,6 +129,24 @@ class DefaultFeatureReports < OpenStudio::Measure::ReportingMeasure
     return end_uses
   end
 
+  # format datetime
+  def format_datetime(date_time)
+    date_time.tr!('-', '/')
+    date_time.gsub!('Jan', '01')
+    date_time.gsub!('Feb', '02')
+    date_time.gsub!('Mar', '03')
+    date_time.gsub!('Apr', '04')
+    date_time.gsub!('May', '05')
+    date_time.gsub!('Jun', '06')
+    date_time.gsub!('Jul', '07')
+    date_time.gsub!('Aug', '08')
+    date_time.gsub!('Sep', '09')
+    date_time.gsub!('Oct', '10')
+    date_time.gsub!('Nov', '11')
+    date_time.gsub!('Dec', '12')
+    return date_time
+  end
+
   # return a vector of IdfObject's to request EnergyPlus objects needed by the run method
   # rubocop:disable Naming/MethodName
   def energyPlusOutputRequests(runner, user_arguments)
@@ -152,17 +168,30 @@ class DefaultFeatureReports < OpenStudio::Measure::ReportingMeasure
       end
     end
 
-    ### Request the output for each end use/fuel type combination
+    # Request the output for each end use/fuel type combination
     result << OpenStudio::IdfObject.load("Output:Meter:MeterFileOnly,Electricity:Facility,#{reporting_frequency};").get
     result << OpenStudio::IdfObject.load("Output:Meter:MeterFileOnly,ElectricityProduced:Facility,#{reporting_frequency};").get
     result << OpenStudio::IdfObject.load("Output:Meter:MeterFileOnly,Gas:Facility,#{reporting_frequency};").get
     result << OpenStudio::IdfObject.load("Output:Meter:MeterFileOnly,DistrictCooling:Facility,#{reporting_frequency};").get
     result << OpenStudio::IdfObject.load("Output:Meter:MeterFileOnly,DistrictHeating:Facility,#{reporting_frequency};").get
+    # result << OpenStudio::IdfObject.load("Output:Meter:MeterFileOnly,Cooling:Electricity,#{reporting_frequency};").get
+    # result << OpenStudio::IdfObject.load("Output:Meter:MeterFileOnly,Heating:Electricity,#{reporting_frequency};").get
+    # result << OpenStudio::IdfObject.load("Output:Meter:MeterFileOnly,InteriorLights:Electricity,#{reporting_frequency};").get
+    # result << OpenStudio::IdfObject.load("Output:Meter:MeterFileOnly,ExteriorLights:Electricity,#{reporting_frequency};").get
+    # result << OpenStudio::IdfObject.load("Output:Meter:MeterFileOnly,InteriorEquipment:Electricity,#{reporting_frequency};").get
+    # result << OpenStudio::IdfObject.load("Output:Meter:MeterFileOnly,Fans:Electricity,#{reporting_frequency};").get
+    # result << OpenStudio::IdfObject.load("Output:Meter:MeterFileOnly,Pumps:Electricity,#{reporting_frequency};").get
+    # result << OpenStudio::IdfObject.load("Output:Meter:MeterFileOnly,WaterSystems:Electricity,#{reporting_frequency};").get
+    # result << OpenStudio::IdfObject.load("Output:Meter:MeterFileOnly,Heating:Gas,#{reporting_frequency};").get
+    # result << OpenStudio::IdfObject.load("Output:Meter:MeterFileOnly,WaterSystems:Gas,#{reporting_frequency};").get
+    # result << OpenStudio::IdfObject.load("Output:Meter:MeterFileOnly,InteriorEquipment:Gas,#{reporting_frequency};").get
+    result << OpenStudio::IdfObject.load('Output:Variable,*,Heating Coil Heating Rate,hourly; !- HVAC Average [W];').get
 
     timeseries_data = ['District Cooling Chilled Water Rate', 'District Cooling Mass Flow Rate',
                        'District Cooling Inlet Temperature', 'District Cooling Outlet Temperature',
                        'District Heating Hot Water Rate', 'District Heating Mass Flow Rate',
-                       'District Heating Inlet Temperature', 'District Heating Outlet Temperature']
+                       'District Heating Inlet Temperature', 'District Heating Outlet Temperature', 'Cooling Coil Total Cooling Rate',
+                       'Heating Coil Heating Rate']
 
     timeseries_data.each do |ts|
       result << OpenStudio::IdfObject.load("Output:Variable,*,#{ts},#{reporting_frequency};").get
@@ -229,6 +258,11 @@ class DefaultFeatureReports < OpenStudio::Measure::ReportingMeasure
     # Assign the user inputs to variables
     reporting_frequency = runner.getStringArgumentValue('reporting_frequency', user_arguments)
 
+    # BilingPeriod reporting frequency not implemented yet
+    if reporting_frequency == 'BillingPeriod'
+      @@logger.error('BillingPeriod frequency is not implemented yet')
+    end
+
     # cache runner for this instance of the measure
     @runner = runner
 
@@ -271,7 +305,10 @@ class DefaultFeatureReports < OpenStudio::Measure::ReportingMeasure
     feature_report.name = feature_name
     feature_report.feature_type = feature_type
     feature_report.directory_name = workflow.absoluteRunDir
-    feature_report.timesteps_per_hour = model.getTimestep.numberOfTimestepsPerHour
+
+    timesteps_per_hour = model.getTimestep.numberOfTimestepsPerHour
+    feature_report.timesteps_per_hour = timesteps_per_hour
+
     feature_report.simulation_status = 'Complete'
 
     feature_report.reporting_periods << URBANopt::Scenario::DefaultReports::ReportingPeriod.new
@@ -434,6 +471,10 @@ class DefaultFeatureReports < OpenStudio::Measure::ReportingMeasure
     aspect_ratio ||= nil
     feature_report.program.aspect_ratio = aspect_ratio
 
+    # total_construction_cost
+    total_construction_cost = sql_query(runner, sql_file, 'Life-Cycle Cost Report', "TableName='Present Value for Recurring, Nonrecurring and Energy Costs (Before Tax)' AND RowName='LCC_MAT - BUILDING - LIFE CYCLE COSTS' AND ColumnName='Cost'")
+    feature_report.program.total_construction_cost = total_construction_cost
+
     ############################################################################
     ##
     # Get Reporting Periods information and store in the feature_report
@@ -544,6 +585,19 @@ class DefaultFeatureReports < OpenStudio::Measure::ReportingMeasure
     photovoltaic_power = sql_query(runner, sql_file, 'AnnualBuildingUtilityPerformanceSummary', "TableName='Electric Loads Satisfied' AND RowName='Photovoltaic Power' AND ColumnName='Electricity'")
     feature_report.reporting_periods[0].energy_production[:electricity_produced][:photovoltaic] = convert_units(photovoltaic_power, 'GJ', 'kBtu')
 
+    ## Total utility cost
+    total_utility_cost = sql_query(runner, sql_file, 'Economics Results Summary Report', "TableName='Annual Cost' AND RowName='Cost' AND ColumnName='Total'")
+    feature_report.reporting_periods[0].total_utility_cost = total_utility_cost
+
+    ## Utility Costs
+    # electricity utility cost
+    elec_utility_cost = sql_query(runner, sql_file, 'Economics Results Summary Report', "TableName='Annual Cost' AND RowName='Cost' AND ColumnName='Electric'")
+    feature_report.reporting_periods[0].utility_costs[0][:fuel_type] = 'Electricity'
+    feature_report.reporting_periods[0].utility_costs[0][:total_cost] = elec_utility_cost
+    # gas utility cost
+    gas_utility_cost = sql_query(runner, sql_file, 'Economics Results Summary Report', "TableName='Annual Cost' AND RowName='Cost' AND ColumnName='Gas'")
+    feature_report.reporting_periods[0].utility_costs << { fuel_type: 'Natural Gas', total_cost: gas_utility_cost }
+
     ## comfort_result
     # time_setpoint_not_met_during_occupied_cooling
     time_setpoint_not_met_during_occupied_cooling = sql_query(runner, sql_file, 'AnnualBuildingUtilityPerformanceSummary', "TableName='Comfort and Setpoint Not Met Summary' AND RowName='Time Setpoint Not Met During Occupied Cooling' AND ColumnName='Facility'")
@@ -580,6 +634,19 @@ class DefaultFeatureReports < OpenStudio::Measure::ReportingMeasure
       'Electricity:Facility',
       'ElectricityProduced:Facility',
       'Gas:Facility',
+      'Cooling:Electricity',
+      'Heating:Electricity',
+      'InteriorLights:Electricity',
+      'ExteriorLights:Electricity',
+      'InteriorEquipment:Electricity',
+      'Fans:Electricity',
+      'Pumps:Electricity',
+      'WaterSystems:Electricity',
+      'HeatRejection:Electricity',
+      'HeatRejection:Gas',
+      'Heating:Gas',
+      'WaterSystems:Gas',
+      'InteriorEquipment:Gas',
       'DistrictCooling:Facility',
       'DistrictHeating:Facility',
       'District Cooling Chilled Water Rate',
@@ -589,26 +656,58 @@ class DefaultFeatureReports < OpenStudio::Measure::ReportingMeasure
       'District Heating Hot Water Rate',
       'District Heating Mass Flow Rate',
       'District Heating Inlet Temperature',
-      'District Heating Outlet Temperature'
+      'District Heating Outlet Temperature',
+      'Cooling Coil Total Cooling Rate',
+      'Heating Coil Heating Rate'
     ]
 
+    # add thermal comfort timeseries
+    comfortTimeseries = ['Zone Thermal Comfort Fanger Model PMV', 'Zone Thermal Comfort Fanger Model PPD']
+    requested_timeseries_names += comfortTimeseries
+
+    # add additional power timeseries (for calculating transformer apparent power to compare to rating ) in VA
+    powerTimeseries = ['Net Electric Energy', 'Electricity:Facility Power', 'ElectricityProduced:Facility Power', 'Electricity:Facility Apparent Power', 'ElectricityProduced:Facility Apparent Power', 'Net Power', 'Net Apparent Power']
+    requested_timeseries_names += powerTimeseries
+
+    # register info all timeseries
+    runner.registerInfo("All timeseries: #{requested_timeseries_names}")
+
+    # timeseries variables to keep to calculate power
+    tsToKeep = ['Electricity:Facility', 'ElectricityProduced:Facility']
+    tsToKeepIndexes = {}
+
+    ### powerFactor ###
+    # use power_factor default:  0.9
+    # TODO: Set powerFactor default based on building type
+    powerFactor = 0.9
+
+    ### power_conversion ###
+    # divide values by  total_seconds to convert J to W (W = J/sec)
+    # divide values by total_hours to convert kWh to kW (kW = kWh/hrs)
+    total_seconds = (60 / timesteps_per_hour.to_f) * 60 # make sure timesteps_per_hour is a float in the division
+    total_hours = 1 / timesteps_per_hour.to_f # make sure timesteps_per_hour is a float in the division
+    # set power_conversion
+    power_conversion = total_hours # we set the power conversio to total_hours since we want to convert lWh to kW
+    puts "Power Converion: to convert kWh to kW values will be divided by #{power_conversion}"
+
     # number of values in each timeseries
     n = nil
-
-    # all numeric timeseries values, transpose of CSV file (e.g. values[j] is column, values[j][i] is column and row)
+    # all numeric timeseries values, transpose of CSV file (e.g. values[key_cnt] is column, values[key_cnt][i] is column and row)
     values = []
-
-    # Since schedule value will have a bunch of key_values, we need to keep track of these as additional timeseries
+    tmpArray = []
+    # since schedule value will have a bunch of key_values, we need to keep track of these as additional timeseries
+    key_cnt = 0
     # this is recording the name of these final timeseries to write in the header of the CSV
     final_timeseries_names = []
 
     # loop over requested timeseries
-    # rubocop: disable Metrics/BlockLength
-    requested_timeseries_names.each_with_index do |timeseries_name, j|
+    requested_timeseries_names.each_index do |i|
+      timeseries_name = requested_timeseries_names[i]
+      puts " *********timeseries_name = #{timeseries_name}******************"
       runner.registerInfo("TIMESERIES: #{timeseries_name}")
 
-      # get all the key values that this timeseries can be reported for (e.g. if power is requested for each zone)
-      key_values = sql_file.availableKeyValues(ann_env_pd.to_s, reporting_frequency.to_s, timeseries_name)
+      # get all the key values that this timeseries can be reported for (e.g. if PMV is requested for each zone)
+      key_values = sql_file.availableKeyValues('RUN PERIOD 1', 'Zone Timestep', timeseries_name)
       runner.registerInfo("KEY VALUES: #{key_values}")
       if key_values.empty?
         key_values = ['']
@@ -616,7 +715,7 @@ class DefaultFeatureReports < OpenStudio::Measure::ReportingMeasure
 
       # sort keys
       sorted_keys = key_values.sort
-      requested_keys = ['SUMMED ELECTRICITY:FACILITY', 'SUMMED ELECTRICITY:FACILITY POWER', 'SUMMED ELECTRICITYPRODUCED:FACILITY', 'SUMMED ELECTRICITYPRODUCED:FACILITY POWER', 'SUMMED NET APPARENT POWER', 'SUMMED NET ELECTRIC ENERGY', 'SUMMED NET POWER', 'TRANSFORMER OUTPUT ELECTRIC ENERGY SCHEDULE']
+      requested_keys = requested_timeseries_names
       final_keys = []
       # make sure aggregated timeseries are listed in sorted order before all individual feature timeseries
       sorted_keys.each do |k|
@@ -649,7 +748,7 @@ class DefaultFeatureReports < OpenStudio::Measure::ReportingMeasure
             new_timeseries_name = key_value
           end
         end
-        final_timeseries_names << new_timeseries_name
+        # final_timeseries_names << new_timeseries_name
 
         # get the actual timeseries
         ts = sql_file.timeSeries(ann_env_pd.to_s, reporting_frequency.to_s, timeseries_name, key_value)
@@ -657,38 +756,210 @@ class DefaultFeatureReports < OpenStudio::Measure::ReportingMeasure
         if n.nil?
           # first timeseries should always be set
           runner.registerInfo('First timeseries')
-          values[j] = ts.get.values
-          n = values[j].size
+          values[key_cnt] = ts.get.values
+          n = values[key_cnt].size
         elsif ts.is_initialized
           runner.registerInfo('Is Initialized')
-          values[j] = ts.get.values
+          values[key_cnt] = ts.get.values
         else
           runner.registerInfo('Is NOT Initialized')
-          values[j] = Array.new(n, 0)
+          values[key_cnt] = Array.new(n, 0)
+        end
+
+        # unit conversion
+        old_unit = ts.get.units if ts.is_initialized
+
+        if timeseries_name.include? 'Gas'
+          new_unit = 'kBtu'
+        else
+          new_unit = case old_unit.to_s
+                        when 'J'
+                          'kWh'
+                        when 'kBtu'
+                          'kWh'
+                        when 'gal'
+                          'm3'
+                        when 'W'
+                          'W'
+                      end
         end
 
-        # ##Unit conversion
-        old_units = ts.get.units if ts.is_initialized
-        new_units = case old_units.to_s
-                      when 'J'
-                        'kBtu'
-                      when 'kWh'
-                        'kBtu'
-                      when 'm3'
-                        'gal'
-                    end
-
-        # Unit conversion here
-        os_vec = values[j]
-
-        # loop through each value to retrieve it
-        for i in 0..os_vec.length - 1
-          unless new_units == old_units
-            os_vec[i] = OpenStudio.convert(os_vec[i], old_units, new_units).get
+        # loop through each value and apply unit conversion
+        os_vec = values[key_cnt]
+        if !timeseries_name.include? 'Zone Thermal Comfort'
+          for i in 0..os_vec.length - 1
+
+            unless new_unit == old_unit || old_unit.nil? || new_unit.nil? || !ts.is_initialized
+              os_vec[i] = OpenStudio.convert(os_vec[i], old_unit, new_unit).get
+            end
+
+          end
+        end
+
+        # keep certain timeseries to calculate power
+        if tsToKeep.include? timeseries_name
+          tsToKeepIndexes[timeseries_name] = key_cnt
+        end
+
+        # special processing: power
+        if powerTimeseries.include? timeseries_name
+          # special case: net series (subtract generation from load)
+          if timeseries_name.include? 'Net'
+
+            newVals = Array.new(n, 0)
+            # Apparent power calculation
+
+            if timeseries_name.include?('Apparent')
+              (0..n - 1).each do |j|
+                newVals[j] = (values[tsToKeepIndexes['Electricity:Facility']][j].to_f - values[tsToKeepIndexes['ElectricityProduced:Facility']][j].to_f) / power_conversion / powerFactor
+                j += 1
+              end
+              new_unit = 'kVA'
+            elsif timeseries_name.include? 'Net Electric Energy'
+              (0..n - 1).each do |j|
+                newVals[j] = (values[tsToKeepIndexes['Electricity:Facility']][j].to_f - values[tsToKeepIndexes['ElectricityProduced:Facility']][j].to_f)
+                j += 1
+              end
+              new_unit = 'kWh'
+            else
+              runner.registerInfo('Power calc')
+              # Power calculation
+              (0..n - 1).each do |j|
+                newVals[j] = (values[tsToKeepIndexes['Electricity:Facility']][j].to_f - values[tsToKeepIndexes['ElectricityProduced:Facility']][j].to_f) / power_conversion
+                j += 1
+              end
+              new_unit = 'kW'
+            end
+
+            values[key_cnt] = newVals
+          else
+            tsToKeepIndexes.each do |key, indexValue|
+              if timeseries_name.include? key
+                runner.registerInfo("timeseries_name: #{timeseries_name}, key: #{key}")
+                # use this timeseries
+                newVals = Array.new(n, 0)
+                # Apparent power calculation
+                if timeseries_name.include?('Apparent')
+                  (0..n - 1).each do |j|
+                    newVals[j] = values[indexValue][j].to_f / power_conversion / powerFactor
+                    j += 1
+                  end
+                  new_unit = 'kVA'
+                else
+                  # Power calculation
+                  (0..n - 1).each do |j|
+                    newVals[j] = values[indexValue][j].to_f / power_conversion
+                    j += 1
+                  end
+                  new_unit = 'kW'
+                end
+                values[key_cnt] = newVals
+              end
+            end
           end
         end
+
+        # append units to headers
+        new_timeseries_name += "(#{new_unit})"
+        final_timeseries_names << new_timeseries_name
+
+        # TODO: DELETE PUTS
+        # puts " *********timeseries_name = #{timeseries_name}******************"
+        # if timeseries_name.include? 'Power'
+        #   puts "values = #{values[key_cnt]}"
+        #   puts "units = #{new_unit}"
+        # end
+
+        # comfort results usually have multiple timeseries (per zone), aggregate into a single series with consistent name and use worst value at each timestep
+        if comfortTimeseries.include? timeseries_name
+
+          # set up array if 1st key_value
+          if key_i == 0
+            runner.registerInfo("SETTING UP NEW ARRAY FOR: #{timeseries_name}")
+            tmpArray = Array.new(n, 0)
+          end
+
+          # add to array (keep max value at each timestep)
+          (0..(n - 1)).each do |ind|
+            # process negative and positive values differently
+            tVal = values[key_cnt][ind].to_f
+            if tVal < 0
+              tmpArray[ind] = [tVal, tmpArray[ind]].min
+            else
+              tmpArray[ind] = [tVal, tmpArray[ind]].max
+            end
+          end
+
+          # aggregate and save when all keyvalues have been processed
+          if key_i == final_keys.size - 1
+
+            hrsOutOfBounds = 0
+            if timeseries_name === 'Zone Thermal Comfort Fanger Model PMV'
+              (0..(n - 1)).each do |ind|
+                # -0.5 < x < 0.5 is within bounds
+                if values[key_cnt][ind].to_f > 0.5 || values[key_cnt][ind].to_f < -0.5
+                  hrsOutOfBounds += 1
+                end
+              end
+              hrsOutOfBounds = hrsOutOfBounds.to_f / timesteps_per_hour
+            elsif timeseries_name === 'Zone Thermal Comfort Fanger Model PPD'
+              (0..(n - 1)).each do |ind|
+                # > 20 is outside bounds
+                if values[key_cnt][ind].to_f > 20
+                  hrsOutOfBounds += 1
+                end
+              end
+              hrsOutOfBounds = hrsOutOfBounds.to_f / timesteps_per_hour
+            else
+              # this one is already scaled by timestep, no need to divide total
+              (0..(n - 1)).each do |ind|
+                hrsOutOfBounds += values[key_cnt][ind].to_f if values[key_cnt][ind].to_f > 0
+              end
+            end
+
+            # save variable to feature_reports hash
+            runner.registerInfo("timeseries #{timeseries_name}: hours out of bounds: #{hrsOutOfBounds}")
+            if timeseries_name === 'Zone Thermal Comfort Fanger Model PMV'
+              feature_report.reporting_periods[0].comfort_result[:hours_out_of_comfort_bounds_PMV] = hrsOutOfBounds
+            elsif timeseries_name == 'Zone Thermal Comfort Fanger Model PPD'
+              feature_report.reporting_periods[0].comfort_result[:hours_out_of_comfort_bounds_PPD] = hrsOutOfBounds
+            end
+
+          end
+
+        end
+
+        # increment key_cnt in new_keys loop
+        key_cnt += 1
       end
     end
+
+    # Add datime column
+    datetimes = []
+    # check what timeseries is available
+    available_ts = sql_file.availableTimeSeries
+    puts "####### available_ts = #{available_ts}"
+    # get the timeseries for any of available timeseries
+    # RK: code enhancement needed
+    ts_d_e = sql_file.timeSeries(ann_env_pd.to_s, reporting_frequency.to_s, 'Electricity:Facility', '')
+    ts_d_g = sql_file.timeSeries(ann_env_pd.to_s, reporting_frequency.to_s, 'Gas:Facility', '')
+
+    if ts_d_e.is_initialized
+      timeseries_d = ts_d_e.get
+    elsif ts_d_g.is_initialized
+      timeseries_d = ts_d_g.get
+    else
+      raise 'ELECTRICITY and GAS results are not initiaized'
+    end
+    # get formated datetimes
+    timeseries_d.dateTimes.each do |datetime|
+      datetimes << format_datetime(datetime.to_s)
+    end
+    # insert datetimes to values
+    values.insert(0, datetimes)
+    # insert datetime header to names
+    final_timeseries_names.insert(0, 'Datetime')
+
     # rubocop: enable Metrics/BlockLength
     runner.registerInfo("new final_timeseries_names size: #{final_timeseries_names.size}")