urbanopt-reopt 0.3.0 → 0.5.5

data/lib/urbanopt/reopt/reopt_lite_api.rb

@@ -1,5 +1,5 @@
 # *********************************************************************************
-# URBANopt, Copyright (c) 2019-2020, Alliance for Sustainable Energy, LLC, and other
+# URBANopt (tm), 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,
@@ -56,6 +56,7 @@ module URBANopt # :nodoc:
         @use_localhost = use_localhost
         if @use_localhost
           @uri_submit = URI.parse('http//:127.0.0.1:8000/v1/job/')
+          @uri_submit_outagesimjob = URI.parse('http//:127.0.0.1:8000/v1/outagesimjob/')
         else
           if [nil, '', '<insert your key here>'].include? nrel_developer_key
             if [nil, '', '<insert your key here>'].include? DEVELOPER_NREL_KEY
@@ -66,6 +67,7 @@ module URBANopt # :nodoc:
           end
           @nrel_developer_key = nrel_developer_key
           @uri_submit = URI.parse("https://developer.nrel.gov/api/reopt/v1/job/?api_key=#{@nrel_developer_key}")
+          @uri_submit_outagesimjob = URI.parse("https://developer.nrel.gov/api/reopt/v1/outagesimjob/?api_key=#{@nrel_developer_key}")
           # initialize @@logger
           @@logger ||= URBANopt::REopt.reopt_logger
         end
@@ -88,6 +90,23 @@ module URBANopt # :nodoc:
         return URI.parse("https://developer.nrel.gov/api/reopt/v1/job/#{run_uuid}/results?api_key=#{@nrel_developer_key}")
       end
 
+      ##
+      # URL of the resilience statistics end point for a specific optimization task
+      ##
+      #
+      # [*parameters:*]
+      #
+      # * +run_uuid+ - _String_ - Resilience statistics for a unique run_uuid obtained from the \REopt Lite job submittal URL for a specific optimization task.
+      #
+      # [*return:*] _URI_ - Returns URI object for use in calling the \REopt Lite resilience statistics endpoint for a specifc optimization task.
+      ##
+      def uri_resilience(run_uuid) # :nodoc:
+        if @use_localhost
+          return URI.parse("http://127.0.0.1:8000/v1/job/#{run_uuid}/resilience_stats")
+        end
+        return URI.parse("https://developer.nrel.gov/api/reopt/v1/job/#{run_uuid}/resilience_stats?api_key=#{@nrel_developer_key}")
+      end
+
       def make_request(http, r, max_tries = 3)
         result = nil
         tries = 0
@@ -117,10 +136,10 @@ module URBANopt # :nodoc:
         http = Net::HTTP.new(@uri_submit.host, @uri_submit.port)
         if !@use_localhost
           http.use_ssl = true
-    end
+        end
 
         request = Net::HTTP::Post.new(@uri_submit, header)
-        request.body = data.to_json
+        request.body = ::JSON.generate(data, allow_nan: true)
 
         # Send the request
         response = make_request(http, request)
@@ -132,6 +151,82 @@ module URBANopt # :nodoc:
         return true
       end
 
+      ##
+      # Completes a \REopt Lite optimization. From a formatted hash, an optimization task is submitted to the API.
+      # Results are polled at 5 second interval until they are ready or an error is returned from the API. Results
+      # are written to disk.
+      ##
+      #
+      # [*parameters:*]
+      #
+      # * +reopt_input+ - _Hash_ - \REopt Lite formatted post containing at least required parameters.
+      # * +filename+ - _String_ - Path to file that will be created containing the full \REopt Lite response.
+      #
+      # [*return:*] _Bool_ - Returns true if the post succeeeds. Otherwise returns false.
+      ##
+      def resilience_request(run_uuid, filename)
+        
+        if File.directory? filename
+          if run_uuid.nil?
+            run_uuid = 'error'
+          end
+          if run_uuid.downcase.include? 'error'
+            run_uuid = "error#{SecureRandom.uuid}"
+          end
+          filename = File.join(filename, "#{run_uuid}_resilience.json")
+          @@logger.info("REopt results saved to #{filename}")
+        end
+        
+        #Submit Job
+        @@logger.info("Submitting Resilience Statistics job for #{run_uuid}")
+        header = { 'Content-Type' => 'application/json' }
+        http = Net::HTTP.new(@uri_submit_outagesimjob.host, @uri_submit_outagesimjob.port)
+        if !@use_localhost
+          http.use_ssl = true
+        end
+        request = Net::HTTP::Post.new(@uri_submit_outagesimjob, header)
+        request.body = ::JSON.generate({"run_uuid" => run_uuid, "bau" => false }, allow_nan: true)
+        submit_response = make_request(http, request)
+        @@logger.info(submit_response.body)
+
+        #Fetch Results
+        uri = uri_resilience(run_uuid)
+        http = Net::HTTP.new(uri.host, uri.port)
+        if !@use_localhost
+          http.use_ssl = true
+        end
+
+        elapsed_time = 0
+        max_elapsed_time = 60 * 5
+        
+        request = Net::HTTP::Get.new(uri.request_uri)
+        response = make_request(http, request)
+        
+        while (elapsed_time < max_elapsed_time) & (response.code == "404")
+          response = make_request(http, request)
+          elapsed_time += 5 
+          sleep 5
+        end
+        
+        data = JSON.parse(response.body)
+        text = ::JSON.generate(data, allow_nan: true)
+        begin
+          File.open(filename, 'w+') do |f|
+            f.puts(text)
+          end
+        rescue
+          @@logger.info("Cannot write - #{filename}")
+        end
+
+        if response.code == "200"
+          return data
+        end
+        
+        @@logger.info("Error from REopt API - #{data['Error']}")
+        return {}
+        
+      end
+
       ##
       # Completes a \REopt Lite optimization. From a formatted hash, an optimization task is submitted to the API.
       # Results are polled at 5 second interval until they are ready or an error is returned from the API. Results
@@ -157,13 +252,13 @@ module URBANopt # :nodoc:
           http.use_ssl = true
         end
         request = Net::HTTP::Post.new(@uri_submit, header)
-        request.body = reopt_input.to_json
-
+        request.body = ::JSON.generate(reopt_input, allow_nan: true)
+        
         # Send the request
         response = make_request(http, request)
 
         # Get UUID
-        run_uuid = JSON.parse(response.body)['run_uuid']
+        run_uuid = JSON.parse(response.body, allow_nan:true)['run_uuid']
 
         if File.directory? filename
           if run_uuid.nil?
@@ -176,10 +271,12 @@ module URBANopt # :nodoc:
           @@logger.info("REopt results saved to #{filename}")
         end
 
+        text = ::JSON.generate(response.body, allow_nan: true)
         if response.code != '201'
-          File.open(filename, 'w') do |f|
-            f.write(response.body)
+          File.open(filename, 'w+') do |f|
+            f.puts(text)
           end
+          @@logger.info("Cannot write - #{filename}")
           raise "Error in REopt optimization post - see #{filename}"
         end
 
@@ -195,7 +292,9 @@ module URBANopt # :nodoc:
 
         while status == 'Optimizing...'
           response = make_request(http, request)
-          data = JSON.parse(response.body)
+          
+          data = JSON.parse(response.body, allow_nan:true)
+
           if data['outputs']['Scenario']['Site']['PV'].kind_of?(Array)
             pv_sizes = 0
             data['outputs']['Scenario']['Site']['PV'].each do |x|
@@ -216,7 +315,7 @@ module URBANopt # :nodoc:
         while (_tries < _max_retry) && check_complete
           sleep 1
           response = make_request(http, request)
