urbanopt-rnm-us 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 48d2e5b31538bcf737ce6e1d6d6c581dcfa8cddf779c6c2174590d9a9784a878
-  data.tar.gz: fc4973c31698c5461451c675e47d4ae837aef99e314684e37d35caea0da18e2f
+  metadata.gz: 07dfa016051b9b8499a11ba5d8066a73c06131d628af10adb2dfc8c9848e7c30
+  data.tar.gz: a6e9f7af3ee4e92951d9225caa5eddfb8f97b20b0e1a5d95898a3f4a132405e3
 SHA512:
-  metadata.gz: 800c18d91f1bb12ed9e46ca6a14a810d570fad5b4eb08e66e7dcca79507676545b53cb49db0f1046ec8b2dbdfeccc2d2c3eb3863b3f12699d79fd9bd1aa256a8
-  data.tar.gz: 865a614718260125d16e49fa459d90826b8b86519ec8e75dc1ebdee61b12de8e386a6763ae89599e3fa050f5666b0b3a8ac4636f2f224ffd0b868b2b9e9007fb
+  metadata.gz: b25a77720880cc85ed29adabb35280a8e308692004183ef7da0a70ae0f4dd4e56c18d5299697490e8ed98e62e8007465ec31f80279c505595df23b144cbf16e5
+  data.tar.gz: e6a40b39b6f1f20f96df5379bf02c73205e00981e60bdf25dccaadb8780dd24522e18dcf423f3497fa7c03f6dd180cdc54531bd150666f2a33612b3a2b40c883

data/.gitignore

