urbanopt-reopt 0.6.0 → 0.6.1

data/lib/urbanopt/reopt/reopt_logger.rb

@@ -42,7 +42,7 @@ require 'logger'
 
 module URBANopt
   module REopt
-    @@reopt_logger = Logger.new(STDOUT)
+    @@reopt_logger = Logger.new($stdout)
     ##
     # Definining class variable "@@logger" to log errors, info and warning messages.
     def self.reopt_logger

data/lib/urbanopt/reopt/reopt_post_processor.rb

@@ -79,18 +79,18 @@ module URBANopt # :nodoc:
         if !scenario_report.nil?
           @scenario_report = scenario_report
 
-          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"))
+          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")
           @scenario_timeseries_default_output_file = File.join(@scenario_report.directory_name, "scenario_report_#{@scenario_report.id}_timeseries.csv")
 
           @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"))
+            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
@@ -113,8 +113,7 @@ module URBANopt # :nodoc:
         end
       end
 
-      attr_accessor :scenario_reopt_default_assumptions_hash, :scenario_reopt_default_output_file, :scenario_timeseries_default_output_file
-      attr_accessor :feature_reports_reopt_default_assumption_hashes, :feature_reports_reopt_default_output_files, :feature_reports_timeseries_default_output_files
+      attr_accessor :scenario_reopt_default_assumptions_hash, :scenario_reopt_default_output_file, :scenario_timeseries_default_output_file, :feature_reports_reopt_default_assumption_hashes, :feature_reports_reopt_default_output_files, :feature_reports_timeseries_default_output_files
 
       ##
       # Updates a FeatureReport based on an optional set of \REopt Lite optimization assumptions.
@@ -129,7 +128,7 @@ module URBANopt # :nodoc:
       #
       # [*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, run_resilience:true)
+      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
 
@@ -143,7 +142,7 @@ module URBANopt # :nodoc:
           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'))
+            resilience_stats = api.resilience_request(run_uuid, reopt_output_file.sub!('.json', '_resilience.json'))
           end
         else
           resilience_stats = nil
@@ -167,7 +166,7 @@ module URBANopt # :nodoc:
       # * +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, run_resilience:true)
+      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
@@ -189,7 +188,7 @@ module URBANopt # :nodoc:
           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'))
+            resilience_stats = api.resilience_request(run_uuid, @scenario_reopt_default_output_file.sub!('.json', '_resilience.json'))
           end
         else
           resilience_stats = nil
@@ -213,8 +212,7 @@ module URBANopt # :nodoc:
       # * +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, run_resilience:true)
-
+      def run_feature_reports(feature_reports:, reopt_assumptions_hashes: [], reopt_output_files: [], timeseries_csv_paths: [], save_names: nil, run_resilience: true, keep_existing_output: false)
         if !reopt_assumptions_hashes.empty?
           @feature_reports_reopt_default_assumption_hashes = reopt_assumptions_hashes
         end
@@ -243,36 +241,59 @@ module URBANopt # :nodoc:
         feature_adapter = URBANopt::REopt::FeatureReportAdapter.new
         new_feature_reports = []
         feature_reports.each_with_index do |feature_report, idx|
-          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])
-            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])
+          # check if we should rerun
+          if !(keep_existing_output && output_exists(@feature_reports_reopt_default_output_files[idx]))
+            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])
+              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 = api.resilience_request(run_uuid, @feature_reports_reopt_default_output_files[idx].sub!('.json','_resilience.json'))
+                resilience_stats = nil
               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 save_names[idx]
-              else
-                warn "Could not save feature reports - the number of save names provided did not match the number of feature reports"
+              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 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
               end
+            rescue StandardError
+              @@logger.info("Could not optimize Feature Report #{feature_report.name} #{feature_report.id}")
             end
-          rescue StandardError
-            @@logger.info("Could not optimize Feature Report #{feature_report.name} #{feature_report.id}")
+          else
+            puts('Output file already exists...skipping')
           end
         end
 
         return new_feature_reports
       end
 
+      # Checks whether a feature has already been run by determining if output files already exists (for rate limit issues and larger projects)
+      ##
+      #
+      # [*parameters:*]
+      #
+      # * +output_file+ - _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.
+      # [*return:*] _Boolean_ - Returns true if file or nonempty directory exist
+      def output_exists(output_file)
+        res = false
+        if File.directory?(output_file) && !File.empty?(output_file)
+          res = true
+        elsif File.exist? output_file
+          res = true
+        end
+
+        return res
+      end
+
       # Updates a ScenarioReport based on an optional set of \REopt Lite optimization assumptions.
       ##
       #