-          data = JSON.parse(response.body)
+          data = JSON.parse(response.body, allow_nan:true)
           if data['outputs']['Scenario']['Site']['PV'].kind_of?(Array)
             pv_sizes = 0
             data['outputs']['Scenario']['Site']['PV'].each do |x|
@@ -230,8 +329,14 @@ module URBANopt # :nodoc:
           _tries += 1
         end
 
-        File.open(filename, 'w') do |f|
-          f.write(data.to_json)
+        data = JSON.parse(response.body)
+        text = ::JSON.generate(data, allow_nan: true)
+        begin
+          File.open(filename, 'w+') do |f|
+            f.puts(text)
+          end
+        rescue
+          @@logger.info("Cannot write - #{filename}")
         end
 
         if status == 'optimal'

data/lib/urbanopt/reopt/reopt_logger.rb

@@ -1,5 +1,5 @@
 # *********************************************************************************
-# URBANopt, Copyright (c) 2019-2020, Alliance for Sustainable Energy, LLC, and other
+# URBANopt (tm), 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/urbanopt/reopt/reopt_post_processor.rb

@@ -1,5 +1,5 @@
 # *********************************************************************************
-# URBANopt, Copyright (c) 2019-2020, Alliance for Sustainable Energy, LLC, and other
+# URBANopt (tm), 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,
@@ -29,9 +29,8 @@
 # *********************************************************************************
 
 require 'bundler/setup'
-require 'urbanopt/scenario/default_reports'
+require 'urbanopt/reporting/default_reports'
 require 'urbanopt/reopt/reopt_logger'
-require 'urbanopt/reopt'
 require 'csv'
 
 module URBANopt # :nodoc:
@@ -43,7 +42,7 @@ module URBANopt # :nodoc:
       #
       # [*parameters:*]
       #
-      # * +scenario_report+ - _ScenarioReport_ - Optional. A scenario report that has been returned from the URBANopt::Scenario::ScenarioDefaultPostProcessor - used in creating default output file names in \REopt Lite optimizations.
+      # * +scenario_report+ - _ScenarioReport_ - Optional. A scenario report that has been returned from the URBANopt::Reporting::ScenarioDefaultPostProcessor - used in creating default output file names in \REopt Lite optimizations.
       # * +scenario_reopt_assumptions_file+ - _String_ - Optional. JSON file formatted for a \REopt Lite analysis containing custom input parameters for optimizations at the Scenario Report level
       # * +reopt_feature_assumptions+ - _Array_ - Optional. A list of JSON file formatted for a \REopt Lite analysis containing custom input parameters for optimizations at the Feature Report level. The order and number of files must match the Feature Reports in the scenario_report input.
       # * +use_localhost+ - _Bool_ - If this is true, requests will be sent to a version of the \REopt Lite API running on localhost. Default is false, such that the production version of \REopt Lite is accessed.
@@ -70,8 +69,9 @@ module URBANopt # :nodoc:
         if !scenario_report.nil?
           @scenario_report = scenario_report
 
-          if  !Dir.exist?(File.join(@scenario_report.directory_name, "reopt"))
+          if !Dir.exist?(File.join(@scenario_report.directory_name, "reopt"))
             Dir.mkdir(File.join(@scenario_report.directory_name, "reopt"))
+            @@logger.info("Created directory: " + File.join(@scenario_report.directory_name, "reopt"))
           end
 
           @scenario_reopt_default_output_file = File.join(@scenario_report.directory_name, "reopt/scenario_report_#{@scenario_report.id}_reopt_run.json")
@@ -80,6 +80,7 @@ module URBANopt # :nodoc:
           @scenario_report.feature_reports.each do |fr|
             if !Dir.exist?(File.join(fr.directory_name, "reopt"))
               Dir.mkdir(File.join(fr.directory_name, "reopt"))
+              @@logger.info("Created directory: " + File.join(fr.directory_name, "reopt"))
             end
             @feature_reports_reopt_default_output_files << File.join(fr.directory_name, "reopt/feature_report_#{fr.id}_reopt_run.json")
           end
@@ -111,25 +112,36 @@ module URBANopt # :nodoc:
       #
       # [*parameters:*]
       #
-      # * +feature_report+ - _URBANopt::Scenario::DefaultReports::FeatureReport_ -  FeatureReport which will be used in creating and then updated by a \REopt Lite opimization response.
+      # * +feature_report+ - _URBANopt::Reporting::DefaultReports::FeatureReport_ -  FeatureReport which will be used in creating and then updated by a \REopt Lite opimization response.
       # * +reopt_assumptions_hash+ - _Hash_ - Optional. A \REopt Lite formatted hash containing default parameters (i.e. utility rate, escalation rate) which will be updated by the FeatureReport (i.e. location, roof availability)
       # * +reopt_output_file+ - _String_ - Optional. Path to a file at which REpopt Lite responses will be saved.
       # * +timeseries_csv_path+ - _String_ - Optional. Path to a file at which the new timeseries CSV for the FeatureReport will be saved.
       #
-      # [*return:*] _URBANopt::Scenario::DefaultReports::FeatureReport_ - Returns an updated FeatureReport
+      # [*return:*] _URBANopt::Reporting::DefaultReports::FeatureReport_ - Returns an updated FeatureReport
       ##
-      def run_feature_report(feature_report:, reopt_assumptions_hash:nil, reopt_output_file:nil, timeseries_csv_path:nil, save_name:nil)
+      def run_feature_report(feature_report:, reopt_assumptions_hash:nil, reopt_output_file:nil, timeseries_csv_path:nil, save_name:nil, run_resilience:true)
         api = URBANopt::REopt::REoptLiteAPI.new(@nrel_developer_key, @localhost)
         adapter = URBANopt::REopt::FeatureReportAdapter.new
 
         reopt_input = adapter.reopt_json_from_feature_report(feature_report, reopt_assumptions_hash)
         if reopt_output_file.nil?
-          reopt_output_file = feature_report.directory_name
+          reopt_output_file = File.join(feature_report.directory_name, 'reopt')
         end
         reopt_output = api.reopt_request(reopt_input, reopt_output_file)
-        result = adapter.update_feature_report(feature_report, reopt_output, timeseries_csv_path)
+        if run_resilience
+          run_uuid = reopt_output['outputs']['Scenario']['run_uuid']
+          if File.directory? reopt_output_file
+            resilience_stats = api.resilience_request(run_uuid, reopt_output_file)
+          else
+            resilience_stats = api.resilience_request(run_uuid, reopt_output_file.sub!('.json','_resilience.json'))
+          end
+        else
+          resilience_stats = nil
+        end
+        result = adapter.update_feature_report(feature_report, reopt_output, timeseries_csv_path, resilience_stats)
         if !save_name.nil?
-          result.save_feature_report save_name
+          #result.save_feature_report save_name
+          result.save_json_report(save_name)
         end
         return result
       end
@@ -140,13 +152,13 @@ module URBANopt # :nodoc:
       #
       # [*parameters:*]
       #
-      # * +feature_report+ - _URBANopt::Scenario::DefaultReports::ScenarioReport_ -  ScenarioReport which will be used in creating and then updated by a \REopt Lite opimization response.
+      # * +feature_report+ - _URBANopt::Reporting::DefaultReports::ScenarioReport_ -  ScenarioReport which will be used in creating and then updated by a \REopt Lite opimization response.
       # * +reopt_assumptions_hash+ - _Hash_ - Optional. A \REopt Lite formatted hash containing default parameters (i.e. utility rate, escalation rate) which will be updated by the ScenarioReport (i.e. location, roof availability)
       # * +reopt_output_file+ - _String_ - Optional. Path to a file at which REpopt Lite responses will be saved.
       # * +timeseries_csv_path+ - _String_ - Optional. Path to a file at which the new timeseries CSV for the ScenarioReport will be saved.
       #
       # [*return:*] _URBANopt::Scenario::DefaultReports::ScenarioReport_ Returns an updated ScenarioReport