@@ -29,4 +29,6 @@ runner.conf
 # ignore template files for now
 /template_inputs/*
 test_opendss_catalog.json
-*.sql
+*.sql
+
+*__pycache__

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## Version 0.5.0
+Date Range 9/30/22 - 12/8/22
+
+- Update dependencies for Extension Gem 0.6.0 and OpenStudio 3.5.0
+
 ## Version 0.4.0
 Date Range 05/10/22 - 9/30/22
 

data/Gemfile

@@ -9,8 +9,9 @@ allow_local = ENV['FAVOR_LOCAL_GEMS']
 # Below is an example of how to configure the gemfile for developing with local gems
 # modify as appropriate
 
-if allow_local && File.exists?('../urbanopt-geojson-gem')
-  gem 'urbanopt-geojson', path: '../urbanopt-geojson-gem'
-elsif allow_local
-	gem 'urbanopt-geojson', github: 'URBANopt/urbanopt-geojson-gem', branch: 'develop'
-end
+# if allow_local && File.exists?('../urbanopt-geojson-gem')
+#   gem 'urbanopt-geojson', path: '../urbanopt-geojson-gem'
+# elsif allow_local
+#	  gem 'urbanopt-geojson', github: 'URBANopt/urbanopt-geojson-gem', branch: 'develop'
+# end
+

data/README.md

@@ -47,7 +47,21 @@ bundle exec rake create_opendss_catalog[/desired/path/to/opendss_catalog.json]
 | API Version | RNM-US Gem Version | RNM-US exe Version |
 | ----------- | ----------- | ---------------- |
 | v1      | 0.3.0 and earlier | RNM-US_20220819 |
-| v2      | 0.4.0 | RNM-US_20220927 |
+| v2      | 0.4.0 | RNM-US_20221018 |
+
+
+## Validation Functionality
+
+The validation and results visualization functionality is written in python. Follow these steps if you would like to use it.
+
+1. Install python (3.10) if you do not already have it installed
+1. Clone the repo to your computer
+1. cd into the repo directory
+1. run `bundle install` to install the required ruby dependencies
+1. run `pip install -r requirements.txt` to install the required python dependencies for the validation module
+1. create input files and run the simulation as usual
+1. run `bundle exec rake run_validation[/path/to/scenario/csv]` to run the validation
+
 
 ## Testing
 

data/Rakefile

@@ -148,6 +148,29 @@ task :run_simulation, [:scenario_csv_path, :reopt, :use_localhost] do |t, args|
   puts '...done!'
 end
 
+# Full Runner workflow (mimics UO CLI functionality)
+# pass in the path to the scenario csv, geojson path, whether this is a reopt analysis (true/false), and whether to use localhost RNM API (true/false)
+desc 'Full Runner workflow'
+task :full_runner_workflow, [:scenario_csv_path, :geojson_path, :reopt, :use_localhost] do |t, args|
+  # todo: could allow passing in extended catalog, average peak catalog, and opendss_catalog flags too
+  # if no path passed in, use default:
+  scenario_csv = args[:scenario_csv_path] || 'spec/test/example_project/run/baseline_scenario'
+  geojson_path = args[:geojson_path] || 'spec/test/example_project/example_project_with_network_and_streets'
+  root_dir, scenario_file_name = File.split(File.expand_path(scenario_csv))
+  scenario_name = File.basename(scenario_file_name, File.extname(scenario_file_name))
+  run_dir = File.join(root_dir, 'run', scenario_name.downcase)
+  reopt = args[:reopt] || false
+  reopt = reopt == 'true'
+  use_local =  args[:use_localhost] || false
+
+  runner = URBANopt::RNM::Runner.new(scenario_name, run_dir, scenario_csv, geojson_path, reopt: reopt)
+  runner.create_simulation_files
+  runner.run(use_local)
+  runner.post_process
+
+  puts '...done!'
+end
+
 # Create opendss catalog from extended catalog
 # pass in the path and filename where the OpenDSS catalog should be saved
 desc 'Create OpenDSS catalog'
@@ -169,20 +192,22 @@ end
 # run validation
 # pass in the path to the scenario csv
 desc 'Run Validation'
-task :run_validation, [:scenario_csv_path, :reopt, :use_localhost] do |t, args|
+task :run_validation, [:scenario_csv_path, :use_numeric_ids] do |t, args|
   #Exammple to run validation
-  #bundle exec rake run_validation[D:/.../urbanopt-rnm-us-gem/spec/files/example_project/baseline_scenario.csv]
+  #bundle exec rake run_validation[D:/.../urbanopt-rnm-us-gem/spec/files/example_project/baseline_scenario.csv,true]
+  
   puts 'Running OpenDSS validation'
+  
   # if no path passed in, use default:
   scenario_csv = args[:scenario_csv_path] || 'spec/test/example_project/run/baseline_scenario'
   root_dir, scenario_file_name = File.split(File.expand_path(scenario_csv))
   scenario_name = File.basename(scenario_file_name, File.extname(scenario_file_name))
   run_dir = File.join(root_dir, 'run', scenario_name.downcase)
-
   rnm_dir = File.join(run_dir, 'rnm-us')
 
-  
-  
+  #Use numeric ids (for the hierarchical plot of the network)
+  use_numeric_ids = args[:use_numeric_ids] || false
+  use_numeric_ids = use_numeric_ids == 'true'  
   
   if !File.exist?(rnm_dir)
     puts rnm_dir
@@ -190,7 +215,7 @@ task :run_validation, [:scenario_csv_path, :reopt, :use_localhost] do |t, args|
   end
 
   puts "run dir path: #{run_dir}"
-  validation = URBANopt::RNM::Validation.new(rnm_dir)
+  validation = URBANopt::RNM::Validation.new(rnm_dir,use_numeric_ids)
   validation.run_validation()
 
   puts '...done!'

data/lib/urbanopt/rnm/api_client.rb

@@ -108,6 +108,7 @@ module URBANopt
         end
 
         if !missing_files.empty?
+          puts "RNM DIR: #{@rnm_dir}"
           raise "Input Files missing in directory: #{missing_files.join(',')}"
         end
 
@@ -281,6 +282,13 @@ module URBANopt
           # delete zip
           File.delete(file_path)
 
+          # check if zip is empty
+          if Dir.empty? File.join(@rnm_dir, 'results')
+            msg = "Error in simulation: Results.zip empty"
+            @@logger.error(msg)
+            raise msg
+          end
+
         else
           msg = "Error retrieving results for #{the_sim_id}. error code: #{resp.status}.  #{resp.body}"
           @@logger.error(msg)

data/lib/urbanopt/rnm/consumers.rb

@@ -45,7 +45,7 @@ require 'csv'
 module URBANopt
   module RNM
     class Consumers
-      attr_accessor :customers, :customers_ext, :profile_customer_p, :profile_customer_q, :profile_customer_p_ext, :profile_customer_q_ext, :power_factor
+      attr_accessor :customers, :customers_ext, :profile_customer_p, :profile_customer_q, :profile_customer_p_ext, :profile_customer_q_ext, :power_factor, :profile_date_time, :profile_date_time_ext
 
       # initializing all the attributes to build the inputs files required by the RNM-US model
       def initialize(reopt, only_lv_consumers = false, max_num_lv_nodes, average_building_peak_catalog_path, lv_limit)
@@ -55,8 +55,10 @@ module URBANopt
         @max_num_lv_nodes = max_num_lv_nodes
         @customers = []
         @customers_ext = []
+        @profile_date_time = []
         @profile_customer_p = []
         @profile_customer_q = []
+        @profile_date_time_ext = []
         @profile_customer_p_ext = []
         @profile_customer_q_ext = []
         @power_factor = power_factor
@@ -73,8 +75,10 @@ module URBANopt
       # while the 2nd option is run in case "only LV" set to false and the consumption for each building will be placed in a single node
       def construct_consumer(profiles, single_values, building_map, building_nodes, height, users, folder)
         if @only_lv_consumers
+          planning_date_time = []
           planning_profile_node_active = []
           planning_profile_node_reactive = []
+          yearly_date_time = []
           yearly_profile_node_active = []
           yearly_profile_node_reactive = []
           nodes_per_bldg, area, medium_voltage = av_peak_cons_per_building_type(folder['building_types'])
@@ -106,19 +110,23 @@ module URBANopt
             else
               voltage_default, phases = voltage_values(peak_active_power_cons / @power_factor)
             end
-
+            
             for k in 0..profiles[:planning_profile_cust_active].length - 1
+              planning_date_time[k]=profiles[:planning_date_time][k]
               planning_profile_node_active[k] = ((profiles[:planning_profile_cust_active][k]) / nodes_per_bldg).round(2)
               planning_profile_node_reactive[k] = ((profiles[:planning_profile_cust_reactive][k]) / nodes_per_bldg).round(2)
             end
             for k in 0..profiles[:yearly_profile_cust_active].length - 1
+              yearly_date_time[k]=profiles[:yearly_date_time][k]
               yearly_profile_node_active[k] = ((profiles[:yearly_profile_cust_active][k]) / nodes_per_bldg).round(2)
               yearly_profile_node_reactive[k] = ((profiles[:yearly_profile_cust_reactive][k]) / nodes_per_bldg).round(2)
             end
             @customers.push([coordinates, voltage_default, peak_active_power_cons, peak_reactive_power_cons, phases])
             @customers_ext.push([coordinates, voltage_default, peak_active_power_cons, peak_reactive_power_cons, phases, area, height, (single_values[:energy] / nodes_per_bldg).round(2), peak_active_power_cons, peak_reactive_power_cons, users])
+            @profile_date_time.push([planning_date_time])
             @profile_customer_q.push([id, 24, planning_profile_node_reactive])
             @profile_customer_p.push([id, 24, planning_profile_node_active])
+            @profile_date_time_ext.push([yearly_date_time])
             @profile_customer_p_ext.push([id, 8760, yearly_profile_node_active])
             @profile_customer_q_ext.push([id, 8760, yearly_profile_node_reactive])
 
@@ -131,8 +139,10 @@ module URBANopt
           voltage_default, phases = voltage_values(single_values[:peak_active_power_cons] / @power_factor * 0.9) # applying safety factor
           @customers.push([building_map, voltage_default, single_values[:peak_active_power_cons], single_values[:peak_reactive_power_cons], phases])
           @customers_ext.push([building_map, voltage_default, single_values[:peak_active_power_cons], single_values[:peak_reactive_power_cons], phases, area, height, (single_values[:energy]).round(2), single_values[:peak_active_power_cons], single_values[:peak_reactive_power_cons], users])
+          @profile_date_time.push([profiles[:planning_date_time]])
           @profile_customer_q.push([id, 24, profiles[:planning_profile_cust_reactive]])
           @profile_customer_p.push([id, 24, profiles[:planning_profile_cust_active]])
+          @profile_date_time_ext.push([profiles[:yearly_date_time]])
           @profile_customer_p_ext.push([id, 8760, profiles[:yearly_profile_cust_active]])
           @profile_customer_q_ext.push([id, 8760, profiles[:yearly_profile_cust_reactive]])
         end
@@ -234,10 +244,12 @@ module URBANopt
         # content = CSV.foreach(csv_feature_report, headers: true) do |power|
         CSV.foreach(csv_feature_report, headers: true) do |power|
           @power_factor = power['Electricity:Facility Power(kW)'].to_f / power['Electricity:Facility Apparent Power(kVA)'].to_f
+          profiles[:yearly_date_time].push(power['Datetime'])
           profiles[:yearly_profile_cust_active].push(power['Electricity:Facility Power(kW)'].to_f)
           profiles[:yearly_profile_cust_reactive].push(profiles[:yearly_profile_cust_active][k] * Math.tan(Math.acos(@power_factor)))
           single_values[:energy] += power['REopt:Electricity:Load:Total(kw)'].to_f # calculating the yearly energy consumed by each feature
           if k >= profile_start_max && k <= profile_start_max + hours
+            profiles[:planning_date_time].push(power['Datetime'])
             profiles[:planning_profile_cust_active].push(power['Electricity:Facility Power(kW)'].to_f)
             if power['Electricity:Facility Power(kW)'].to_f > single_values[:peak_active_power_cons]
               single_values[:peak_active_power_cons] = power['Electricity:Facility Power(kW)'].to_f

data/lib/urbanopt/rnm/input_files.rb

@@ -258,6 +258,10 @@ module URBANopt
           File.open(File.join(@run_dir, @rnm_dirname, 'customers_ext.txt'), 'w+') do |g|
             g.puts(prosumers.customers_ext.map { |w| w.join(';') })
           end
+          File.open(File.join(@run_dir, @rnm_dirname, 'timestamps.csv'), 'w+') do |g|
+            g.puts("Datetime\n")
+            g.puts(prosumers.profile_date_time[0].map { |w| w.join("\n") })
+          end
           File.open(File.join(@run_dir, @rnm_dirname, 'cust_profile_p.txt'), 'w+') do |g|
             g.puts(prosumers.profile_customer_p.map { |w| w.join(';') })
           end
@@ -267,6 +271,10 @@ module URBANopt
           # CSV.open(File.join(@run_dir, @rnm_dirname, "cust_profile_q_extendido.csv"), "w") do |csv|
           #             csv << [prosumers.profile_customer_q_ext]
           #         end
+          File.open(File.join(@run_dir, @rnm_dirname, 'timestamps_extendido.csv'), 'w+') do |g|
+            g.puts("Datetime\n")
+            g.puts(prosumers.profile_date_time_ext[0].map { |w| w.join("\n") })
+          end
           File.open(File.join(@run_dir, @rnm_dirname, 'cust_profile_q_extendido.txt'), 'w+') do |g|
             g.puts(prosumers.profile_customer_q_ext.map { |w| w.join(';') })
           end
@@ -289,6 +297,7 @@ module URBANopt
           File.open(File.join(@run_dir, @rnm_dirname, 'gen_profile_p_extendido.txt'), 'w+') do |g|
             g.puts(prosumers.profile_dg_p_extended.map { |w| w.join(';') })
           end
+          ficheros_entrada_inc.push('Timestamps;timestamps.csv;timestamps_extendido.csv')
           ficheros_entrada_inc.push('CClienteGreenfield;customers_ext.txt;cust_profile_p.txt;cust_profile_q.txt;cust_profile_p_extendido.txt;cust_profile_q_extendido.txt')
           ficheros_entrada_inc.push('CGeneradorGreenfield;generators.txt;gen_profile_p.txt;gen_profile_q.txt;gen_profile_p_extendido.txt;gen_profile_q_extendido.txt')
           ficheros_entrada_inc.push('END')
@@ -302,18 +311,27 @@ module URBANopt
           File.open(File.join(@run_dir, @rnm_dirname, 'customers_ext.txt'), 'w+') do |g|
             g.puts(consumers.customers_ext.map { |w| w.join(';') })
           end
+          File.open(File.join(@run_dir, @rnm_dirname, 'timestamps.csv'), 'w+') do |g|
+            g.puts("Datetime\n")
+            g.puts(consumers.profile_date_time[0].map { |w| w.join("\n") })
+          end
           File.open(File.join(@run_dir, @rnm_dirname, 'cust_profile_p.txt'), 'w+') do |g|
             g.puts(consumers.profile_customer_p.map { |w| w.join(';') })
           end
           File.open(File.join(@run_dir, @rnm_dirname, 'cust_profile_q.txt'), 'w+') do |g|
             g.puts(consumers.profile_customer_q.map { |w| w.join(';') })
           end
+          File.open(File.join(@run_dir, @rnm_dirname, 'timestamps_extendido.csv'), 'w+') do |g|
+            g.puts("Datetime\n")
+            g.puts(consumers.profile_date_time_ext[0].map { |w| w.join("\n") })
+          end
           File.open(File.join(@run_dir, @rnm_dirname, 'cust_profile_q_extendido.txt'), 'w+') do |g|
             g.puts(consumers.profile_customer_q_ext.map { |w| w.join(';') })
           end
           File.open(File.join(@run_dir, @rnm_dirname, 'cust_profile_p_extendido.txt'), 'w+') do |g|
             g.puts(consumers.profile_customer_p_ext.map { |w| w.join(';') })
           end
+          ficheros_entrada_inc.push('Timestamps;timestamps.csv;timestamps_extendido.csv')
           ficheros_entrada_inc.push('CClienteGreenfield;customers_ext.txt;cust_profile_p.txt;cust_profile_q.txt;cust_profile_p_extendido.txt;cust_profile_q_extendido.txt')
           ficheros_entrada_inc.push('END')
           File.open(File.join(@run_dir, @rnm_dirname, 'ficheros_entrada_inc.txt'), 'w+') do |g|

data/lib/urbanopt/rnm/prosumers.rb

@@ -45,7 +45,7 @@ module URBANopt
     # creating a class that creates the consumers input required by the RNM-US model,
     # according to their geographic location, energy consumption and peak demand, and power consumption profiles
     class Prosumers
-      attr_accessor :customers, :customers_ext, :profile_customer_p, :profile_customer_q, :profile_customer_p_ext, :profile_customer_q_ext, :dg, :dg_profile_p, :dg_profile_q, :profile_dg_p_extended, :profile_dg_q_extended, :power_factor
+      attr_accessor :customers, :customers_ext, :profile_customer_p, :profile_customer_q, :profile_customer_p_ext, :profile_customer_q_ext, :dg, :dg_profile_p, :dg_profile_q, :profile_dg_p_extended, :profile_dg_q_extended, :power_factor, :profile_date_time, :profile_date_time_ext
 
       # initializing all the attributes to build the inputs files required by the RNM-US model
       def initialize(reopt, only_lv_consumers = false, max_num_lv_nodes, average_building_peak_catalog_path, lv_limit)
@@ -55,8 +55,10 @@ module URBANopt
         @max_num_lv_nodes = max_num_lv_nodes
         @customers = []
         @customers_ext = []
+        @profile_date_time = []
         @profile_customer_p = []
         @profile_customer_q = []
+        @profile_date_time_ext = []
         @profile_customer_p_ext = []
         @profile_customer_q_ext = []
         @dg = []
@@ -99,16 +101,20 @@ module URBANopt
         end
         @customers.push([building_map, id, voltage_default, single_values[:peak_active_power_cons], single_values[:peak_reactive_power_cons], phases])
         @customers_ext.push([building_map, id, voltage_default, single_values[:peak_active_power_cons], single_values[:peak_reactive_power_cons], phases, area, height, (single_values[:energy]).round(2), single_values[:peak_active_power_cons], single_values[:peak_reactive_power_cons], users])
+        @profile_date_time.push([profiles_planning[:planning_date_time]])
         @profile_customer_q.push([id, 48, profiles_planning[:planning_profile_cust_reactive]])
         @profile_customer_p.push([id, 48, profiles_planning[:planning_profile_cust_active]])
+        @profile_date_time_ext.push([profiles[:yearly_date_time]])
         @profile_customer_p_ext.push([id, 8760, profiles[:yearly_profile_cust_active]])
         @profile_customer_q_ext.push([id, 8760, profiles[:yearly_profile_cust_reactive]])
 
         if !der_capacity[:storage].nil? && der_capacity[:storage] > 0
           @customers.push([building_map, id_batt, voltage_default, single_values[:peak_active_power_storage], single_values[:peak_reactive_power_storage], phases])
           @customers_ext.push([building_map, id_batt, voltage_default, single_values[:peak_active_power_storage], single_values[:peak_reactive_power_storage], phases, area, height, (single_values[:energy]).round(2), single_values[:peak_active_power_storage], single_values[:peak_reactive_power_storage], users])
+          @profile_date_time.push([profiles_planning[:planning_date_time]])
           @profile_customer_q.push([id_batt, 48, profiles_planning[:planning_profile_storage_reactive]])
           @profile_customer_p.push([id_batt, 48, profiles_planning[:planning_profile_storage_active]])
+          @profile_date_time_ext.push([profiles[:yearly_date_time]])
           @profile_customer_p_ext.push([id_batt, 8760, profiles[:yearly_profile_storage_active]])
           @profile_customer_q_ext.push([id_batt, 8760, profiles[:yearly_profile_storage_reactive]])
         end
@@ -129,8 +135,10 @@ module URBANopt
       # among the nodes of each building
       def construct_prosumer_lv(nodes_per_bldg = 0, profiles, profiles_planning, single_values, building_map, building_nodes, area, height, users, der_capacity)
         # the default variables are defined (i.e. type and rurality type)
+        planning_date_time = []
         planning_profile_node_active = []
         planning_profile_node_reactive = []
+        yearly_date_time = []
         yearly_profile_node_active = []
         yearly_profile_node_reactive = []
         closest_node = building_map[3].split('_')[1].to_i # refers to the closest node of the building in consideration to the street
@@ -159,17 +167,21 @@ module URBANopt
             peak_reactive_power_cons = (single_values[:peak_reactive_power_cons] / nodes_consumers).round(2)
             voltage_default, phases = voltage_values(peak_active_power_cons / @power_factor)
             for k in 0..profiles_planning[:planning_profile_cust_active].length - 1
+              planning_date_time[k]=profiles_planning[:planning_date_time][k]
               planning_profile_node_active[k] = (profiles_planning[:planning_profile_cust_active][k] / nodes_consumers).round(2)
               planning_profile_node_reactive[k] = (profiles_planning[:planning_profile_cust_reactive][k] / nodes_consumers).round(2)
             end
             for k in 0..profiles[:yearly_profile_cust_active].length - 1
+              yearly_date_time[k]=profiles[:yearly_date_time][k]
               yearly_profile_node_active[k] = (profiles[:yearly_profile_cust_active][k] / nodes_consumers).round(2)
               yearly_profile_node_reactive[k] = (profiles[:yearly_profile_cust_reactive][k] / nodes_consumers).round(2)
             end
             @customers.push([coordinates, id, voltage_default, peak_active_power_cons, peak_reactive_power_cons, phases])
             @customers_ext.push([coordinates, id, voltage_default, peak_active_power_cons, peak_reactive_power_cons, phases, area, height, (single_values[:energy] / nodes_consumers).round(2), peak_active_power_cons, peak_reactive_power_cons, users])
+            @profile_date_time.push([planning_date_time])
             @profile_customer_q.push([id, 48, planning_profile_node_reactive])
             @profile_customer_p.push([id, 48, planning_profile_node_active])
+            @profile_date_time_ext.push([yearly_date_time])
             @profile_customer_p_ext.push([id, 8760, yearly_profile_node_active])
             @profile_customer_q_ext.push([id, 8760, yearly_profile_node_reactive])
           else
@@ -186,8 +198,10 @@ module URBANopt
             if !der_capacity[:storage].nil? && der_capacity[:storage] > 0
               @customers.push([coordinates, id_batt, voltage_default, single_values[:peak_active_power_storage], single_values[:peak_reactive_power_storage], phases])
               @customers_ext.push([coordinates, id_batt, voltage_default, single_values[:peak_active_power_storage], single_values[:peak_reactive_power_storage], phases, area, height, (single_values[:energy]).round(2), single_values[:peak_active_power_storage], single_values[:peak_reactive_power_storage], users])
+              @profile_date_time.push([profiles[:planning_date_time]])
               @profile_customer_q.push([id_batt, 48, profiles_planning[:planning_profile_storage_reactive]])
               @profile_customer_p.push([id_batt, 48, profiles_planning[:planning_profile_storage_active]])
+              @profile_date_time_ext.push([profiles[:yearly_date_time]])
               @profile_customer_p_ext.push([id_batt, 8760, profiles[:yearly_profile_storage_active]])
               @profile_customer_q_ext.push([id_batt, 8760, profiles[:yearly_profile_storage_reactive]])
             end
@@ -285,6 +299,7 @@ module URBANopt
 
       # method to order profiles consistently
       def profiles_planning_creation(profiles_planning, power, single_values, i, hours, power_factor)
+        profiles_planning[:planning_date_time][i]=power['Datetime']
         profiles_planning[:planning_profile_cust_active][i] = power['REopt:Electricity:Load:Total(kw)'].to_f
         profiles_planning[:planning_profile_storage_active][i] = power['REopt:Electricity:Grid:ToBattery(kw)'].to_f + power['REopt:ElectricityProduced:Generator:ToBattery(kw)'].to_f + power['REopt:ElectricityProduced:PV:ToBattery(kw)'].to_f + power['REopt:ElectricityProduced:Wind:ToBattery(kw)'].to_f - power['REopt:Electricity:Storage:ToLoad(kw)'].to_f - power['REopt:Electricity:Storage:ToGrid(kw)'].to_f
         profiles_planning[:planning_profile_dg_active][i] = power['REopt:ElectricityProduced:Total(kw)'].to_f
@@ -341,6 +356,7 @@ module URBANopt
         max_peak = 0
         CSV.foreach(csv_feature_report, headers: true) do |power|
           @power_factor = power['Electricity:Facility Power(kW)'].to_f / power['Electricity:Facility Apparent Power(kVA)'].to_f
+          profiles[:yearly_date_time].push(power['Datetime'])
           profiles[:yearly_profile_cust_active].push(power['REopt:Electricity:Load:Total(kw)'].to_f)
           profiles[:yearly_profile_cust_reactive].push(profiles[:yearly_profile_cust_active][k] * Math.tan(Math.acos(@power_factor)))
           profiles[:yearly_profile_dg_active].push(power['REopt:ElectricityProduced:Total(kw)'].to_f)

data/lib/urbanopt/rnm/validation/main_validation.py

@@ -7,45 +7,147 @@ import math
 import networkx as nx
 import opendss_interface
 import plot_lib
+import report
+import os
+
 
 class Validation:
-    def __init__(self, folder):
-        self.folder = folder
-        
+    def __init__(self, folder,sb_numeric_ids):
+        """Initialices the folder variables"""
+        self.main_folder = folder        #Main uppper level folder (needed to search for OpenDSS files)     
+        self.folder=folder+'/Validation' #Folder where the Validation results are saved
+        self.b_numeric_ids=sb_numeric_ids.lower()=='true' #Use numeric IDs in the hierarchical plot of the network
+        self.mkdir(self.folder)          #It creates the validation folder if it does not exist
+
+    def mkdir(self,directory):
+        """Checkes whether the folder exists, if not it creates it"""
+        if (not os.path.exists(directory)):
+            os.mkdir(directory)
+
+    def make_dirs(self):
+        """Creates all the subfolder, it they don't exist"""
+        path=self.folder+'/'        
+        self.mkdir(path+'Voltage')
+        self.mkdir(path+'Voltage/CSV')
+        self.mkdir(path+'Voltage/Figures')
+        self.mkdir(path+'Unbalance')
+        self.mkdir(path+'Unbalance/CSV')
+        self.mkdir(path+'Unbalance/Figures')
+        self.mkdir(path+'Loading')
+        self.mkdir(path+'Loading/CSV')
+        self.mkdir(path+'Loading/Figures')
+        self.mkdir(path+'Losses')
+        self.mkdir(path+'Losses/CSV')
+        self.mkdir(path+'Losses/Figures')
+        self.mkdir(path+'Loads')
+        self.mkdir(path+'Loads/Figures')
+        self.mkdir(path+'Equipment')
+        self.mkdir(path+'Equipment/Figures')
+        self.mkdir(path+'Network')
+        self.mkdir(path+'Network/Figures')
+        self.mkdir(path+'Summary')
+    
+    def define_ranges(self):
+        """Defines the allowed ranges (to determine violations), the limits (to plot the lines in the plots), and the display ranges (for the axis in the figures)"""
+        #Voltages
+        v_range_voltage={}
+        v_range_voltage['allowed_range']=(0.95, 1.05)
+        v_range_voltage['limits']=[0.95, 1.05]
+        v_range_voltage['display_range']=(0.85, 1.15)
+        #Lodaing
+        v_range_loading={}
+        v_range_loading['allowed_range']=(0, 1)
+        v_range_loading['limits']=[1]
+        v_range_loading['display_range']=(0, 1.3)
+        #Unbalance
+        v_range_unbalance={}
+        v_range_unbalance['allowed_range']=(0,0.02)
+        v_range_unbalance['limits']=[0.02]
+        v_range_unbalance['display_range']=(0,0.021)
+        #Show all variables option
+        v_range_show_all={}
+        v_range_show_all['allowed_range']=()
+        v_range_show_all['limits']=[]
+        v_range_show_all['display_range']=()        
+
+        return v_range_voltage,v_range_loading,v_range_unbalance,v_range_show_all
+
+
     def main_validation(self):
-        master_file_full_path = folder + '/dss_files/' + 'Master.dss'
-        start_index = 0
-        num_periods=12
-        end_index = 8760
-        v_range_voltage=(0.9, 1.1)
-        v_limits_voltage=[0.95,1.05]
-        v_range_loading=(0,1.3)
-        v_limits_loading=[1]
-        v_range_show_all=(0,0)
+        """Carries out the whole validation of the distribution system"""
+        #Path and file name
+        master_file_full_path = self.main_folder + '/dss_files/' + 'Master.dss' #Path for the Master file        
+        #Number of periods (always 12 months)
+        num_periods=12   
+        #Start and end index
+        #Define only to simulate only a subset of hours
+        #Set to None to use all timestamps 
+        start_index = None  #Default initial index (0/None)
+        end_index = None    #Default final index, 1 year, 8760h (8760/None)
 
-        #For tests
-        #end_index = 24
-        #v_range_voltage=(0.975, 1.025)
+        #Create sub-folders
+        self.make_dirs()
+        #Define the ranges of voltage, loading, unbalance and a default range to show all the values
+        v_range_voltage,v_range_loading,v_range_unbalance,v_range_show_all=self.define_ranges()
 
-        myopendss_io=opendss_interface.OpenDSS_Interface(folder)
-        v_dict_voltage,v_voltage_yearly,v_voltage_period,v_power_yearly,v_power_period,v_dict_loading,v_loading_yearly,v_loading_period,v_dict_losses,v_subs_losses_yearly,v_line_losses_yearly,dict_buses_element=myopendss_io.solve_powerflow_iteratively(num_periods,start_index,end_index,master_file_full_path,v_range_voltage,v_range_loading)
-        myopendss_io.write_dict(v_dict_voltage,v_range_show_all,'Voltages (p.u.)','Buses')
-        myopendss_io.write_dict(v_dict_voltage,v_range_voltage,'Voltage Violations (p.u.)','Buses')
-        myopendss_io.write_dict(v_dict_loading,v_range_show_all,'Loading (p.u.)','Branches')
-        myopendss_io.write_dict(v_dict_loading,v_range_loading,'Loading Violations (p.u.)','Branches')
-        myopendss_io.write_dict(v_dict_losses,v_range_show_all,'Losses','Branches')        
-        edges=myopendss_io.get_edges()
-        myplot_lib=plot_lib.Plot_Lib(folder)
-        myplot_lib.plot_hist('Voltage',v_voltage_yearly,v_voltage_period,v_range_voltage,40,num_periods,v_limits_voltage)
-        myplot_lib.plot_hist('Loading',v_loading_yearly,v_loading_period,v_range_loading,80,num_periods,v_limits_loading)
-        myplot_lib.plot_losses(v_subs_losses_yearly,v_line_losses_yearly)    
-        myplot_lib.plot_graph(edges,v_dict_voltage,v_range_voltage,v_dict_loading,v_range_loading,dict_buses_element)
+        #For tests
+        #start_index = 2000  #Default initial index 
+        #end_index = 4000    #Simulate few hours (still broken down in 12 periods/months)
+        #v_range_voltage['allowed_range']=(0.975, 1.025)    #More stringent limmits than the standard ones to show violations
+        #v_range_loading['allowed_range']=(0,0.3)
+        #v_range_unbalance['allowed_range']=(0, 4e-5)
+        #v_range_unbalance['allowed_range']=(0, 2.1e-5)
 
+        #Run power flow iteratively and obtain the results
+        myopendss_io=opendss_interface.OpenDSS_Interface(folder,self.b_numeric_ids)
+        v_dict_buses_ids,v_dict_ids_buses,v_dict_voltage,v_voltage_yearly,v_voltage_period,v_power_yearly,v_power_period,v_dict_loading,v_loading_yearly,v_loading_period,v_dict_losses,v_subs_losses_yearly,v_line_losses_yearly,dict_buses_element,v_dict_loads,v_loads_kw_yearly,v_loads_kw_period,v_loads_kvar_yearly,v_loads_kvar_period,v_total_load_kw_yearly,v_total_load_kvar_yearly, v_loads_kw, v_loads_kvar, v_dict_unbalance,v_unbalance_yearly,v_unbalance_period,dict_lines,v_lines_norm_amps,dict_transformers,v_transformers_kva,timestamps,v_months,v_hours=myopendss_io.solve_powerflow_iteratively(num_periods,start_index,end_index,master_file_full_path,v_range_voltage,v_range_loading,v_range_unbalance)
 
+        #Save voltage, unbalance, loading and losses results in CSV files
+        myopendss_io.write_dict('Voltage/CSV',v_dict_voltage,v_range_show_all,'Voltages (p.u.)','Buses',v_dict_buses_ids,timestamps,v_hours)
+        myopendss_io.write_dict('Voltage/CSV',v_dict_voltage,v_range_voltage,'Voltage Violations (p.u.)','Buses',v_dict_buses_ids,timestamps,v_hours)
+        myopendss_io.write_dict('Unbalance/CSV',v_dict_unbalance,v_range_show_all,'Unbalance (p.u.)','Buses',v_dict_buses_ids,timestamps,v_hours)
+        myopendss_io.write_dict('Unbalance/CSV',v_dict_unbalance,v_range_unbalance,'Unbalance Violations (p.u.)','Buses',v_dict_buses_ids,timestamps,v_hours)
+        myopendss_io.write_dict('Loading/CSV',v_dict_loading,v_range_show_all,'Loading (p.u.)','Branches',None,timestamps,v_hours)
+        myopendss_io.write_dict('Loading/CSV',v_dict_loading,v_range_loading,'Loading Violations (p.u.)','Branches',None,timestamps,v_hours)
+        myopendss_io.write_dict('losses/CSV',v_dict_losses,v_range_show_all,'Losses','Branches',None,timestamps,v_hours)        
+        if self.b_numeric_ids:
+            myopendss_io.write_id_dict('Network/Figures','IDs_Buses',v_dict_buses_ids)
+        #Get the edges of the network (for later making a hierarchical representation of the network)
+        closed_edges,open_edges=myopendss_io.get_edges(v_dict_buses_ids)
+        #Plot all the figures
+        myplot_lib=plot_lib.Plot_Lib(folder,self.b_numeric_ids)
+        #Voltage
+        myplot_lib.plot_hist('Voltage','Voltage (p.u.)',v_voltage_yearly,v_voltage_period,v_range_voltage,num_periods,40,v_months)
+        myplot_lib.plot_violin_monthly('Voltage/Figures','Voltage (p.u.)',v_voltage_yearly,v_voltage_period,v_range_voltage,num_periods,v_months)
+        #Unbalance
+        myplot_lib.plot_hist('Unbalance','Unbalance (p.u.)',v_unbalance_yearly,v_unbalance_period,v_range_unbalance,num_periods,40,v_months)
+        myplot_lib.plot_violin_monthly('Unbalance/Figures','Unbalance (p.u.)',v_unbalance_yearly,v_unbalance_period,v_range_unbalance,num_periods,v_months)
+        #Loading
+        myplot_lib.plot_hist('Loading','Loading (p.u.)',v_loading_yearly,v_loading_period,v_range_loading,num_periods,80,v_months)
+        myplot_lib.plot_violin_monthly('Loading/Figures','Loading (p.u.)',v_loading_yearly,v_loading_period,v_range_loading,num_periods,v_months)
+        #Loads and load shpaes
+        myplot_lib.plot_duration_curve('Loads/Figures',v_total_load_kw_yearly,v_total_load_kvar_yearly,False,v_hours)    
+        myplot_lib.plot_violin_monthly_two_vars('Loads/Figures','Loads',v_loads_kw_yearly,v_loads_kw_period,v_loads_kvar_yearly,v_loads_kvar_period,v_range_show_all,num_periods,v_months)
+        myplot_lib.plot_violin('Loads/Figures','Loads Peak (kW)',v_loads_kw,v_range_show_all)
+        #Losses
+        myplot_lib.plot_duration_curve('Losses/Figures',v_subs_losses_yearly,v_line_losses_yearly,True,v_hours)    
+        #Equipment parameters
+        myplot_lib.plot_violin('Equipment/Figures','Power Line - Normal Amps (A)',v_lines_norm_amps,v_range_show_all)
+        myplot_lib.plot_violin('Equipment/Figures','Transformer (kVA)',v_transformers_kva,v_range_show_all)
+        #Summary operational report
+        myreport=report.Report(folder,self.b_numeric_ids)
+        myreport.write_summary_operational_report('Summary',v_dict_voltage,v_range_voltage,v_dict_unbalance,v_range_unbalance,v_dict_loading,v_range_loading,v_dict_loads)
+        #Hierarchical representation of the network
+        myplot_lib.plot_graph('Network/Figures',closed_edges,open_edges,v_dict_voltage,v_range_voltage,v_dict_loading,v_range_loading,dict_buses_element,v_dict_buses_ids,v_dict_ids_buses)
+        
 
+#def main_validation(folder): #Example: uncomment to make the script run from a function
+    #folder = './files/'
 if __name__ == "__main__":
-    #Example to run it in command window
-    #python main_validation.py files
-    folder = sys.argv[1]
-    valid=Validation(folder)
-    valid.main_validation()
+    """Runs direclty as a script if called from the command window"""
+    #Example of use: python main_validation.py files
+    folder = sys.argv[1]        #Use the folder specified in the arguments
+    sb_numeric_ids = sys.argv[2] #Use numeric IDs in the hierarchical plot of the network
+    valid=Validation(folder,sb_numeric_ids)    
+    valid.main_validation()     #Call the main validation function
+