@@ -284,22 +305,26 @@ module URBANopt # :nodoc:
       # * +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, 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)
-
+      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, keep_existing_output: false)
+        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, keep_existing_output: keep_existing_output)
+        puts("KEEP EXISTING? #{keep_existing_output}")
+        # only do this if you have run feature reports
         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
+        if !new_feature_reports.empty?
 
-        timeseries_hash = { column_names: scenario_report.timeseries_csv.column_names }
-        new_scenario_report.timeseries_csv = URBANopt::Reporting::DefaultReports::TimeseriesCSV.new(timeseries_hash)
+          new_scenario_report.id = scenario_report.id
+          new_scenario_report.name = scenario_report.name
+          new_scenario_report.directory_name = scenario_report.directory_name
 
-        new_feature_reports.each do |feature_report|
-          new_scenario_report.add_feature_report(feature_report)
-        end
-        if !save_name_scenario_report.nil?
-          new_scenario_report.save save_name_scenario_report
+          timeseries_hash = { column_names: scenario_report.timeseries_csv.column_names }
+          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)
+          end
+          if !save_name_scenario_report.nil?
+            new_scenario_report.save save_name_scenario_report
+          end
         end
         return new_scenario_report
       end

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

@@ -44,8 +44,10 @@ require 'urbanopt/scenario/simulation_dir_osw'
 require 'csv'
 require 'fileutils'
 
-module URBANopt # nodoc:
-  module Scenario # nodoc:
+# nodoc:
+module URBANopt
+  # nodoc:
+  module Scenario
     class REoptScenarioCSV < ScenarioCSV
       ##
       # REoptScenarioCSV is an extension of ScenarioCSV which assigns a Simulation Mapper to each Feature in a FeatureFile using a simple CSV format.
@@ -101,10 +103,8 @@ module URBANopt # nodoc:
           mapper_class = row[2].chomp
           # Assume fourth columns, if exists, contains the name of the JSON file in the reopt_files_dir to use when running \REopt Lite for the feature report
 
-          if row.length > 3
-            if !@reopt_files_dir.nil?
-              @reopt_feature_assumptions[idx - 1] = File.join(@reopt_files_dir, row[3].chomp)
-            end
+          if row.length > 3 && !@reopt_files_dir.nil?
+            @reopt_feature_assumptions[idx - 1] = File.join(@reopt_files_dir, row[3].chomp)
           end
 
           # gets +features+ from the feature_file.
@@ -120,6 +120,6 @@ module URBANopt # nodoc:
         end
         return result
       end
-  end
+    end
   end
 end

data/lib/urbanopt/reopt/scenario_report_adapter.rb

@@ -81,22 +81,20 @@ module URBANopt # :nodoc:
         end
 
         # Update required info
-        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|
-              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
+        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)) && (!scenario_report.feature_reports.nil? && (scenario_report.feature_reports != []))
+          lats = []
+          longs = []
+          scenario_report.feature_reports.each do |x|
+            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_deg = lats.reduce(:+) / lats.size.to_f
-              scenario_report.location.longitude_deg = longs.reduce(:+) / longs.size.to_f
-            end
+          if !lats.empty? && !longs.empty?
+            scenario_report.location.latitude_deg = lats.reduce(:+) / lats.size.to_f
+            scenario_report.location.longitude_deg = longs.reduce(:+) / longs.size.to_f
           end
         end
 
@@ -120,16 +118,12 @@ module URBANopt # :nodoc:
 
         # Update optional info
         # 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
+        if reopt_inputs[:Scenario][:Site][:roof_squarefeet].nil? && !scenario_report.program.roof_area_sqft.nil?
+          reopt_inputs[:Scenario][:Site][:roof_squarefeet] = scenario_report.program.roof_area_sqft[:available_roof_area_sqft]
         end
 
-        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
+        if reopt_inputs[:Scenario][:Site][:land_acres].nil? && !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
 
         if reopt_inputs[:Scenario][:time_steps_per_hour].nil?
@@ -140,17 +134,17 @@ module URBANopt # :nodoc:
         begin
           col_num = scenario_report.timeseries_csv.column_names.index('Electricity:Facility(kWh)')
           t = CSV.read(scenario_report.timeseries_csv.path, headers: true, converters: :numeric)