-      def run_scenario_report(scenario_report:, reopt_assumptions_hash:nil, reopt_output_file:nil, timeseries_csv_path:nil, save_name:nil)
+      def run_scenario_report(scenario_report:, reopt_assumptions_hash:nil, reopt_output_file:nil, timeseries_csv_path:nil, save_name:nil, run_resilience:true)
         if !reopt_assumptions_hash.nil?
           @scenario_reopt_default_assumptions_hash = reopt_assumptions_hash
         end
@@ -163,8 +175,18 @@ module URBANopt # :nodoc:
         reopt_input = adapter.reopt_json_from_scenario_report(scenario_report, @scenario_reopt_default_assumptions_hash)
 
         reopt_output = api.reopt_request(reopt_input, @scenario_reopt_default_output_file)
+        if run_resilience
+          run_uuid = reopt_output['outputs']['Scenario']['run_uuid']
+          if File.directory? @scenario_reopt_default_output_file
+            resilience_stats = api.resilience_request(run_uuid, @scenario_reopt_default_output_file)
+          else
+            resilience_stats = api.resilience_request(run_uuid, @scenario_reopt_default_output_file.sub!('.json','_resilience.json'))
+          end
+        else
+          resilience_stats = nil
+        end
 
-        result = adapter.update_scenario_report(scenario_report, reopt_output, @scenario_timeseries_default_output_file)
+        result = adapter.update_scenario_report(scenario_report, reopt_output, @scenario_timeseries_default_output_file, resilience_stats)
         if !save_name.nil?
           result.save save_name
         end
@@ -176,13 +198,13 @@ module URBANopt # :nodoc:
       #
       # [*parameters:*]
       #
-      # * +feature_reports+ - _Array_ -  An array of _URBANopt::Scenario::DefaultReports::FeatureReport_ objetcs which will each be used to create (and are subsquently updated by) a \REopt Lite opimization response.
+      # * +feature_reports+ - _Array_ -  An array of _URBANopt::Reporting::DefaultReports::FeatureReport_ objetcs which will each be used to create (and are subsquently updated by) a \REopt Lite opimization response.
       # * +reopt_assumptions_hashes+ - _Array_ - Optional. An array of \REopt Lite formatted hashes containing default parameters (i.e. utility rate, escalation rate) which will be updated by the ScenarioReport (i.e. location, roof availability). The number and order of the hashes should match the feature_reports array.
       # * +reopt_output_files+ - _Array_ - Optional. A array of paths to files at which REpopt Lite responses will be saved. The number and order of the paths should match the feature_reports array.
       # * +timeseries_csv_path+ - _Array_ - Optional. A array of paths to files at which the new timeseries CSV for the FeatureReports will be saved. The number and order of the paths should match the feature_reports array.
       #
       # [*return:*] _Array_ Returns an array of updated _URBANopt::Scenario::DefaultReports::FeatureReport_ objects
-      def run_feature_reports(feature_reports:, reopt_assumptions_hashes:[], reopt_output_files:[], timeseries_csv_paths:[], save_names:nil)
+      def run_feature_reports(feature_reports:, reopt_assumptions_hashes:[], reopt_output_files:[], timeseries_csv_paths:[], save_names:nil, run_resilience:true)
 
         if !reopt_assumptions_hashes.empty?
           @feature_reports_reopt_default_assumption_hashes = reopt_assumptions_hashes
@@ -215,11 +237,22 @@ module URBANopt # :nodoc:
           begin
             reopt_input = feature_adapter.reopt_json_from_feature_report(feature_report, @feature_reports_reopt_default_assumption_hashes[idx])
             reopt_output = api.reopt_request(reopt_input, @feature_reports_reopt_default_output_files[idx])
-            new_feature_report = feature_adapter.update_feature_report(feature_report, reopt_output, @feature_reports_timeseries_default_output_files[idx])
+            if run_resilience
+            run_uuid = reopt_output['outputs']['Scenario']['run_uuid']
+              if File.directory? @feature_reports_reopt_default_output_files[idx]
+                resilience_stats = api.resilience_request(run_uuid, @feature_reports_reopt_default_output_files[idx])
+              else
+                resilience_stats = api.resilience_request(run_uuid, @feature_reports_reopt_default_output_files[idx].sub!('.json','_resilience.json'))
+              end
+            else
+              resilience_stats = nil
+            end
+            new_feature_report = feature_adapter.update_feature_report(feature_report, reopt_output, @feature_reports_timeseries_default_output_files[idx], resilience_stats)
             new_feature_reports.push(new_feature_report)
             if !save_names.nil?
               if save_names.length == feature_reports.length
-                new_feature_report.save_feature_report save_names[idx]
+                #new_feature_report.save_feature_report save_names[idx]
+                new_feature_report.save_json_report save_names[idx]
               else
                 warn "Could not save feature reports - the number of save names provided did not match the number of feature reports"
               end
@@ -228,7 +261,7 @@ module URBANopt # :nodoc:
             @@logger.info("Could not optimize Feature Report #{feature_report.name} #{feature_report.id}")
           end
         end
-        
+
         return new_feature_reports
       end
 
@@ -237,22 +270,22 @@ module URBANopt # :nodoc:
       #
       # [*parameters:*]
       #
-      # * +scenario_report+ - _Array_ -  A _URBANopt::Scenario::DefaultReports::ScenarioReport_ which will each be used to create (and is subsquently updated by) \REopt Lite opimization responses for each of its FeatureReports.
+      # * +scenario_report+ - _Array_ -  A _URBANopt::Reporting::DefaultReports::ScenarioReport_ which will each be used to create (and is subsquently updated by) \REopt Lite opimization responses for each of its FeatureReports.
       # * +reopt_assumptions_hashes+ - _Array_ - Optional. An array of \REopt Lite formatted hashes containing default parameters (i.e. utility rate, escalation rate) which will be updated by the ScenarioReport (i.e. location, roof availability). The number and order of the hashes should match the array in ScenarioReport.feature_reports.
       # * +reopt_output_files+ - _Array_ - Optional. An array of paths to files at which REpopt Lite responses will be saved. The number and order of the paths should match the array in ScenarioReport.feature_reports.
       # * +feature_report_timeseries_csv_paths+ - _Array_ - Optional. An array of paths to files at which the new timeseries CSV for the FeatureReports will be saved. The number and order of the paths should match the array in ScenarioReport.feature_reports.
       #
       # [*return:*] _URBANopt::Scenario::DefaultReports::ScenarioReport_ - Returns an updated ScenarioReport
-      def run_scenario_report_features(scenario_report:, reopt_assumptions_hashes:[], reopt_output_files:[], feature_report_timeseries_csv_paths:[], save_names_feature_reports:nil, save_name_scenario_report:nil)
-        new_feature_reports = run_feature_reports(feature_reports:scenario_report.feature_reports, reopt_assumptions_hashes:reopt_assumptions_hashes, reopt_output_files:reopt_output_files, timeseries_csv_paths:feature_report_timeseries_csv_paths,save_names:save_names_feature_reports)
+      def run_scenario_report_features(scenario_report:, reopt_assumptions_hashes:[], reopt_output_files:[], feature_report_timeseries_csv_paths:[], save_names_feature_reports:nil, save_name_scenario_report:nil, run_resilience:true)
+        new_feature_reports = run_feature_reports(feature_reports:scenario_report.feature_reports, reopt_assumptions_hashes:reopt_assumptions_hashes, reopt_output_files:reopt_output_files, timeseries_csv_paths:feature_report_timeseries_csv_paths,save_names:save_names_feature_reports, run_resilience:run_resilience)
 
