urbanopt-reporting 0.3.2 → 0.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0adaa330d8958566edae263cedfd8a1bdee84769c881b98b86481ec4b0ee8bd5
-  data.tar.gz: ceb2145a16413bd4885a1ef81fc9e534d8ed96e49ba19aaff47980dfeaa4838a
+  metadata.gz: e65d30b14cf3916be1251dd1092dd74f222e737a0c9d6e6278123f4c6101b503
+  data.tar.gz: 4fa5c62490c7dcc883c5308f8f31547090f1eef01914b0e3e54093e218f09bf9
 SHA512:
-  metadata.gz: d8b2234582c11610f1ad932566bc60e8006930b6038dc619d307955739b21b63b3493488fea25cb2c66d3bb8c70433aebdacd66739920c944d08f53052ac105c
-  data.tar.gz: 5be211005727f24581d0a2e2540db99b1aff5ac1003bdbaf61fafd0b6c4bbfbb2b293408afaac7cb45aa4f757cb153fb2c4aa420ca7bbcbc3e2e5ee40c1f5b3d
+  metadata.gz: 0e0fdd09a89d58be74b9506fc9904253b0121f0d117041799baa500f3a0b1ab07f907609e0495486943751203c1f8683cc564ffcb038cb944721e1751e79c6f3
+  data.tar.gz: 067ab1a1d6506c22933a1e4e9e09dac96ecc925e4d3d931bfc51bd6853faf99e658c4b578f6689d9e34cc5ff5533c77dab1d8533ccef1384963ad7a85ac627e1

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 # URBANopt Reporting Gem
 