-          energy_timeseries_kw = t.by_col[col_num].map { |e| ((e * scenario_report.timesteps_per_hour || 0) ) }
+          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_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) / \
-                        (( 60 / scenario_report.timesteps_per_hour ) * 60)).to_int
-            end_date = Time.parse(t.by_col["Datetime"][-1])
+                        ((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) / \
-                        (( 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)
+                        ((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
-          energy_timeseries_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 || 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}"
@@ -159,7 +153,7 @@ module URBANopt # :nodoc:
         # 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
+        rescue StandardError
           @@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
@@ -167,9 +161,9 @@ module URBANopt # :nodoc:
         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]}
+          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
+            tmp2[i] += 1
           end
           reopt_inputs[:Scenario][:Site][:ElectricTariff][:coincident_peak_load_active_timesteps] = tmp2
         end
@@ -181,7 +175,6 @@ module URBANopt # :nodoc:
         return reopt_inputs
       end
 
-
       ##
       # Converts a FeatureReport list from a ScenarioReport into an array of \REopt Lite posts
       #
@@ -215,7 +208,7 @@ module URBANopt # :nodoc:
       #
       # [*return:*] _URBANopt::Reporting::DefaultReports::ScenarioReport_ - Returns an updated ScenarioReport
       ##
-      def update_scenario_report(scenario_report, reopt_output, timeseries_csv_path=nil, resilience_stats=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
@@ -248,56 +241,46 @@ module URBANopt # :nodoc:
           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
+        if reopt_output['outputs']['Scenario']['Site']['PV'].instance_of?(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::Reporting::DefaultReports::SolarPV.new( {size_kw: (pv['size_kw'] || 0), id: 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::Reporting::DefaultReports::Wind.new( {size_kw: (wind['size_kw'] || 0) })
+        if !wind['size_kw'].nil? && (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::Reporting::DefaultReports::Generator.new( {size_kw: (generator['size_kw'] || 0) })
+        if !generator['size_kw'].nil? && (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::Reporting::DefaultReports::Storage.new( {size_kwh: (storage['size_kwh'] || 0), size_kw: (storage['size_kw'] || 0) })
+        if !storage['size_kw'].nil? && (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|
-          if (pv['size_kw'] || 0) > 0
-            if !pv['year_one_power_production_series_kw'].nil?
-              generation_timeseries_kwh += Matrix[convert_powerflow_resolution(pv['year_one_power_production_series_kw'], reopt_resolution, scenario_report.timesteps_per_hour)]
-            end
+          if (pv['size_kw'] || 0) > 0 && !pv['year_one_power_production_series_kw'].nil?
+            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']['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[convert_powerflow_resolution(reopt_output['outputs']['Scenario']['Site']['Wind']['year_one_power_production_series_kw'], reopt_resolution, scenario_report.timesteps_per_hour)]
-            end
-          end
+        if !reopt_output['outputs']['Scenario']['Site']['Wind'].nil? && ((reopt_output['outputs']['Scenario']['Site']['Wind']['size_kw'] || 0) > 0) && !reopt_output['outputs']['Scenario']['Site']['Wind']['year_one_power_production_series_kw'].nil?
+          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
 
-        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[convert_powerflow_resolution(reopt_output['outputs']['Scenario']['Site']['Generator']['year_one_power_production_series_kw'], reopt_resolution, scenario_report.timesteps_per_hour)]
-            end
-          end
+        if !reopt_output['outputs']['Scenario']['Site']['Generator'].nil? && ((reopt_output['outputs']['Scenario']['Site']['Generator']['size_kw'] || 0) > 0) && !reopt_output['outputs']['Scenario']['Site']['Generator']['year_one_power_production_series_kw'].nil?
+          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
 
         $generation_timeseries_kwh = generation_timeseries_kwh.to_a[0] || [0] * (8760 * scenario_report.timesteps_per_hour)
@@ -476,13 +459,13 @@ module URBANopt # :nodoc:
         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)
+                        ((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 -1)
+            modrow(x, start_ts + i - 1)
           else
             x
           end

data/lib/urbanopt/reopt/utilities.rb

@@ -1,111 +1,111 @@
-def convert_powerflow_resolution(timeseries_kw, original_res, destination_res)	
-	if timeseries_kw.nil?
-        return nil
-	end
-    
-	if timeseries_kw.length == 0
-		return nil
-	end
-	
-	if original_res > destination_res
-		# Timesteps will be reduced, i.e. 35040 -> 8760
-		
-    	# This algorithm works by stepping along the origin timeseries at an interval equal to
-    	# one timestep in the destintion timeseries and then averaging all origin values that
-    	# coincide with the interval. Averages are weighted if a destination timestep
-    	# only partaially overlaps an origin timestep.
-    	
-    	# EX 1
-    	# stepping interval 2
-    	# origin stepping       | 1 | 2 | 2 | 4 |
-    	# destination stepping  |  1.5  |   3   |
+def convert_powerflow_resolution(timeseries_kw, original_res, destination_res)
+  if timeseries_kw.nil?
+    return nil
+  end
 
-    	# EX 2
-    	# stepping interval 2.5
-    	# origin stepping       | 1 | 1 | 4 | 2 | 2 |
-    	# destination stepping  |   1.6   |  2.4    |
-    	
-    	result = []
-    	stepping_interval = Float(original_res) / Float(destination_res)
-    	current_origin_ts = 0 # fraction stepped along the origin time series
-		current_origin_idx = 0 # current integer index of the origin timeseries
-		(0..(8760*destination_res-1)).each do |ts|
-			next_stopping_ts = current_origin_ts + stepping_interval #stop at the next destination interval
-			total_power = [] #create to store wieghted origin timestep values to average
-			while current_origin_ts != next_stopping_ts do
-				next_origin_ts_int = Integer(current_origin_ts) + 1
-				# Calc next stopping point that will being you to the next origin or destination time step
-				next_origin_ts = [next_origin_ts_int, next_stopping_ts].min 
-				# Calc next step length
-				delta_to_next_origin_ts = next_origin_ts - current_origin_ts 
-				# Add the proportional origin timestep value to the total power variable
-				total_power.push(Float(timeseries_kw[current_origin_idx]) *  delta_to_next_origin_ts)
-				# Only move on to the next origin timestep if you are not ending mid way though an origin timestep
-				# i.e  in EX 2 above, the value 4 is needed in destination timestep 1 and 2 
-				if next_origin_ts_int <= next_stopping_ts
-					current_origin_idx += 1
-				end
-				# Step to the next stopping point
-				current_origin_ts += delta_to_next_origin_ts
-			end
-			# Add averaged total power variable for the destination time step
-			result.push(Float(total_power.sum) / stepping_interval)
-		end
-    end
-    if destination_res > original_res
-		#Timesteps will be expanded, i.e. 8760 -> 35040
+  if timeseries_kw.empty?
+    return nil
+  end
+
+  if original_res > destination_res
+    # Timesteps will be reduced, i.e. 35040 -> 8760
+
+    # This algorithm works by stepping along the origin timeseries at an interval equal to
+    # one timestep in the destintion timeseries and then averaging all origin values that
+    # coincide with the interval. Averages are weighted if a destination timestep
+    # only partaially overlaps an origin timestep.
+
+    # EX 1
+    # stepping interval 2
+    # origin stepping       | 1 | 2 | 2 | 4 |
+    # destination stepping  |  1.5  |   3   |
 
-		# This algorithm works by stepping along the destination timeseries. Steps are made to the next 
-		# destination or origin breakpoint, and at each step the propotional amount of the origin stepped
-		# is added to the destination. For example, in in EX 1 below 4 steps are made each with adding the full amount of
-		# the origin (1, 1, 2 and 2) since each in the destination overlaps perfectly with 2 origin
-		# timesteps. In EX 2, the origin overlaps with the first 2 destination timesteps but the third
-		# destination value much be compose of half the 1st origin timestep value and half the second
-		# (i.e  4, 4, (4 * 1/2) + (3 * 1/2), 3, and 3 are added to the destination). 
-    	
-    	# EX 1
-    	# stepping interval 2
-    	# origin stepping       |   1   |   2   |
-    	# destination stepping  | 1 | 1 | 2 | 2 |
+    # EX 2
+    # stepping interval 2.5
+    # origin stepping       | 1 | 1 | 4 | 2 | 2 |
+    # destination stepping  |   1.6   |  2.4    |
 
-    	# EX 2
-    	# stepping interval 2.5
-    	# origin stepping       |     4    |    3     |
-    	# destination stepping  | 4 | 4 | 3.5 | 3 | 3 |
-	
-		result = []
-		stepping_interval = (Float(destination_res) / Float(original_res))
-		current_destination_ts = 0 # fraction stepped along the origin time series
-		(0..(8760*original_res-1)).each do |original_ts|
-			# keep track of step length along the destination time series
-			original_indices_stepped = 0
-			# See if you are start in the middle of a destination time step and add the proportional
-			# value to the most recent (and incomplete) destination value
-			remainder = (current_destination_ts - Integer(current_destination_ts))
-			if remainder > 0
-				current_destination_ts += (1 - remainder)
-				original_indices_stepped += (1 - remainder)
-				result[-1] = result[-1] + (Float(timeseries_kw[original_ts])*(1-remainder))
-			end
-			# Make whole steps along the destination timeseries that overlap perfectly with the 
-			# origin timeseries
-			while (original_indices_stepped < stepping_interval) and ((original_indices_stepped + 1) <= stepping_interval)
-				result.push(Float(timeseries_kw[original_ts]))
-				original_indices_stepped += 1
-				current_destination_ts += 1
-			end
-			# See if you need to end your step in the middle of a destination time step and 
-			# just add the proportional value from the current origin timestep
-			remainder = (stepping_interval - original_indices_stepped)
-			if remainder > 0
-				result.push((Float(timeseries_kw[original_ts]) * remainder))
-				current_destination_ts += remainder
-			end
-		end
+    result = []
+    stepping_interval = Float(original_res) / Float(destination_res)
+    current_origin_ts = 0 # fraction stepped along the origin time series
+    current_origin_idx = 0 # current integer index of the origin timeseries
+    (0..(8760 * destination_res - 1)).each do |ts|
+      next_stopping_ts = current_origin_ts + stepping_interval # stop at the next destination interval
+      total_power = [] # create to store wieghted origin timestep values to average
+      while current_origin_ts != next_stopping_ts
+        next_origin_ts_int = Integer(current_origin_ts) + 1
+        # Calc next stopping point that will being you to the next origin or destination time step
+        next_origin_ts = [next_origin_ts_int, next_stopping_ts].min
+        # Calc next step length
+        delta_to_next_origin_ts = next_origin_ts - current_origin_ts
+        # Add the proportional origin timestep value to the total power variable
+        total_power.push(Float(timeseries_kw[current_origin_idx]) * delta_to_next_origin_ts)
+        # Only move on to the next origin timestep if you are not ending mid way though an origin timestep
+        # i.e  in EX 2 above, the value 4 is needed in destination timestep 1 and 2
+        if next_origin_ts_int <= next_stopping_ts
+          current_origin_idx += 1
+        end
+        # Step to the next stopping point
+        current_origin_ts += delta_to_next_origin_ts
+      end
+      # Add averaged total power variable for the destination time step
+      result.push(Float(total_power.sum) / stepping_interval)
     end
-    if destination_res == original_res
-    	#No resolution conversion necessary
-		result = timeseries_kw
+  end
+  if destination_res > original_res
+    # Timesteps will be expanded, i.e. 8760 -> 35040
+
+    # This algorithm works by stepping along the destination timeseries. Steps are made to the next
+    # destination or origin breakpoint, and at each step the propotional amount of the origin stepped
+    # is added to the destination. For example, in in EX 1 below 4 steps are made each with adding the full amount of
+    # the origin (1, 1, 2 and 2) since each in the destination overlaps perfectly with 2 origin
+    # timesteps. In EX 2, the origin overlaps with the first 2 destination timesteps but the third
+    # destination value much be compose of half the 1st origin timestep value and half the second
+    # (i.e  4, 4, (4 * 1/2) + (3 * 1/2), 3, and 3 are added to the destination).
+
+    # EX 1
+    # stepping interval 2
+    # origin stepping       |   1   |   2   |
+    # destination stepping  | 1 | 1 | 2 | 2 |
+
+    # EX 2
+    # stepping interval 2.5
+    # origin stepping       |     4    |    3     |
+    # destination stepping  | 4 | 4 | 3.5 | 3 | 3 |
+
+    result = []
+    stepping_interval = (Float(destination_res) / Float(original_res))
+    current_destination_ts = 0 # fraction stepped along the origin time series
+    (0..(8760 * original_res - 1)).each do |original_ts|
+      # keep track of step length along the destination time series
+      original_indices_stepped = 0
+      # See if you are start in the middle of a destination time step and add the proportional
+      # value to the most recent (and incomplete) destination value
+      remainder = (current_destination_ts - Integer(current_destination_ts))
+      if remainder > 0
+        current_destination_ts += (1 - remainder)
+        original_indices_stepped += (1 - remainder)
+        result[-1] = result[-1] + (Float(timeseries_kw[original_ts]) * (1 - remainder))
+      end
+      # Make whole steps along the destination timeseries that overlap perfectly with the
+      # origin timeseries
+      while (original_indices_stepped < stepping_interval) && ((original_indices_stepped + 1) <= stepping_interval)
+        result.push(Float(timeseries_kw[original_ts]))
+        original_indices_stepped += 1
+        current_destination_ts += 1
+      end
+      # See if you need to end your step in the middle of a destination time step and
+      # just add the proportional value from the current origin timestep
+      remainder = (stepping_interval - original_indices_stepped)
+      if remainder > 0
+        result.push((Float(timeseries_kw[original_ts]) * remainder))
+        current_destination_ts += remainder
+      end
     end
-    return result
-end
+  end
+  if destination_res == original_res
+    # No resolution conversion necessary
+    result = timeseries_kw
+  end
+  return result
+end