-        new_scenario_report = URBANopt::Scenario::DefaultReports::ScenarioReport.new
+        new_scenario_report = URBANopt::Reporting::DefaultReports::ScenarioReport.new
         new_scenario_report.id = scenario_report.id
         new_scenario_report.name = scenario_report.name
         new_scenario_report.directory_name = scenario_report.directory_name
 
         timeseries_hash = { column_names: scenario_report.timeseries_csv.column_names }
-        new_scenario_report.timeseries_csv = URBANopt::Scenario::DefaultReports::TimeseriesCSV.new(timeseries_hash)
+        new_scenario_report.timeseries_csv = URBANopt::Reporting::DefaultReports::TimeseriesCSV.new(timeseries_hash)
 
         new_feature_reports.each do |feature_report|
           new_scenario_report.add_feature_report(feature_report)

data/lib/urbanopt/reopt/scenario/reopt_scenario_csv.rb

@@ -1,5 +1,5 @@
 # *********************************************************************************
-# URBANopt, Copyright (c) 2019-2020, Alliance for Sustainable Energy, LLC, and other
+# URBANopt (tm), 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/urbanopt/reopt/scenario_report_adapter.rb

@@ -1,5 +1,5 @@
 # *********************************************************************************
-# URBANopt, Copyright (c) 2019-2020, Alliance for Sustainable Energy, LLC, and other
+# URBANopt (tm), 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,
@@ -28,11 +28,12 @@
 # OF THE POSSIBILITY OF SUCH DAMAGE.
 # *********************************************************************************
 
-require 'urbanopt/scenario/default_reports'
+require 'urbanopt/reporting/default_reports'
 require 'urbanopt/reopt/reopt_logger'
 require 'matrix'
 require 'csv'
 require 'time'
+require_relative 'utilities'
 
 module URBANopt # :nodoc:
   module REopt # :nodoc:
@@ -51,7 +52,7 @@ module URBANopt # :nodoc:
       #
       # [*parameters:*]
       #
-      # * +scenario_report+ - _URBANopt::Scenario::DefaultReports::ScenarioReport_ - ScenarioReport to use in converting the +reopt_assumptions_hash+, if provided, to a \REopt Lite post. Otherwise, if the +reopt_assumptions_hash+ is nil a default post will be updated from this ScenarioReport and submitted to the \REopt Lite API.
+      # * +scenario_report+ - _URBANopt::Reporting::DefaultReports::ScenarioReport_ - ScenarioReport to use in converting the +reopt_assumptions_hash+, if provided, to a \REopt Lite post. Otherwise, if the +reopt_assumptions_hash+ is nil a default post will be updated from this ScenarioReport and submitted to the \REopt Lite API.
       # * +reopt_assumptions_hash+ - _Hash_ - Optional. A hash formatted for submittal to the \REopt Lite API containing default values. Values will be overwritten from the ScenarioReport where available (i.e. latitude, roof_squarefeet). Missing optional parameters will be filled in with default values by the API.
       #
       # [*return:*] _Hash_ - Returns hash formatted for submittal to the \REopt Lite API
@@ -70,31 +71,32 @@ module URBANopt # :nodoc:
         end
 
         # Update required info
-        if scenario_report.location.latitude.nil? || scenario_report.location.longitude.nil? || (scenario_report.location.latitude == 0) || (scenario_report.location.longitude == 0)
+        if scenario_report.location.latitude_deg.nil? || scenario_report.location.longitude_deg.nil? || (scenario_report.location.latitude_deg == 0) || (scenario_report.location.longitude_deg == 0)
           if !scenario_report.feature_reports.nil? && (scenario_report.feature_reports != [])
             lats = []
             longs = []
             scenario_report.feature_reports.each do |x|
-              if ![nil, 0].include?(x[:location][:latitude]) && ![nil, 0].include?(x[:location][:longitude])
-                lats.push(x[:location][:latitude])
-                longs.push(x[:location][:longitude])
+              puts " ERROR: #{x.location.latitude_deg}"
+              if ![nil].include?(x.location.latitude_deg) && ![nil].include?(x.location.longitude_deg)
+                lats.push(x.location.latitude_deg)
+                longs.push(x.location.longitude_deg)
               end
             end
 
             if !lats.empty? && !longs.empty?
-              scenario_report.location.latitude = lats.reduce(:+) / lats.size.to_f
-              scenario_report.location.longitude = longs.reduce(:+) / longs.size.to_f
+              scenario_report.location.latitude_deg = lats.reduce(:+) / lats.size.to_f
+              scenario_report.location.longitude_deg = longs.reduce(:+) / longs.size.to_f
             end
           end
         end
 
         # Update required info
         requireds_names = ['latitude', 'longitude']
-        requireds = [scenario_report.location.latitude, scenario_report.location.longitude]
+        requireds = [scenario_report.location.latitude_deg, scenario_report.location.longitude_deg]
 
         if requireds.include?(nil) || requireds.include?(0)
-          requireds.each_with_index do |i, x|
-            if [nil, 0].include? x
+          requireds.each_with_index do |x, i|
+            if [nil].include? x
               n = requireds_names[i]
               raise "Missing value for #{n} - this is a required input"
             end
@@ -103,20 +105,25 @@ module URBANopt # :nodoc:
 
         reopt_inputs[:Scenario][:description] = description
 
-        reopt_inputs[:Scenario][:Site][:latitude] = scenario_report.location.latitude
-        reopt_inputs[:Scenario][:Site][:longitude] = scenario_report.location.longitude
+        reopt_inputs[:Scenario][:Site][:latitude] = scenario_report.location.latitude_deg
+        reopt_inputs[:Scenario][:Site][:longitude] = scenario_report.location.longitude_deg
 
         # Update optional info
-        if !scenario_report.program.roof_area.nil?
-          reopt_inputs[:Scenario][:Site][:roof_squarefeet] = scenario_report.program.roof_area[:available_roof_area]
+        # REK: attribute names should be updated
+        if reopt_inputs[:Scenario][:Site][:roof_squarefeet].nil?
+          if !scenario_report.program.roof_area_sqft.nil?
+            reopt_inputs[:Scenario][:Site][:roof_squarefeet] = scenario_report.program.roof_area_sqft[:available_roof_area_sqft]
+          end
         end
 
-        if !scenario_report.program.site_area.nil?
-          reopt_inputs[:Scenario][:Site][:land_acres] = scenario_report.program.site_area * 1.0 / 43560 # acres/sqft
+        if reopt_inputs[:Scenario][:Site][:land_acres].nil?
+          if !scenario_report.program.site_area_sqft.nil?
+            reopt_inputs[:Scenario][:Site][:land_acres] = scenario_report.program.site_area_sqft * 1.0 / 43560 # acres/sqft
+          end
         end
 
-        unless scenario_report.timesteps_per_hour.nil?
-          reopt_inputs[:Scenario][:time_steps_per_hour] = scenario_report.timesteps_per_hour
+        if reopt_inputs[:Scenario][:time_steps_per_hour].nil?
+          reopt_inputs[:Scenario][:time_steps_per_hour] = 1
         end
 
         # Update load profile info
@@ -126,27 +133,51 @@ module URBANopt # :nodoc:
           energy_timeseries_kw = t.by_col[col_num].map { |e| ((e * scenario_report.timesteps_per_hour || 0) ) }
           if energy_timeseries_kw.length < (scenario_report.timesteps_per_hour * 8760)
             start_date = Time.parse(t.by_col["Datetime"][0])