+## Version 0.3.3
+
+Date Range: 12/09/20 - 01/13/21
+
+- Fixed [#36]( https://github.com/urbanopt/urbanopt-reporting-gem/issues/36 ), Add reporting measure for district heating/cooling system mass flow rates
+- Fixed [#37]( https://github.com/urbanopt/urbanopt-reporting-gem/issues/37 ), Add EUI to default report
+- Fixed [#38]( https://github.com/urbanopt/urbanopt-reporting-gem/issues/38 ), Add better error handling around convert_units
+- Fixed [#43]( https://github.com/urbanopt/urbanopt-reporting-gem/issues/43 ), Add available_roof_area calculation
+- Fixed [#44]( https://github.com/urbanopt/urbanopt-reporting-gem/issues/44 ), Fix coordinates order
+
 ## Version 0.3.2
 
 Date Range: 12/07/20 - 12/08/20

data/lib/measures/default_feature_reports/measure.rb

@@ -258,6 +258,11 @@ class DefaultFeatureReports < OpenStudio::Measure::ReportingMeasure
     if value.nil?
       return nil
     end
+    if from_units.nil? || to_units.nil?
+      @runner.registerError("Cannot convert units...from_units: #{from_units} or to_units: #{to_units} left blank.")
+      return nil
+    end
+
     # apply unit conversion
     value_converted = OpenStudio.convert(value, from_units, to_units)
     if value_converted.is_initialized
@@ -353,10 +358,10 @@ class DefaultFeatureReports < OpenStudio::Measure::ReportingMeasure
     ##
 
     if feature_location.include? '['
-      # get latitude from feature_location
-      latitude = (feature_location.split(',')[0].delete! '[]').to_f
       # get longitude from feature_location
-      longitude = (feature_location.split(',')[1].delete! '[]').to_f
+      longitude = (feature_location.split(',')[0].delete! '[]').to_f
+      # get latitude from feature_location
+      latitude = (feature_location.split(',')[1].delete! '[]').to_f
       # latitude
       feature_report.location.latitude_deg = latitude
       # longitude
@@ -495,7 +500,23 @@ class DefaultFeatureReports < OpenStudio::Measure::ReportingMeasure
         total_roof_area += surface.netArea
       end
     end
-    feature_report.program.roof_area_sqft[:total_roof_area_sqft] = convert_units(total_roof_area, 'm^2', 'ft^2')
+
+    total_roof_area_sqft = convert_units(total_roof_area, 'm^2', 'ft^2')
+    feature_report.program.roof_area_sqft[:total_roof_area_sqft] = total_roof_area_sqft
+
+    # available_roof_area_sqft
+    # RK: a more robust method should be implemented to find the available_roof_area 
+    # assign available roof area to be a percentage of the total roof area
+
+    if building_types[0][:building_type].include? 'Single-Family Detached'
+      feature_report.program.roof_area_sqft[:available_roof_area_sqft] = 0.45 * total_roof_area_sqft
+    else 
+      feature_report.program.roof_area_sqft[:available_roof_area_sqft] = 0.75 * total_roof_area_sqft
+    end
+
+    # RK: Temporary solution: assign available roof area to be equal to total roof area
+    #feature_report.program.roof_area_sqft[:available_roof_area_sqft] = total_roof_area_sqft
+
 
     # orientation
     # RK: a more robust method should be implemented to find orientation(finding main axis of the building using aspect ratio)
@@ -581,6 +602,22 @@ class DefaultFeatureReports < OpenStudio::Measure::ReportingMeasure
     total_source_energy = sql_query(runner, sql_file, 'AnnualBuildingUtilityPerformanceSummary', "TableName='Site and Source Energy' AND RowName='Total Source Energy' AND ColumnName='Total Energy'")
     feature_report.reporting_periods[0].total_source_energy_kwh = convert_units(total_source_energy, 'GJ', 'kWh')
 
+    # EUI is only valid with a full year of energy data
+    if begin_month == 1 && begin_day_of_month == 1 && end_month == 12 && end_day_of_month == 31
+      # calculate site EUI
+      site_EUI_kwh_per_m2 = feature_report.reporting_periods[0].total_site_energy_kwh / floor_area
+      site_EUI_kbtu_per_ft2 = convert_units(total_site_energy, 'GJ', 'kBtu') / feature_report.program.floor_area_sqft
+      # add site EUI to feature report
+      feature_report.reporting_periods[0].site_EUI_kwh_per_m2 = site_EUI_kwh_per_m2
+      feature_report.reporting_periods[0].site_EUI_kbtu_per_ft2 = site_EUI_kbtu_per_ft2
+      # calculate source EUI
+      source_EUI_kwh_per_m2 = feature_report.reporting_periods[0].total_source_energy_kwh / floor_area
+      source_EUI_kbtu_per_ft2 = convert_units(total_source_energy, 'GJ', 'kBtu') / feature_report.program.floor_area_sqft
+      # add source EUI to feature report
+      feature_report.reporting_periods[0].source_EUI_kwh_per_m2 = source_EUI_kwh_per_m2
+      feature_report.reporting_periods[0].source_EUI_kbtu_per_ft2 = source_EUI_kbtu_per_ft2
+    end
+
     # net_site_energy
     net_site_energy = sql_query(runner, sql_file, 'AnnualBuildingUtilityPerformanceSummary', "TableName='Site and Source Energy' AND RowName='Net Site Energy' AND ColumnName='Total Energy'")
     feature_report.reporting_periods[0].net_site_energy_kwh = convert_units(net_site_energy, 'GJ', 'kWh')

data/lib/measures/export_modelica_loads/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/export_modelica_loads/README.md

@@ -0,0 +1,26 @@
+
+
+###### (Automatically generated documentation)
+
+# Export Modelica Loads
+
+## Description
+Use the results from the EnergyPlus simulation to generate a load file for use in Modelica. This will create a MOS and a CSV file of the heating, cooling, and hot water loads.
+
+## Modeler Description
+
+
+## Measure Type
+ReportingMeasure
+
+## Taxonomy
+
+
+## Arguments
+
+
+
+
+This measure does not have any user arguments
+
+

data/lib/measures/export_modelica_loads/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/export_modelica_loads/measure.rb

@@ -0,0 +1,367 @@
+# *******************************************************************************
+# 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'
+
+# start the measure
+class ExportModelicaLoads < OpenStudio::Measure::ReportingMeasure
+  # human readable name
+  def name
+    # Measure name should be the title case of the class name.
+    return 'Export Modelica Loads'
+  end
+
+  def description
+    return 'Use the results from the EnergyPlus simulation to generate a load file for use in Modelica. This will create a MOS and a CSV file of the heating, cooling, and hot water loads.'
+  end
+
+  def modeler_description
+    return ''
+  end
+
+  def log(str)
+    puts "#{Time.now}: #{str}"
+  end
+
+  def arguments(_model)
+    args = OpenStudio::Measure::OSArgumentVector.new
+
+    # this measure does not require any user arguments, return an empty list
+    return args
+  end
+
+  # 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
+
+    # To use the built-in error checking we need the model...
+    # 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
+
+    # use the built-in error checking
+    if !runner.validateUserArguments(arguments(model), user_arguments)
+      return false
+    end
+
+    result << OpenStudio::IdfObject.load('Output:Variable,,Site Mains Water Temperature,hourly;').get
+    result << OpenStudio::IdfObject.load('Output:Variable,,Site Outdoor Air Drybulb Temperature,hourly;').get
+    result << OpenStudio::IdfObject.load('Output:Variable,,Site Outdoor Air Relative Humidity,hourly;').get
+    result << OpenStudio::IdfObject.load('Output:Meter,Cooling:Electricity,hourly;').get
+    result << OpenStudio::IdfObject.load('Output:Meter,Heating:Electricity,hourly;').get
+    result << OpenStudio::IdfObject.load('Output:Meter,Heating:Gas,hourly;').get
+    result << OpenStudio::IdfObject.load('Output:Meter,InteriorLights:Electricity,hourly;').get
+    result << OpenStudio::IdfObject.load('Output:Meter,Fans:Electricity,hourly;').get
+    result << OpenStudio::IdfObject.load('Output:Meter,InteriorEquipment:Electricity,hourly;').get # Joules
+    result << OpenStudio::IdfObject.load('Output:Meter,ExteriorLighting:Electricity,hourly;').get # Joules
+    result << OpenStudio::IdfObject.load('Output:Meter,Electricity:Facility,hourly;').get # Joules
+    result << OpenStudio::IdfObject.load('Output:Meter,Gas:Facility,hourly;').get # Joules
+    result << OpenStudio::IdfObject.load('Output:Meter,Heating:EnergyTransfer,hourly;').get  # Joules
+    result << OpenStudio::IdfObject.load('Output:Meter,WaterSystems:EnergyTransfer,hourly;').get  # Joules
+    # these variables are used for the modelica export.
+    result << OpenStudio::IdfObject.load('Output:Variable,*,Zone Predicted Sensible Load to Setpoint Heat Transfer Rate,hourly;').get  # watts according to e+
+    result << OpenStudio::IdfObject.load('Output:Variable,*,Water Heater Total Demand Heat Transfer Rate,hourly;').get # Watts
+
+    return result
+  end
+
+  def extract_timeseries_into_matrix(sqlfile, data, variable_name, key_value = nil, default_if_empty=0)
+    log "Executing query for #{variable_name}"
+    column_name = variable_name
+    if key_value
+      ts = sqlfile.timeSeries('RUN PERIOD 1', 'Hourly', variable_name, key_value)
+      # ts = sqlfile.timeSeries('RUN PERIOD 1', 'Zone Timestep', variable_name, key_value)
+      column_name += "_#{key_value}"
+    else
+      ts = sqlfile.timeSeries('RUN PERIOD 1', 'Hourly', variable_name)
+      # ts = sqlfile.timeSeries('RUN PERIOD 1', 'Zone Timestep', variable_name)
+    end
+    log 'Iterating over timeseries'
+    column = [column_name.delete(':').delete(' ')] # Set the header of the data to the variable name, removing : and spaces
+
+    if ts.empty?
+      log "No time series for #{variable_name}:#{key_value}... defaulting to #{default_if_empty}"
+      # needs to be data.size-1 since the column name is already stored above (+=)
+      column += [default_if_empty] * (data.size-1)
+    else
+      ts = ts.get if ts.respond_to?(:get)
+      ts = ts.first if ts.respond_to?(:first)
+
+      start = Time.now
+      # Iterating in OpenStudio can take up to 60 seconds with 10min data. The quick_proc takes 0.03 seconds.
+      # for i in 0..ts.values.size - 1
+      #   log "... at #{i}" if i % 10000 == 0
+      #   column << ts.values[i]
+      # end
+
+      quick_proc = ts.values.to_s.split(',')
+
+      # the first and last have some cleanup items because of the Vector method
+      quick_proc[0] = quick_proc[0].gsub(/^.*\(/, '')
+      quick_proc[-1] = quick_proc[-1].delete(')')
+      column += quick_proc
+
+      log "Took #{Time.now - start} to iterate"
+    end
+
+    log 'Appending column to data'
+
+    # append the data to the end of the rows
+    if column.size == data.size
+      data.each_index do |index|
+        data[index] << column[index]
+      end
+    end
+
+    log "Finished extracting #{variable_name}"
+  end
+
+  def create_new_variable_sum(data, new_var_name, include_str, options=nil)
+    var_info = {
+        name: new_var_name,
+        var_indexes: []
+    }
+    data.each_with_index do |row, index|
+      if index.zero?
+        # Get the index of the columns to add
+        row.each do |c|
+          if c.include? include_str
+            var_info[:var_indexes] << row.index(c)
+          end
+        end
+
+        # add the new var to the header row
+        data[0] << var_info[:name]
+      else
+        # sum the values
+        sum = 0
+        var_info[:var_indexes].each do |var|
+          temp_v = row[var].to_f
+          if options.nil?
+            sum += temp_v
+          elsif options[:positive_only] && temp_v > 0
+            sum += temp_v
+          elsif options[:negative_only] && temp_v < 0
+            sum += temp_v
+          end
+        end
+
+        # Also round the data here, because we don't need 10 decimals
+        data[index] << sum.round(1)
+      end
+    end
+  end
+
+  def run(runner, user_arguments)
+    super(runner, user_arguments)
+
+    # 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
+
+    # use the built-in error checking
+    return false unless runner.validateUserArguments(arguments(model), user_arguments)
+
+    # 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)
+
+    # create a new csv with the values and save to the reports directory.
+    # assumptions:
+    #   - all the variables exist
+    #   - data are the same length
+
+    # initialize the rows with the header
+    log 'Starting to process Timeseries data'
+    # Initial header row
+    rows = [
+      ['Date Time', 'Month', 'Day', 'Day of Week', 'Hour', 'Minute', 'SecondsFromStart']
+    ]
+
+    # just grab one of the variables to get the date/time stamps
+    # ts = sqlFile.timeSeries('RUN PERIOD 1', 'Zone Timestep', 'Cooling:Electricity')
+    ts = sqlFile.timeSeries('RUN PERIOD 1', 'Hourly', 'Cooling:Electricity')
+    unless ts.empty?
+      ts = ts.first
+      dt_base = nil
+      # Save off the date time values
+      ts.dateTimes.each_with_index do |dt, index|
+        runner.registerInfo("My index is #{index}")
+        dt_base = DateTime.parse(dt.to_s) if dt_base.nil?
+        dt_current = DateTime.parse(dt.to_s)
+        rows << [
+          DateTime.parse(dt.to_s).strftime('%m/%d/%Y %H:%M'),
+            dt.date.monthOfYear.value,
+            dt.date.dayOfMonth,
+            dt.date.dayOfWeek.value,
+            dt.time.hours,
+            dt.time.minutes,
+            dt_current.to_time.to_i - dt_base.to_time.to_i
+        ]
+      end
+    end
+
+    # add in the other variables by columns -- should really pull this from the report variables defined above
+    extract_timeseries_into_matrix(sqlFile, rows, 'Site Outdoor Air Drybulb Temperature', 'Environment', 0)
+    extract_timeseries_into_matrix(sqlFile, rows, 'Site Outdoor Air Relative Humidity', 'Environment', 0)
+    extract_timeseries_into_matrix(sqlFile, rows, 'Heating:Electricity', nil, 0)
+    extract_timeseries_into_matrix(sqlFile, rows, 'Heating:Gas', nil, 0)
+    extract_timeseries_into_matrix(sqlFile, rows, 'Cooling:Electricity', nil, 0)
+    extract_timeseries_into_matrix(sqlFile, rows, 'Electricity:Facility', nil, 0)
+    extract_timeseries_into_matrix(sqlFile, rows, 'Gas:Facility', nil, 0)
+    extract_timeseries_into_matrix(sqlFile, rows, 'Heating:EnergyTransfer', nil, 0)
+    extract_timeseries_into_matrix(sqlFile, rows, 'WaterSystems:EnergyTransfer', nil, 0)
+
+    # get all zones and save the names for later use in aggregation.
+    tz_names = []
+    model.getThermalZones.each do |tz|
+      tz_names << tz.name.get if tz.name.is_initialized
+      extract_timeseries_into_matrix(sqlFile, rows, 'Zone Predicted Sensible Load to Setpoint Heat Transfer Rate', tz_names.last, 0)
+      extract_timeseries_into_matrix(sqlFile, rows, 'Water Heater Heating Rate', tz_names.last, 0)
+    end
+
+    # sum up a couple of the columns and create a new columns
+    create_new_variable_sum(rows, 'TotalSensibleLoad', 'ZonePredictedSensibleLoadtoSetpointHeatTransferRate')
+    create_new_variable_sum(rows, 'TotalCoolingSensibleLoad', 'ZonePredictedSensibleLoadtoSetpointHeatTransferRate', negative_only: true)
+    create_new_variable_sum(rows, 'TotalHeatingSensibleLoad', 'ZonePredictedSensibleLoadtoSetpointHeatTransferRate', positive_only: true)
+    create_new_variable_sum(rows, 'TotalWaterHeating', 'WaterHeaterHeatingRate')
+
+    # convert this to CSV object
+    File.open('./building_loads.csv', 'w') do |f|
+      rows.each do |row|
+        f << row.join(',') << "\n"
+      end
+    end
+
+    # covert the row data into the format needed by modelica
+    modelica_data = [['seconds', 'cooling', 'heating', 'waterheating']]
+    seconds_index = nil
+    total_water_heating_index = nil
+    total_cooling_sensible_index = nil
+    total_heating_sensible_index = nil
+    peak_cooling = 0
+    peak_heating = 0
+    peak_water_heating = 0
+    rows.each_with_index do |row, index|
+      if index.zero?
+        seconds_index = row.index('SecondsFromStart')
+        total_cooling_sensible_index = row.index('TotalCoolingSensibleLoad')
+        total_heating_sensible_index = row.index('TotalHeatingSensibleLoad')
+        total_water_heating_index = row.index('TotalWaterHeating')
+      else
+        new_data = [
+          row[seconds_index],
+          row[total_cooling_sensible_index],
+          row[total_heating_sensible_index],
+          row[total_water_heating_index]
+        ]
+
+        modelica_data << new_data
+
+        # store the peaks
+        peak_cooling = row[total_cooling_sensible_index] if row[total_cooling_sensible_index] < peak_cooling
+        peak_heating = row[total_heating_sensible_index] if row[total_heating_sensible_index] > peak_heating
+        peak_water_heating = row[total_water_heating_index] if row[total_water_heating_index] > peak_water_heating
+      end
+    end
+
+    File.open('./modelica.mos', 'w') do |f|
+      f << "#1\n"
+      f << "#Heating and Cooling Model loads from OpenStudio Prototype Buildings\n"
+      f << "#  Building Type: {{BUILDINGTYPE}}\n"
+      f << "#  Climate Zone: {{CLIMATEZONE}}\n"
+      f << "#  Vintage: {{VINTAGE}}\n"
+      f << "#  Simulation ID (for debugging): {{SIMID}}\n"
+      f << "#  URL: https://github.com/urbanopt/openstudio-prototype-loads\n"
+      f << "\n"
+      f << "#First column: Seconds in the year (loads are hourly)\n"
+      f << "#Second column: cooling loads in Watts (as negative numbers).\n"
+      f << "#Third column: space heating loads in Watts\n"
+      f << "#Fourth column: water heating in Watts\n"
+      f << "\n"
+      f << "#Peak space cooling load = #{peak_cooling} Watts\n"
+      f << "#Peak space heating load = #{peak_heating} Watts\n"
+      f << "#Peak water heating load = #{peak_water_heating} Watts\n"
+      f << "double tab1(8760,4)\n"
+      modelica_data.each_with_index do |row, index|
+        next if index.zero?
+        f << row.join(';') << "\n"
+      end
+    end
+
+    # Find the total runtime for energyplus and save it into a registerValue
+    total_time = -999
+    location_of_file = ['../eplusout.end', './run/eplusout.end']
+    first_index = location_of_file.map {|f| File.exist?(f)}.index(true)
+    if first_index
+      match = File.read(location_of_file[first_index]).to_s.match(/Elapsed.Time=(.*)hr(.*)min(.*)sec/)
+      total_time = match[1].to_i * 3600 + match[2].to_i * 60 + match[3].to_f
+    end
+
+    runner.registerValue('energyplus_runtime', total_time, 'sec')
+    runner.registerValue('peak_cooling_load', peak_cooling, 'W')
+    runner.registerValue('peak_heating_load', peak_heating, 'W')
+    runner.registerValue('peak_water_heating', peak_water_heating, 'W')
+
+    return true
+  ensure
+    sqlFile.close if sqlFile
+  end
+end
+
+# register the measure to be used by the application
+ExportModelicaLoads.new.registerWithApplication