-            start_ts = (((start_date.yday * 60.0 * 60.0 * 24) + (start_date.hour * 60.0 * 60.0) + (start_date.min * 60.0) + start_date.sec) /
+            start_ts = (((start_date.yday * 60.0 * 60.0 * 24) + (start_date.hour * 60.0 * 60.0) + (start_date.min * 60.0) + start_date.sec) / \
                         (( 60 / scenario_report.timesteps_per_hour ) * 60)).to_int
             end_date = Time.parse(t.by_col["Datetime"][-1])
-            end_ts = (((end_date.yday * 60.0 * 60.0 * 24) + (end_date.hour * 60.0 * 60.0) + (end_date.min * 60.0) + end_date.sec) /
+            end_ts = (((end_date.yday * 60.0 * 60.0 * 24) + (end_date.hour * 60.0 * 60.0) + (end_date.min * 60.0) + end_date.sec) / \
                         (( 60 / scenario_report.timesteps_per_hour ) * 60)).to_int
             energy_timeseries_kw = [0.0]*(start_ts-1) + energy_timeseries_kw + [0.0]*((scenario_report.timesteps_per_hour * 8760) - end_ts)
           end
-          reopt_inputs[:Scenario][:Site][:LoadProfile][:loads_kw] = energy_timeseries_kw.map { |e| e ? e : 0 }[0,(scenario_report.timesteps_per_hour * 8760)]
+          energy_timeseries_kw = energy_timeseries_kw.map { |e| e ? e : 0 }[0,(scenario_report.timesteps_per_hour * 8760)]
         rescue StandardError
           @@logger.error("Could not parse the annual electric load from the timeseries csv - #{scenario_report.timeseries_csv.path}")
           raise "Could not parse the annual electric load from the timeseries csv - #{scenario_report.timeseries_csv.path}"
         end
+
+        # Convert load to REopt Resolution
+        begin
+          reopt_inputs[:Scenario][:Site][:LoadProfile][:loads_kw] = convert_powerflow_resolution(energy_timeseries_kw, scenario_report.timesteps_per_hour, reopt_inputs[:Scenario][:time_steps_per_hour])
+        rescue
+          @@logger.error("Could not convert the annual electric load from a resolution of #{scenario_report.timesteps_per_hour} to #{reopt_inputs[:Scenario][:time_steps_per_hour]}")
+          raise "Could not convert the annual electric load from a resolution of #{scenario_report.timesteps_per_hour} to #{reopt_inputs[:Scenario][:time_steps_per_hour]}"
+        end
+
+        if reopt_inputs[:Scenario][:Site][:ElectricTariff][:coincident_peak_load_active_timesteps].nil?
+          n_top_values = 100
+          tmp1 = reopt_inputs[:Scenario][:Site][:LoadProfile][:loads_kw]
+          tmp2 = tmp1.each_index.max_by(n_top_values*reopt_inputs[:Scenario][:time_steps_per_hour]){|i| tmp1[i]} 
+          for i in (0...tmp2.count)
+              tmp2[i] += 1
+          end
+          reopt_inputs[:Scenario][:Site][:ElectricTariff][:coincident_peak_load_active_timesteps] = tmp2
+        end
+
+        if reopt_inputs[:Scenario][:Site][:ElectricTariff][:coincident_peak_load_charge_us_dollars_per_kw].nil?
+          reopt_inputs[:Scenario][:Site][:ElectricTariff][:coincident_peak_load_charge_us_dollars_per_kw] = 0
+        end
+
         return reopt_inputs
       end
 
+
       ##
       # Converts a FeatureReport list from a ScenarioReport into an array of \REopt Lite posts
       #
       # [*parameters:*]
       #
-      # * +scenario_report+ - _URBANopt::Scenario::DefaultReports::ScenarioReport_ - ScenarioReport to use in converting FeatureReports and respecitive +reopt_assumptions_hashes+, if provided, to a \REopt Lite post. If no +reopt_assumptions_hashes+ are provided default posts will be updated from these FeatureReports and submitted to the \REopt Lite API.
+      # * +scenario_report+ - _URBANopt::Reporting::DefaultReports::ScenarioReport_ - ScenarioReport to use in converting FeatureReports and respecitive +reopt_assumptions_hashes+, if provided, to a \REopt Lite post. If no +reopt_assumptions_hashes+ are provided default posts will be updated from these FeatureReports and submitted to the \REopt Lite API.
       # * +reopt_assumptions_hashes+ - _Array_ - Optional. An array of hashes formatted for submittal to the \REopt Lite API containing default values. Values will be overwritten from the ScenarioReport where available (i.e. latitude, roof_squarefeet). Missing optional parameters will be filled in with default values by the API. The order should match the list in ScenarioReport.feature_reports.
       #
       # [*return:*] _Array_ - Returns an array of hashes formatted for submittal to the \REopt Lite API in the order of the FeatureReports lited in ScenarioReport.feature_reports.
@@ -168,44 +199,21 @@ module URBANopt # :nodoc:
       #
       # [*parameters:*]
       #
-      # * +scenario_report+ - _URBANopt::Scenario::DefaultReports::ScenarioReport_ - ScenarioReport to update from a \REopt Lite response.
+      # * +scenario_report+ - _URBANopt::Reporting::DefaultReports::ScenarioReport_ - ScenarioReport to update from a \REopt Lite response.
       # * +reopt_output+ - _Hash_ - A hash response from the \REopt Lite API.
       # * +timeseries_csv_path+ - _String_ - Optional. The path to a file at which new timeseries data will be written. If not provided a file is created based on the run_uuid of the \REopt Lite optimization task.
       #
-      # [*return:*] _URBANopt::Scenario::DefaultReports::ScenarioReport_ - Returns an updated ScenarioReport
+      # [*return:*] _URBANopt::Reporting::DefaultReports::ScenarioReport_ - Returns an updated ScenarioReport
       ##
-      def update_scenario_report(scenario_report, reopt_output, timeseries_csv_path = nil)
+      def update_scenario_report(scenario_report, reopt_output, timeseries_csv_path=nil, resilience_stats=nil)
         if reopt_output['outputs']['Scenario']['status'] != 'optimal'
           @@logger.info("Warning cannot Feature Report #{scenario_report.name} #{scenario_report.id}  - REopt optimization was non-optimal")
           return scenario_report
         end
         
-        $ts_per_hour = scenario_report.timesteps_per_hour
-        def scale_timeseries(input, ts_per_hr=$ts_per_hour)
-          if input.nil?
-            return nil
-          end
-          if input.length ==0
-            return nil
-          end
-          if input.length == (8760 * ts_per_hr)
-            return input
-          end
-          result = []
-          input.each do |val| 
-            (1..ts_per_hr).each do |x|
-              result.push(val/ts_per_hr.to_f)
-            end
-          end
-          return result
-        end
-
         # Update location
-        scenario_report.location.latitude = reopt_output['inputs']['Scenario']['Site']['latitude']
-        scenario_report.location.longitude = reopt_output['inputs']['Scenario']['Site']['longitude']
-
-        # Update timeseries csv from \REopt Lite dispatch data
-        scenario_report.timesteps_per_hour = reopt_output['inputs']['Scenario']['time_steps_per_hour']
+        scenario_report.location.latitude_deg = reopt_output['inputs']['Scenario']['Site']['latitude']
+        scenario_report.location.longitude_deg = reopt_output['inputs']['Scenario']['Site']['longitude']
 
         # Update distributed generation sizing and financials
 
@@ -215,55 +223,61 @@ module URBANopt # :nodoc:
         scenario_report.distributed_generation.year_one_demand_cost_us_dollars = reopt_output['outputs']['Scenario']['Site']['ElectricTariff']['year_one_demand_cost_us_dollars'] || 0
         scenario_report.distributed_generation.year_one_bill_us_dollars = reopt_output['outputs']['Scenario']['Site']['ElectricTariff']['year_one_bill_us_dollars'] || 0
         scenario_report.distributed_generation.total_energy_cost_us_dollars = reopt_output['outputs']['Scenario']['Site']['ElectricTariff']['total_energy_cost_us_dollars'] || 0
-        
+        scenario_report.distributed_generation.total_demand_cost_us_dollars = reopt_output['outputs']['Scenario']['Site']['ElectricTariff']['total_demand_cost_us_dollars'] || 0
+        scenario_report.distributed_generation.year_one_energy_cost_bau_us_dollars =  reopt_output['outputs']['Scenario']['Site']['ElectricTariff']['year_one_energy_cost_bau_us_dollars'] || 0
+        scenario_report.distributed_generation.year_one_demand_cost_bau_us_dollars =  reopt_output['outputs']['Scenario']['Site']['ElectricTariff']['year_one_demand_cost_bau_us_dollars'] || 0
+        scenario_report.distributed_generation.year_one_bill_bau_us_dollars = reopt_output['outputs']['Scenario']['Site']['ElectricTariff']['year_one_bill_bau_us_dollars'] || 0
+        scenario_report.distributed_generation.total_demand_cost_bau_us_dollars = reopt_output['outputs']['Scenario']['Site']['ElectricTariff']['total_demand_cost_bau_us_dollars'] || 0
+        scenario_report.distributed_generation.total_energy_cost_bau_us_dollars = reopt_output['outputs']['Scenario']['Site']['ElectricTariff']['total_energy_cost_bau_us_dollars'] || 0
+        if !resilience_stats.nil?
+          scenario_report.distributed_generation.resilience_hours_min = resilience_stats['resilience_hours_min']
+          scenario_report.distributed_generation.resilience_hours_max = resilience_stats['resilience_hours_max']
+          scenario_report.distributed_generation.resilience_hours_avg = resilience_stats['resilience_hours_avg']
+          scenario_report.distributed_generation.probs_of_surviving = resilience_stats['probs_of_surviving']
+          scenario_report.distributed_generation.probs_of_surviving_by_month = resilience_stats['probs_of_surviving_by_month']
+          scenario_report.distributed_generation.probs_of_surviving_by_hour_of_the_day = resilience_stats['probs_of_surviving_by_hour_of_the_day']  
+        end
+
         if reopt_output['outputs']['Scenario']['Site']['PV'].class == Hash
           reopt_output['outputs']['Scenario']['Site']['PV'] = [reopt_output['outputs']['Scenario']['Site']['PV']]
         elsif reopt_output['outputs']['Scenario']['Site']['PV'].nil?
           reopt_output['outputs']['Scenario']['Site']['PV'] = []
         end
-        
-        reopt_output['outputs']['Scenario']['Site']['PV'].each_with_index do |pv, i| 
-          scenario_report.distributed_generation.add_tech 'solar_pv',  URBANopt::Scenario::DefaultReports::SolarPV.new( {size_kw: (pv['size_kw'] || 0), id: i })
+
+        reopt_output['outputs']['Scenario']['Site']['PV'].each_with_index do |pv, i|
+          scenario_report.distributed_generation.add_tech 'solar_pv',  URBANopt::Reporting::DefaultReports::SolarPV.new( {size_kw: (pv['size_kw'] || 0), id: i })
         end
 
         wind = reopt_output['outputs']['Scenario']['Site']['Wind']
         if !wind['size_kw'].nil? and wind['size_kw'] != 0
-          scenario_report.distributed_generation.add_tech 'wind',  URBANopt::Scenario::DefaultReports::Wind.new( {size_kw: (wind['size_kw'] || 0) })
+          scenario_report.distributed_generation.add_tech 'wind',  URBANopt::Reporting::DefaultReports::Wind.new( {size_kw: (wind['size_kw'] || 0) })
         end
 
         generator = reopt_output['outputs']['Scenario']['Site']['Generator']
         if !generator['size_kw'].nil? and generator['size_kw'] != 0
-          scenario_report.distributed_generation.add_tech 'generator',  URBANopt::Scenario::DefaultReports::Generator.new( {size_kw: (generator['size_kw'] || 0) })
+          scenario_report.distributed_generation.add_tech 'generator',  URBANopt::Reporting::DefaultReports::Generator.new( {size_kw: (generator['size_kw'] || 0) })
         end
 
         storage = reopt_output['outputs']['Scenario']['Site']['Storage']
         if !storage['size_kw'].nil?  and storage['size_kw'] != 0
-          scenario_report.distributed_generation.add_tech 'storage',  URBANopt::Scenario::DefaultReports::Storage.new( {size_kwh: (storage['size_kwh'] || 0), size_kw: (storage['size_kw'] || 0) })
+          scenario_report.distributed_generation.add_tech 'storage',  URBANopt::Reporting::DefaultReports::Storage.new( {size_kwh: (storage['size_kwh'] || 0), size_kw: (storage['size_kw'] || 0) })
         end
         
+        reopt_resolution = reopt_output['inputs']['Scenario']['time_steps_per_hour']
         generation_timeseries_kwh = Matrix[[0] * (8760 * scenario_report.timesteps_per_hour)]
-
         
-        reopt_output['outputs']['Scenario']['Site']['PV'].each do |pv| 
+        reopt_output['outputs']['Scenario']['Site']['PV'].each do |pv|
           if (pv['size_kw'] || 0) > 0
             if !pv['year_one_power_production_series_kw'].nil?
-              generation_timeseries_kwh += Matrix[pv['year_one_power_production_series_kw']]
+              generation_timeseries_kwh += Matrix[convert_powerflow_resolution(pv['year_one_power_production_series_kw'], reopt_resolution, scenario_report.timesteps_per_hour)]
             end
           end
          end
 
-        unless reopt_output['outputs']['Scenario']['Site']['Storage'].nil?
-          if (reopt_output['outputs']['Scenario']['Site']['Storage']['size_kw'] or 0) > 0
-            if !reopt_output['outputs']['Scenario']['Site']['Storage']['year_one_to_grid_series_kw'].nil?
-              generation_timeseries_kwh = generation_timeseries_kwh + Matrix[reopt_output['outputs']['Scenario']['Site']['Storage']['year_one_to_grid_series_kw']]
-            end
-          end
-        end
-
         unless reopt_output['outputs']['Scenario']['Site']['Wind'].nil?
           if (reopt_output['outputs']['Scenario']['Site']['Wind']['size_kw'] || 0) > 0
             if !reopt_output['outputs']['Scenario']['Site']['Wind']['year_one_power_production_series_kw'].nil?
-              generation_timeseries_kwh += Matrix[reopt_output['outputs']['Scenario']['Site']['Wind']['year_one_power_production_series_kw']]
+              generation_timeseries_kwh += Matrix[convert_powerflow_resolution(reopt_output['outputs']['Scenario']['Site']['Wind']['year_one_power_production_series_kw'], reopt_resolution, scenario_report.timesteps_per_hour)]
             end
           end
         end
@@ -271,7 +285,7 @@ module URBANopt # :nodoc:
         unless reopt_output['outputs']['Scenario']['Site']['Generator'].nil?
           if (reopt_output['outputs']['Scenario']['Site']['Generator']['size_kw'] || 0) > 0
             if !reopt_output['outputs']['Scenario']['Site']['Generator']['year_one_power_production_series_kw'].nil?
-              generation_timeseries_kwh += Matrix[reopt_output['outputs']['Scenario']['Site']['Generator']['year_one_power_production_series_kw']]
+              generation_timeseries_kwh += Matrix[convert_powerflow_resolution(reopt_output['outputs']['Scenario']['Site']['Generator']['year_one_power_production_series_kw'], reopt_resolution, scenario_report.timesteps_per_hour)]
             end
           end
         end
@@ -283,70 +297,70 @@ module URBANopt # :nodoc:
           scenario_report.timeseries_csv.column_names.push('REopt:ElectricityProduced:Total(kw)')
         end
 
-        $load = scale_timeseries(reopt_output['outputs']['Scenario']['Site']['LoadProfile']['year_one_electric_load_series_kw']) || [0] * (8760 * scenario_report.timesteps_per_hour)
+        $load = convert_powerflow_resolution(reopt_output['outputs']['Scenario']['Site']['LoadProfile']['year_one_electric_load_series_kw'], reopt_resolution, scenario_report.timesteps_per_hour) || [0] * (8760 * scenario_report.timesteps_per_hour)
         $load_col = scenario_report.timeseries_csv.column_names.index('REopt:Electricity:Load:Total(kw)')
         if $load_col.nil?
           $load_col = scenario_report.timeseries_csv.column_names.length
           scenario_report.timeseries_csv.column_names.push('REopt:Electricity:Load:Total(kw)')
         end
 
-        $utility_to_load = scale_timeseries(reopt_output['outputs']['Scenario']['Site']['ElectricTariff']['year_one_to_load_series_kw']) || [0] * (8760 * scenario_report.timesteps_per_hour)
+        $utility_to_load = convert_powerflow_resolution(reopt_output['outputs']['Scenario']['Site']['ElectricTariff']['year_one_to_load_series_kw'], reopt_resolution, scenario_report.timesteps_per_hour) || [0] * (8760 * scenario_report.timesteps_per_hour)
         $utility_to_load_col = scenario_report.timeseries_csv.column_names.index('REopt:Electricity:Grid:ToLoad(kw)')
         if $utility_to_load_col.nil?
           $utility_to_load_col = scenario_report.timeseries_csv.column_names.length
           scenario_report.timeseries_csv.column_names.push('REopt:Electricity:Grid:ToLoad(kw)')
         end
 
-        $utility_to_battery = scale_timeseries(reopt_output['outputs']['Scenario']['Site']['ElectricTariff']['year_one_to_battery_series_kw']) || [0] * (8760 * scenario_report.timesteps_per_hour)
+        $utility_to_battery = convert_powerflow_resolution(reopt_output['outputs']['Scenario']['Site']['ElectricTariff']['year_one_to_battery_series_kw'], reopt_resolution, scenario_report.timesteps_per_hour) || [0] * (8760 * scenario_report.timesteps_per_hour)
         $utility_to_battery_col = scenario_report.timeseries_csv.column_names.index('REopt:Electricity:Grid:ToBattery(kw)')
         if $utility_to_battery_col.nil?
           $utility_to_battery_col = scenario_report.timeseries_csv.column_names.length
           scenario_report.timeseries_csv.column_names.push('REopt:Electricity:Grid:ToBattery(kw)')
         end
 
-        $storage_to_load = scale_timeseries(reopt_output['outputs']['Scenario']['Site']['Storage']['year_one_to_load_series_kw']) || [0] * (8760 * scenario_report.timesteps_per_hour)
+        $storage_to_load = convert_powerflow_resolution(reopt_output['outputs']['Scenario']['Site']['Storage']['year_one_to_load_series_kw'], reopt_resolution, scenario_report.timesteps_per_hour) || [0] * (8760 * scenario_report.timesteps_per_hour)
         $storage_to_load_col = scenario_report.timeseries_csv.column_names.index('REopt:Electricity:Storage:ToLoad(kw)')
         if $storage_to_load_col.nil?
           $storage_to_load_col = scenario_report.timeseries_csv.column_names.length
           scenario_report.timeseries_csv.column_names.push('REopt:Electricity:Storage:ToLoad(kw)')
         end
 
-        $storage_to_grid = scale_timeseries(reopt_output['outputs']['Scenario']['Site']['Storage']['year_one_to_grid_series_kw']) || [0] * (8760 * scenario_report.timesteps_per_hour)
+        $storage_to_grid = convert_powerflow_resolution(reopt_output['outputs']['Scenario']['Site']['Storage']['year_one_to_grid_series_kw'], reopt_resolution, scenario_report.timesteps_per_hour) || [0] * (8760 * scenario_report.timesteps_per_hour)
         $storage_to_grid_col = scenario_report.timeseries_csv.column_names.index('REopt:Electricity:Storage:ToGrid(kw)')
         if $storage_to_grid_col.nil?
           $storage_to_grid_col = scenario_report.timeseries_csv.column_names.length
           scenario_report.timeseries_csv.column_names.push('REopt:Electricity:Storage:ToGrid(kw)')
         end
 
-        $storage_soc = scale_timeseries(reopt_output['outputs']['Scenario']['Site']['Storage']['year_one_soc_series_pct']) || [0] * (8760 * scenario_report.timesteps_per_hour)
+        $storage_soc = convert_powerflow_resolution(reopt_output['outputs']['Scenario']['Site']['Storage']['year_one_soc_series_pct'], reopt_resolution, scenario_report.timesteps_per_hour) || [0] * (8760 * scenario_report.timesteps_per_hour)
         $storage_soc_col = scenario_report.timeseries_csv.column_names.index('REopt:Electricity:Storage:StateOfCharge(pct)')
         if $storage_soc_col.nil?
           $storage_soc_col = scenario_report.timeseries_csv.column_names.length
           scenario_report.timeseries_csv.column_names.push('REopt:Electricity:Storage:StateOfCharge(pct)')
         end
 
-        $generator_total = scale_timeseries(reopt_output['outputs']['Scenario']['Site']['Generator']['year_one_power_production_series_kw']) || [0] * (8760 * scenario_report.timesteps_per_hour)
+        $generator_total = convert_powerflow_resolution(reopt_output['outputs']['Scenario']['Site']['Generator']['year_one_power_production_series_kw'], reopt_resolution, scenario_report.timesteps_per_hour) || [0] * (8760 * scenario_report.timesteps_per_hour)
         $generator_total_col = scenario_report.timeseries_csv.column_names.index('REopt:ElectricityProduced:Generator:Total(kw)')
         if $generator_total_col.nil?
           $generator_total_col = scenario_report.timeseries_csv.column_names.length
           scenario_report.timeseries_csv.column_names.push('REopt:ElectricityProduced:Generator:Total(kw)')
         end
 
-        $generator_to_battery = scale_timeseries(reopt_output['outputs']['Scenario']['Site']['Generator']['year_one_to_battery_series_kw']) || [0] * (8760 * scenario_report.timesteps_per_hour)
+        $generator_to_battery = convert_powerflow_resolution(reopt_output['outputs']['Scenario']['Site']['Generator']['year_one_to_battery_series_kw'], reopt_resolution, scenario_report.timesteps_per_hour) || [0] * (8760 * scenario_report.timesteps_per_hour)
         $generator_to_battery_col = scenario_report.timeseries_csv.column_names.index('REopt:ElectricityProduced:Generator:ToBattery(kw)')
         if $generator_to_battery_col.nil?
           $generator_to_battery_col = scenario_report.timeseries_csv.column_names.length
           scenario_report.timeseries_csv.column_names.push('REopt:ElectricityProduced:Generator:ToBattery(kw)')
         end
 
-        $generator_to_load = scale_timeseries(reopt_output['outputs']['Scenario']['Site']['Generator']['year_one_to_load_series_kw']) || [0] * (8760 * scenario_report.timesteps_per_hour)
+        $generator_to_load = convert_powerflow_resolution(reopt_output['outputs']['Scenario']['Site']['Generator']['year_one_to_load_series_kw'], reopt_resolution, scenario_report.timesteps_per_hour) || [0] * (8760 * scenario_report.timesteps_per_hour)
         $generator_to_load_col = scenario_report.timeseries_csv.column_names.index('REopt:ElectricityProduced:Generator:ToLoad(kw)')
         if $generator_to_load_col.nil?
           $generator_to_load_col = scenario_report.timeseries_csv.column_names.length
           scenario_report.timeseries_csv.column_names.push('REopt:ElectricityProduced:Generator:ToLoad(kw)')
         end
 
-        $generator_to_grid = scale_timeseries(reopt_output['outputs']['Scenario']['Site']['Generator']['year_one_to_grid_series_kw']) || [0] * (8760 * scenario_report.timesteps_per_hour)
+        $generator_to_grid = convert_powerflow_resolution(reopt_output['outputs']['Scenario']['Site']['Generator']['year_one_to_grid_series_kw'], reopt_resolution, scenario_report.timesteps_per_hour) || [0] * (8760 * scenario_report.timesteps_per_hour)
         $generator_to_grid_col = scenario_report.timeseries_csv.column_names.index('REopt:ElectricityProduced:Generator:ToGrid(kw)')
         if $generator_to_grid_col.nil?
           $generator_to_grid_col = scenario_report.timeseries_csv.column_names.length
@@ -384,10 +398,10 @@ module URBANopt # :nodoc:
 
         reopt_output['outputs']['Scenario']['Site']['PV'].each_with_index do |pv, i|
           if (pv['size_kw'] || 0) > 0
-            $pv_total += Matrix[scale_timeseries(pv['year_one_power_production_series_kw']) || [0] * (8760 * scenario_report.timesteps_per_hour)]
-            $pv_to_battery += Matrix[scale_timeseries(pv['year_one_to_battery_series_kw']) || [0] * (8760 * scenario_report.timesteps_per_hour)]
-            $pv_to_load += Matrix[scale_timeseries(pv['year_one_to_load_series_kw']) || [0] * (8760 * scenario_report.timesteps_per_hour)]
-            $pv_to_grid += Matrix[scale_timeseries(pv['year_one_to_grid_series_kw']) || [0] * (8760 * scenario_report.timesteps_per_hour)]
+            $pv_total += Matrix[convert_powerflow_resolution(pv['year_one_power_production_series_kw'], reopt_resolution, scenario_report.timesteps_per_hour) || [0] * (8760 * scenario_report.timesteps_per_hour)]
+            $pv_to_battery += Matrix[convert_powerflow_resolution(pv['year_one_to_battery_series_kw'], reopt_resolution, scenario_report.timesteps_per_hour) || [0] * (8760 * scenario_report.timesteps_per_hour)]
+            $pv_to_load += Matrix[convert_powerflow_resolution(pv['year_one_to_load_series_kw'], reopt_resolution, scenario_report.timesteps_per_hour) || [0] * (8760 * scenario_report.timesteps_per_hour)]
+            $pv_to_grid += Matrix[convert_powerflow_resolution(pv['year_one_to_grid_series_kw'], reopt_resolution, scenario_report.timesteps_per_hour) || [0] * (8760 * scenario_report.timesteps_per_hour)]
           end
         end
 
@@ -396,28 +410,28 @@ module URBANopt # :nodoc:
         $pv_to_load = $pv_to_load.to_a[0]
         $pv_to_grid = $pv_to_grid.to_a[0]
 
-        $wind_total = scale_timeseries(reopt_output['outputs']['Scenario']['Site']['Wind']['year_one_power_production_series_kw']) || [0] * (8760 * scenario_report.timesteps_per_hour)
+        $wind_total = convert_powerflow_resolution(reopt_output['outputs']['Scenario']['Site']['Wind']['year_one_power_production_series_kw'], reopt_resolution, scenario_report.timesteps_per_hour) || [0] * (8760 * scenario_report.timesteps_per_hour)
         $wind_total_col = scenario_report.timeseries_csv.column_names.index('REopt:ElectricityProduced:Wind:Total(kw)')
         if $wind_total_col.nil?
           $wind_total_col = scenario_report.timeseries_csv.column_names.length
           scenario_report.timeseries_csv.column_names.push('REopt:ElectricityProduced:Wind:Total(kw)')
         end
 
-        $wind_to_battery = scale_timeseries(reopt_output['outputs']['Scenario']['Site']['Wind']['year_one_to_battery_series_kw']) || [0] * (8760 * scenario_report.timesteps_per_hour)
+        $wind_to_battery = convert_powerflow_resolution(reopt_output['outputs']['Scenario']['Site']['Wind']['year_one_to_battery_series_kw'], reopt_resolution, scenario_report.timesteps_per_hour) || [0] * (8760 * scenario_report.timesteps_per_hour)
         $wind_to_battery_col = scenario_report.timeseries_csv.column_names.index('REopt:ElectricityProduced:Wind:ToBattery(kw)')
         if $wind_to_battery_col.nil?
           $wind_to_battery_col = scenario_report.timeseries_csv.column_names.length
           scenario_report.timeseries_csv.column_names.push('REopt:ElectricityProduced:Wind:ToBattery(kw)')
         end
 
-        $wind_to_load = scale_timeseries(reopt_output['outputs']['Scenario']['Site']['Wind']['year_one_to_load_series_kw']) || [0] * (8760 * scenario_report.timesteps_per_hour)
+        $wind_to_load = convert_powerflow_resolution(reopt_output['outputs']['Scenario']['Site']['Wind']['year_one_to_load_series_kw'], reopt_resolution, scenario_report.timesteps_per_hour) || [0] * (8760 * scenario_report.timesteps_per_hour)
         $wind_to_load_col = scenario_report.timeseries_csv.column_names.index('REopt:ElectricityProduced:Wind:ToLoad(kw)')
         if $wind_to_load_col.nil?
           $wind_to_load_col = scenario_report.timeseries_csv.column_names.length
           scenario_report.timeseries_csv.column_names.push('REopt:ElectricityProduced:Wind:ToLoad(kw)')
         end
 
-        $wind_to_grid = scale_timeseries(reopt_output['outputs']['Scenario']['Site']['Wind']['year_one_to_grid_series_kw']) || [0] * (8760 * scenario_report.timesteps_per_hour)
+        $wind_to_grid = convert_powerflow_resolution(reopt_output['outputs']['Scenario']['Site']['Wind']['year_one_to_grid_series_kw'], reopt_resolution, scenario_report.timesteps_per_hour) || [0] * (8760 * scenario_report.timesteps_per_hour)
         $wind_to_grid_col = scenario_report.timeseries_csv.column_names.index('REopt:ElectricityProduced:Wind:ToGrid(kw)')
         if $wind_to_grid_col.nil?
           $wind_to_grid_col = scenario_report.timeseries_csv.column_names.length
@@ -448,17 +462,22 @@ module URBANopt # :nodoc:
         end
 
         old_data = CSV.open(scenario_report.timeseries_csv.path).read
-        start_date = Time.parse(old_data[1][0])
-        start_ts = (((start_date.yday * 60.0 * 60.0 * 24) + (start_date.hour * 60.0 * 60.0) + (start_date.min * 60.0) + start_date.sec) / (( 60 / scenario_report.timesteps_per_hour ) * 60)).to_int
+        start_date = Time.parse(old_data[1][0]) # Time is the end of the timestep 
+        start_ts = (
+                      (
+                        ((start_date.yday - 1) * 60.0 * 60.0 * 24) + 
+                        (((start_date.hour)  - 1) * 60.0 * 60.0) + 
+                        (start_date.min * 60.0) + start_date.sec ) /
+                      (( 60 / scenario_report.timesteps_per_hour ) * 60)
+                    ).to_int
         mod_data = old_data.map.with_index do |x, i|
           if i > 0
-            modrow(x, start_ts + i -2)
+            modrow(x, start_ts + i -1)
           else
             x
           end
         end
         mod_data[0] = scenario_report.timeseries_csv.column_names
-
         scenario_report.timeseries_csv.reload_data(mod_data)
         return scenario_report
       end