urbanopt-rnm-us 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bfd1fdcbaf0908d6ec884147fd9a26c78429181063cadb15fd5210e89bacd83e
-  data.tar.gz: d8ca20d16669801961c405b8609f6a8adf21bfc2c5862e604e74f90732cece6d
+  metadata.gz: 977f93affe9c5d526cd2cb0af1232f443e07693a78d45da7827563f9f804c30e
+  data.tar.gz: 03e3f2642b6ddc140b36d9385e0a77790e1308a1f5bd1b96647775d03f4e4830
 SHA512:
-  metadata.gz: 9364a3a2cd150e57ee2dff2e1f070065fdc83b35dc519361e9c076393e7f3ee9b290899fef8952b26eae42abc8872989fe5ad8a7ef00b7a1a35397273578a3c7
-  data.tar.gz: 0fcaf071315fac36a51abace8a64f3278d80c854fd6d85bbb7a63affa774cd0a09e7c4196e2aa0e71ee446d7e8f9cd8349e3c068b67d4ae7c235b82f03433a79
+  metadata.gz: e86574dc52de1655eace0ba423350343257cb234a2e110a2670fd80163fe07fc2f6b7ab7cf56decb02260bcf307b8620ddde128bb9c157ceeb6a94f59487dd16
+  data.tar.gz: 8e7bba90ab83607932f8eecc5bda1487d86c5da2864a32d92fd88d3ae20d4aa18f8567244042dc66a9e640304aa65a0ec44f9090f6a2472124aa191be27db523

data/CHANGELOG.md

@@ -1,5 +1,33 @@
 # Changelog
 
+## Version 0.2.0
+
+Date Range 11/09/21 - 11/22/21
+
+- Updated dependencies for OpenStudio 3.3
+
+## Version 0.1.3
+
+Date Range 11/02/21 - 11/08/21
+
+- Fix [#11](https://github.com/urbanopt/urbanopt-rnm-us-gem/issues/11), results files are not downloading in project directory for large projects
+
+- Fix [#16](https://github.com/urbanopt/urbanopt-rnm-us-gem/issues/16), fix residential enums to be consistent across files and fix typo in multifamily
+
+## Version 0.1.2
+
+Date Range 10/29/21 - 11/01/21
+
+- Fix [#13](https://github.com/urbanopt/urbanopt-rnm-us-gem/issues/13), update rubyzip dependency to fix conflict
+
+## Version 0.1.1
+
+Date Range 07/22/21 - 10/28/21
+
+- Fixed [#10]( https://github.com/urbanopt/urbanopt-rnm-us-gem/issues/7 ), Fix peak profile generation for prosumer profiles
+- Fixed [#8]( https://github.com/urbanopt/urbanopt-rnm-us-gem/issues/8 ), Use timestep_per_hour defined in UO feature report for the interval reporting
+- Fixed [#10]( https://github.com/urbanopt/urbanopt-rnm-us-gem/issues/10 ), Add other residential types to prosumer/consumer calculations
+
 ## Version 0.1.0
 
 Initial version of the RNM-US gem.

data/Jenkinsfile

@@ -0,0 +1,10 @@
+//Jenkins pipelines are stored in shared libaries. Please see: https://github.com/tijcolem/nrel_cbci_jenkins_libs 
+ 
+@Library('cbci_shared_libs') _
+
+// Build for PR to develop branch only. 
+if ((env.CHANGE_ID) && (env.CHANGE_TARGET) ) { // check if set
+
+  urbanopt_rnm_us()
+    
+}

data/lib/urbanopt/rnm/api_client.rb

@@ -177,52 +177,70 @@ module URBANopt
         # prepare results directory
         prepare_results_dir
 
-        max_tries = 10
+        max_tries = 20
         tries = 0
         puts "attempting to retrieve results for simulation #{@sim_id}"
         while !done && (max_tries != tries)
-          resp = conn.get("simulations/#{@sim_id}")
-          if resp.status == 200
-            data = JSON.parse(resp.body)
-            if data['status'] && ['failed', 'completed'].include?(data['status'])
-              # done
-              done = true
-              if data['status'] == 'failed'
-                if data['results'] && data['results']['message']
-                  puts "Simulation Error: #{data['results']['message']}"
+          begin
+            resp = conn.get("simulations/#{@sim_id}")
+            if resp.status == 200
+              data = JSON.parse(resp.body)
+              if data['status'] && ['failed', 'completed'].include?(data['status'])
+                # done
+                done = true
+                if data['status'] == 'failed'
+                  if data['results'] && data['results']['message']
+                    puts "Simulation Error: #{data['results']['message']}"
+                  else
+                    puts 'Simulation Error!'
+                  end
                 else
-                  puts 'Simulation Error!'
+                  # edge case, check for results
+                  if data['results'].nil?
+                    puts "got a 200 but results are null...trying again"
+                    tries += 1
+                    sleep(3)
+                  else
+                    # get results
+                    @results = data['results'] || []
+
+                    puts "downloading results"
+                    # download results
+                    download_results
+                    return @results
+                  end
                 end
               else
-                # get results
-                @results = data['results'] || []
-
-                # download results
-                download_results
-
-                return @results
+                puts "no status yet...trying again"
+                tries += 1
+                sleep(3)
               end
+
             else
+              puts("ERROR retrieving: #{resp.body}")
               tries += 1
-              sleep(1)
-            end
 
-          else
-            puts("ERROR retrieving: #{resp.body}")
-            tries += 1
-
-            if tries == max_tries
-              # now raise the error
-              msg = "Error retrieving simulation #{@sim_id}. error code: #{resp.status}"
-              @@logger.error(msg)
-              raise msg
-            else
-              # try again
-              puts("TRYING AGAIN...#{tries}")
-              sleep(3)
+              if tries == max_tries
+                # now raise the error
+                msg = "Error retrieving simulation #{@sim_id}. error code: #{resp.status}"
+                @@logger.error(msg)
+                raise msg
+              else
+                # try again
+                puts("TRYING AGAIN...#{tries}")
+                sleep(3)
+              end
             end
+          rescue => error
+            @@logger.error("Error retrieving simulation #{@sim_id}.")
+            @@logger.error(error.message)
+            raise error.message
           end
         end
+        if !done
+          @@logger.error("Error retrieving simulation #{@sim_id}.")
+          raise 'Simulation not retrieved...maximum tries reached'
+        end
       end
 
       ##
@@ -243,14 +261,14 @@ module URBANopt
             streamed << chunk
           end
         end
-        # puts("STATUS: #{resp.status}, #{resp.body}")
 
         if resp.status == 200
 
           file_path = File.join(@rnm_dir, 'results', 'results.zip')
 
           File.open(file_path, 'wb') { |f| f.write streamed.join }
-          # puts "RNM-US results.zip downloaded to #{@rnm_dir}"
+          puts "RNM-US results.zip downloaded to #{@rnm_dir}"
+          
           # unzip
           Zip::File.open(file_path) do |zip_file|
             zip_file.each do |f|
@@ -259,7 +277,7 @@ module URBANopt
               zip_file.extract(f, f_path) unless File.exist?(f_path)
             end
           end
-
+          puts "results.zip extracted"
           # delete zip
           File.delete(file_path)
 

data/lib/urbanopt/rnm/consumers.rb

@@ -79,6 +79,7 @@ module URBANopt
           yearly_profile_node_reactive = []
           nodes_per_bldg, area, medium_voltage = av_peak_cons_per_building_type(folder['building_types'])
           # the default variables are defined (i.e. type and rurality type)
+          puts "consumers 82"
           closest_node = building_map[3].split('_')[1].to_i # refers to the node, found in the class above
           node = closest_node
           cont = 1
@@ -175,7 +176,7 @@ module URBANopt
         conservative_factor = 0.8 # considered as a reasonable assumption, but this value could be changed
         average_peak_folder = JSON.parse(File.read(@average_building_peak_catalog_path))
         for i in 0..feature_file.length - 1
-          area = (feature_file[i]['floor_area']).round(2)
+          area = feature_file[i].has_key?('floor_area') ? (feature_file[i]['floor_area']).round(2) : feature_file[i]['floor_area_sqft'].round(2)
           building_type = feature_file[i]['building_type'] # it specifies the type of building, sometimes it is directly the sub-type
           counter = 0 # counter to find number of buildings type belonging to same "category"
           average_peak_folder.each do |building_class|
@@ -214,16 +215,18 @@ module URBANopt
       # the method passes as arguments the urbanopt json and csv output file for each feature and the building coordinates previously calculated
       # and the "extreme" hour used to plan the network
       def customer_files_load(csv_feature_report, json_feature_report, building_map, building_nodes, hour)
+        n_timestep_per_hour = json_feature_report["timesteps_per_hour"].to_i
         profiles = Hash.new { |h, k| h[k] = [] }
         single_values = Hash.new(0)
-        hours = 23
+        hours = 24 * n_timestep_per_hour -1
         feature_type = json_feature_report['program']['building_types'][0]['building_type']
-        residential_building_types = 'Single-Family Detached' # add the other types
+        residential_building_types = ['Single-Family Detached', 'Single-Family Attached', 'Multifamily', 'Single-Family', 'Multifamily Detached (2 to 4 units)', 'Multifamily Detached (5 or more units)']
+
         # finding the index where to start computing and saving the info, from the value of the "worst-case hour" for the max peak consumption of the district
         if residential_building_types.include? feature_type
-          profile_start_max = hour.hour_index_max_res - hour.peak_hour_max_res
+          profile_start_max = hour.hour_index_max_res - ((hour.peak_hour_max_res.split(':')[0].to_i + (hour.peak_hour_max_res.split(':')[1].to_i / 60)) * n_timestep_per_hour)
         else
-          profile_start_max = hour.hour_index_max_comm - hour.peak_hour_max_comm
+          profile_start_max = hour.hour_index_max_comm - ((hour.peak_hour_max_comm.split(':')[0].to_i + (hour.peak_hour_max_comm.split(':')[1].to_i / 60)) * n_timestep_per_hour)
         end
         k = 0 # index for each hour of the year represented in the csv file
         i = 0 # to represent the 24 hours of a day

data/lib/urbanopt/rnm/prosumers.rb

@@ -74,7 +74,7 @@ module URBANopt
 
       # method defined for the case of a single node where both battery, DG and consumers are placed
       # evaluation of the peak power in each node to define the type of connection (e.g. voltage level and n phases)
-      def construct_prosumer_general(profiles, single_values, building_map, area, height, users, der_capacity)
+      def construct_prosumer_general(profiles, profiles_planning, single_values, building_map, area, height, users, der_capacity)
         id = building_map[3]
         id_dg = "#{building_map[3]}_DG"
         id_batt = "#{building_map[3]}_battery"
@@ -84,8 +84,8 @@ module URBANopt
         # in the hour with generation max peak
         # in the hour with storage max peak
 
-        for i in 0..profiles[:planning_profile_cust_active].length - 1
-          hourly_app_power = ((profiles[:planning_profile_cust_active][i] + profiles[:planning_profile_storage_active][i] - profiles[:planning_profile_dg_active][i]) / @power_factor).abs
+        for i in 0..profiles_planning[:planning_profile_cust_active].length-1
+          hourly_app_power = ((profiles_planning[:planning_profile_cust_active][i] + profiles_planning[:planning_profile_storage_active][i] - profiles_planning[:planning_profile_dg_active][i])/@power_factor).abs
           if hourly_app_power > peak_app_power_node
             peak_app_power_node = hourly_app_power
           end
@@ -99,22 +99,22 @@ 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_customer_q.push([id, 48, profiles[:planning_profile_cust_reactive]])
-        @profile_customer_p.push([id, 48, profiles[:planning_profile_cust_active]])
+        @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_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])
+        
+        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_customer_q.push([id_batt, 48, profiles[:planning_profile_storage_reactive]])
-          @profile_customer_p.push([id_batt, 48, profiles[:planning_profile_storage_active]])
+          @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_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
         @dg.push([building_map, id_dg, voltage_default, der_capacity[:dg], single_values[:peak_active_power_dg].round(2), single_values[:peak_reactive_power_dg].round(2), phases])
-        @dg_profile_p.push([id_dg, 48, profiles[:planning_profile_dg_active]])
-        @dg_profile_q.push([id_dg, 48, profiles[:planning_profile_dg_reactive]])
+        @dg_profile_p.push([id_dg, 48, profiles_planning[:planning_profile_dg_active]])
+        @dg_profile_q.push([id_dg, 48, profiles_planning[:planning_profile_dg_reactive]])
         @profile_dg_p_extended.push([id_dg, 8760, profiles[:yearly_profile_dg_active]])
         @profile_dg_q_extended.push([id_dg, 8760, profiles[:yearly_profile_dg_reactive]])
       end
@@ -127,7 +127,7 @@ module URBANopt
       # this method is called only if the user sets the option of "only LV nodes" to true
       # defining a certain numb of nodes for each building and distributing the peak power values equally
       # among the nodes of each building
-      def construct_prosumer_lv(nodes_per_bldg = 0, profiles, single_values, building_map, building_nodes, area, height, users, der_capacity)
+      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_profile_node_active = []
         planning_profile_node_reactive = []
@@ -138,6 +138,7 @@ module URBANopt
         cont = 1
         cont_reverse = 1
         nodes_consumers = nodes_per_bldg - 1
+        
         for i in 1..nodes_per_bldg
           coordinates = building_map
           node = closest_node + cont # to set the new nodes with enough distance among each others
@@ -145,10 +146,10 @@ module URBANopt
           if i > 1 && node <= building_nodes.length - 2
             coordinates = building_nodes[node] # take the closest building node index to the street and pass the nodes after it
             cont += 1
-          elsif i > 1
+          elsif i > 1 
             coordinates = building_nodes[node_reverse]
             cont_reverse += 1
-          end
+          end 
           # this condition is used to firstly place the building consumption nodes and then the last node
           # to be placed is the one referred to DG and battery for the building
           if i < nodes_per_bldg # considering the consumers nodes
@@ -157,12 +158,12 @@ module URBANopt
             peak_active_power_cons = (single_values[:peak_active_power_cons] / nodes_consumers).round(2)
             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_profile_cust_active].length - 1
-              planning_profile_node_active[k] = (profiles[:planning_profile_cust_active][k] / nodes_consumers).round(2)
-              planning_profile_node_reactive[k] = (profiles[:planning_profile_cust_reactive][k] / nodes_consumers).round(2)
+            for k in 0..profiles_planning[:planning_profile_cust_active].length - 1
+                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_profile_node_active[k] = (profiles[:yearly_profile_cust_active][k] / nodes_consumers).round(2)
+              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])
@@ -173,20 +174,20 @@ module URBANopt
             @profile_customer_q_ext.push([id, 8760, yearly_profile_node_reactive])
           else
             # considering the DG and battery
-            voltage_default, phases = voltage_values(der_capacity[:dg]) # assuming that the pv capacity is always higher than battery capacity
+            voltage_default, phases = voltage_values(der_capacity[:dg]) #assuming that the pv capacity is always higher than battery capacity
             id_dg = "#{coordinates[3]}_DG"
             id_batt = "#{coordinates[3]}_battery"
             coordinates.pop
             @dg.push([coordinates, id_dg, voltage_default, der_capacity[:dg], single_values[:peak_active_power_dg].round(2), single_values[:peak_reactive_power_dg].round(2), phases])
-            @dg_profile_p.push([id_dg, 48, profiles[:planning_profile_dg_active]])
-            @dg_profile_q.push([id_dg, 48, profiles[:planning_profile_dg_reactive]])
+            @dg_profile_p.push([id_dg, 48, profiles_planning[:planning_profile_dg_active]])
+            @dg_profile_q.push([id_dg, 48, profiles_planning[:planning_profile_dg_reactive]])
             @profile_dg_p_extended.push([id_dg, 8760, profiles[:yearly_profile_dg_active]])
             @profile_dg_q_extended.push([id_dg, 8760, profiles[:yearly_profile_dg_reactive]])
-            if !der_capacity[:storage].nil? && der_capacity[:storage] > 0
+            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_customer_q.push([id_batt, 48, profiles[:planning_profile_storage_reactive]])
-              @profile_customer_p.push([id_batt, 48, profiles[:planning_profile_storage_active]])
+              @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_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
@@ -247,16 +248,16 @@ module URBANopt
         conservative_factor = 0.8 # considered as a reasonable assumption, but this value could be changed
         average_peak_folder = JSON.parse(File.read(@average_building_peak_catalog_path))
         for i in 0..feature_file.length - 1
-          area = (feature_file[i]['floor_area']).round(2)
-          building_type = feature_file[i]['building_type'] # it specifies the type of building, sometimes it is directly the sub-type
+          area = feature_file[i].key?('floor_area') ? (feature_file[i]['floor_area']).round(2) : (feature_file[i]['floor_area_sqft']).round(2)
+          building_type = feature_file[i]['building_type'] #it specifies the type of building, sometimes it is directly the sub-type
           counter = 0 # counter to find number of buildings type belonging to same "category"
           average_peak_folder.each do |building_class|
-            if building_type == building_class['building type'] || building_type == building_class['sub-type']
+            if (building_type == building_class["building type"] ||  building_type == building_class["sub-type"])
               average_peak = (building_class['average peak demand (kW/ft2)'].to_f * area).to_f.round(4) # finding the average peak considering the floor area of the bilding under consideration
               average_peak_by_size[counter] = average_peak
               floor_area[counter] = (building_class['floor_area (ft2)'] - area).abs # minimum difference among area and area from the prototypes defined by DOE
               counter += 1
-              # in this way I don t consider residential and I assume it s average_peak = 0, it is ok because we assume always 1 node per RES consumers, single-detached family houses
+            # in this way I don t consider residential and I assume it s average_peak = 0, it is ok because we assume always 1 node per RES consumers, single-detached family houses
             end
           end
           if counter > 1
@@ -272,100 +273,108 @@ module URBANopt
           average_peak = mixed_use_av_peak # average peak per mixed use considering the building types which are in this building
           area = area_mixed_use
         end
-        nodes_per_bldg = (average_peak / (@lv_limit[:three_phase] * @power_factor * conservative_factor)).to_f.ceil # computing number of nodes per building
-        if nodes_per_bldg > @max_num_lv_nodes # defined as reasonable maximum
+        nodes_per_bldg = ((average_peak / (@lv_limit[:three_phase] * @power_factor * conservative_factor)).to_f).ceil # computing number of nodes per building
+        if nodes_per_bldg > @max_num_lv_nodes #that it is equal to how it was before
           nodes_per_bldg = 1
           @medium_voltage = true
         end
-
-        nodes_per_bldg += 1 # tacking into account the extra node for distributed generation and the battery
-
+  
+          nodes_per_bldg += 1 # tacking into account the extra node for distributed generation and the battery    
         return nodes_per_bldg, area
       end
 
+      # method to order profiles consistently
+      def profiles_planning_creation(profiles_planning, power, single_values, i, hours, power_factor)
+        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
+        profiles_planning[:planning_profile_cust_reactive][i] = profiles_planning[:planning_profile_cust_active][i] * Math.tan(Math.acos(power_factor))
+        profiles_planning[:planning_profile_storage_reactive][i] = profiles_planning[:planning_profile_storage_active][i] * Math.tan(Math.acos(power_factor))
+        profiles_planning[:planning_profile_dg_reactive][i] = profiles_planning[:planning_profile_dg_active][i] * Math.tan(Math.acos(power_factor))
+        if profiles_planning[:planning_profile_cust_active][i] > single_values[:peak_active_power_cons]
+          single_values[:peak_active_power_cons] = profiles_planning[:planning_profile_cust_active][i]
+          single_values[:peak_reactive_power_cons] = single_values[:peak_active_power_cons] * Math.tan(Math.acos(power_factor))
+        end
+        if profiles_planning[:planning_profile_storage_active][i] > single_values[:peak_active_power_storage]
+          single_values[:peak_active_power_storage] = profiles_planning[:planning_profile_storage_active][i]
+          single_values[:peak_reactive_power_storage] = single_values[:peak_active_power_storage] * Math.tan(Math.acos(power_factor))
+        end
+        if profiles_planning[:planning_profile_dg_active][i] > single_values[:peak_active_power_dg]
+          single_values[:peak_active_power_dg] = profiles_planning[:planning_profile_dg_active][i]
+          single_values[:peak_reactive_power_dg] = single_values[:peak_active_power_dg] * (Math.tan(Math.acos(power_factor)))
+        end
+        return profiles_planning, single_values
+      end
+
       # defining a method for the customers and generators files creation:
       # obtaining all the needed input from each feature_report.csv file (active & apparent power and tot energy consumed and produced)
       # and from each feature_report.json file (area, height, number of users, DG capacity)
       # the method passes as arguments the urbanopt json and csv output file for each feature and the building coordinates previously calculated
       # and the "extreme" hours used to plan the network
       def prosumer_files_load(csv_feature_report, json_feature_report, building_map, building_nodes, hour)
-        profiles = Hash.new { |h, k| h[k] = [] }
+        # add variable to include how many timestep per hour, so the profiles become 48 * n_timestep_per_hour
+        n_timestep_per_hour = json_feature_report["timesteps_per_hour"].to_i
+        profiles_planning = Hash.new{|h, k| h[k] = Array.new(48*n_timestep_per_hour, 0)} # initializing each profile hash to 0 for the number of intervals considered for the planning of the network
+              profiles = Hash.new{|h, k| h[k] = []}
         single_values = Hash.new(0)
         @medium_voltage = false
-        hours = 23
-        feature_type = json_feature_report['program']['building_types'][0]['building_type']
-        residential_building_types = 'Single-Family Detached' # add the other types
+        hours = 24 * n_timestep_per_hour -1 # change name, maybe to intervals
+        feature_type = json_feature_report['program']['building_types'][0]["building_type"]
+        residential_building_types = ['Single-Family Detached', 'Single-Family Attached', 'Multifamily', 'Single-Family', 'Multifamily Detached (2 to 4 units)', 'Multifamily Detached (5 or more units)']
+
         # finding the index where to start computing and saving the info, from the value of the "worst-case hour" for the max peak consumption of the district
+        # considering num timestep per hours and the fact that each day starts from 1 am
         if residential_building_types.include? feature_type
-          profile_start_max = hour.hour_index_max_res - hour.peak_hour_max_res
-          profile_start_min = hour.hour_index_min_res - hour.peak_hour_min_res
+          profile_start_max = hour.hour_index_max_res - ((hour.peak_hour_max_res.split(':')[0].to_i + (hour.peak_hour_max_res.split(':')[1].to_i / 60)) * n_timestep_per_hour)
+          profile_start_min = hour.hour_index_min_res - ((hour.peak_hour_min_res.split(':')[0].to_i + (hour.peak_hour_min_res.split(':')[1].to_i / 60)) * n_timestep_per_hour)
         else
-          profile_start_max = hour.hour_index_max_comm - hour.peak_hour_max_comm
-          profile_start_min = hour.hour_index_min_comm - hour.peak_hour_min_comm
+          profile_start_max = hour.hour_index_max_comm - ((hour.peak_hour_max_comm.split(':')[0].to_i + (hour.peak_hour_max_comm.split(':')[1].to_i / 60)) * n_timestep_per_hour)
+          profile_start_min = hour.hour_index_min_comm - ((hour.peak_hour_min_comm.split(':')[0].to_i + (hour.peak_hour_min_comm.split(':')[1].to_i / 60)) * n_timestep_per_hour)
         end
         # finding the index where to start computing and saving the info, from the value of the "most extreme hours" for the max peak consumption of the district
-        # profile_start_max = hour.hour_index_max - hour.peak_hour_max
-        # profile_start_min = hour.hour_index_min - hour.peak_hour_min
-        k = 0 # index for each hour of the year represented in the csv file
-        i = 0 # to represent the 24 hours
+        k = 0   # index for each hour of the year represented in the csv file
+        i = hours +1 # to represent the 24 hours in case of max_net_generation day
+        j = 0 # to represent the 24 hours in case of peak_demand_day
         h_cons_batt = 0
         h_dg_max = 0 # hour with max DG generation
         h_stor_max = 0 # hour with max storage absorption
         max_peak = 0
-        # 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_profile_cust_active].push(power['REopt:Electricity:Load:Total(kw)'].to_f)
+          @power_factor = power["Electricity:Facility Power(kW)"].to_f / power["Electricity:Facility Apparent Power(kVA)"].to_f
+          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)
+          profiles[:yearly_profile_dg_active].push(power["REopt:ElectricityProduced:Total(kw)"].to_f)
           profiles[:yearly_profile_dg_reactive].push(profiles[:yearly_profile_dg_active][k] * Math.tan(Math.acos(@power_factor)))
           profiles[:yearly_profile_storage_active].push(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[:yearly_profile_storage_reactive].push(profiles[:yearly_profile_storage_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
-          single_values[:energy_dg] += power['REopt:ElectricityProduced:Total(kw)'].to_f
+          single_values[:energy] += power["REopt:Electricity:Load:Total(kw)"].to_f # calculating the yearly energy consumed by each feature
+          single_values[:energy_dg] += power["REopt:ElectricityProduced:Total(kw)"].to_f
           single_values[:energy_storage] += 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
-          if k >= profile_start_max && k <= profile_start_max + hours || k >= profile_start_min && k <= profile_start_min + hours
-            profiles[:planning_profile_cust_active].push(power['REopt:Electricity:Load:Total(kw)'].to_f)
-            if profiles[:planning_profile_cust_active][i] > single_values[:peak_active_power_cons]
-              single_values[:peak_active_power_cons] = profiles[:planning_profile_cust_active][i]
-              single_values[:peak_reactive_power_cons] = single_values[:peak_active_power_cons] * Math.tan(Math.acos(power_factor))
-              single_values[:h_cons_max] = i
-            end
-            profiles[:planning_profile_storage_active].push((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))
-            if profiles[:planning_profile_storage_active][i] > single_values[:peak_active_power_storage]
-              single_values[:peak_active_power_storage] = profiles[:planning_profile_storage_active][i]
-              single_values[:peak_reactive_power_storage] = single_values[:peak_active_power_storage] * Math.tan(Math.acos(power_factor))
-              single_values[:h_stor_max] = i
-            end
-            profiles[:planning_profile_dg_active].push(power['REopt:ElectricityProduced:Total(kw)'].to_f)
-            if profiles[:planning_profile_dg_active][i] > single_values[:peak_active_power_dg]
-              single_values[:peak_active_power_dg] = profiles[:planning_profile_dg_active][i]
-              single_values[:peak_reactive_power_dg] = single_values[:peak_active_power_dg] * Math.tan(Math.acos(power_factor))
-              single_values[:h_dg_max] = i
-            end
-            profiles[:planning_profile_cust_reactive].push(profiles[:planning_profile_cust_active][i] * Math.tan(Math.acos(power_factor)))
-            profiles[:planning_profile_storage_reactive].push(profiles[:planning_profile_storage_active][i] * Math.tan(Math.acos(power_factor)))
-            profiles[:planning_profile_dg_reactive].push(profiles[:planning_profile_dg_active][i] * Math.tan(Math.acos(power_factor)))
-            i += 1
+          case k
+          when profile_start_min..profile_start_min + (hours)
+            profiles_planning, single_values = self.profiles_planning_creation(profiles_planning, power, single_values, i, hours, power_factor)
+              i+=1
+          when profile_start_max..profile_start_max + (hours)
+            profiles_planning, single_values = self.profiles_planning_creation(profiles_planning, power, single_values, j, hours, power_factor)
+            j+=1
           end
-          k += 1
+          k+=1
         end
         height = (json_feature_report['program']['maximum_roof_height_ft']).round(2)
         users = json_feature_report['program']['number_of_residential_units']
-        der_capacity = sum_dg(json_feature_report['distributed_generation'])
+        der_capacity = self.sum_dg(json_feature_report['distributed_generation'])
         if @only_lv_consumers
-          nodes_per_bldg, area = av_peak_cons_per_building_type(json_feature_report['program']['building_types'])
-          if @max_num_lv_nodes == 1
-            construct_prosumer_general(profiles, single_values, building_map, area, height, users, der_capacity)
+          nodes_per_bldg, area = self.av_peak_cons_per_building_type(json_feature_report['program']['building_types'])
+          if @max_num_nodes == 1
+            self.construct_prosumer_general(profiles, profiles_planning, single_values, building_map, area, height, users, der_capacity)
           else
-            construct_prosumer_lv(nodes_per_bldg, profiles, single_values, building_map, building_nodes, area, height, users, der_capacity)
+            self.construct_prosumer_lv(nodes_per_bldg, profiles, profiles_planning, single_values, building_map, building_nodes, area, height, users, der_capacity)
           end
         else
-          # this key seems to change between floor_area or floor_area_ft
-          area = json_feature_report['program'].key?('floor_area') ? (json_feature_report['program']['floor_area']).round(2) : (json_feature_report['program']['floor_area_sqft']).round(2)
+          area = json_feature_report['program'].has_key?('floor_area') ? (json_feature_report['program']['floor_area']).round(2) : (json_feature_report['program']['floor_area_sqft']).round(2)
           # associating 2 nodes (consumers & DG and battery in the same node) per building considering the consumer, the battery and DG
-          construct_prosumer_general(profiles, single_values, building_map, area, height, users, der_capacity)
-        end
+          self.construct_prosumer_general(profiles, profiles_planning, single_values, building_map, area, height, users, der_capacity)
+        end 
       end
     end
   end

data/lib/urbanopt/rnm/scenario_report.rb

@@ -73,23 +73,23 @@ module URBANopt
           (0..@commercial_consumption.length - 1).each do |j|
             if @commercial_consumption[j] > max_net_load_comm
               max_net_load_comm = @commercial_consumption[j]
-              @peak_hour_max_comm = (@time[j].split(' ')[1]).split(':')[0].to_i # defined the most-stressing scenario
+              @peak_hour_max_comm = (@time[j].split(' ')[1]) # defined the most-stressing scenario
               @hour_index_max_comm = j
             end
             if @commercial_consumption[j] < min_net_load_comm
               min_net_load_comm = @commercial_consumption[j]
-              @peak_hour_min_comm = (@time[j].split(' ')[1]).split(':')[0].to_i # defined the most-stressing scenario
+              @peak_hour_min_comm = (@time[j].split(' ')[1]) # defined the most-stressing scenario
               @hour_index_min_comm = j
             end
 
             if @res_consumption[j] > max_net_load_res
               max_net_load_res = @res_consumption[j]
-              @peak_hour_max_res = (@time[j].split(' ')[1]).split(':')[0].to_i # defined the most-stressing scenario
+              @peak_hour_max_res = (@time[j].split(' ')[1]) # defined the most-stressing scenario
               @hour_index_max_res = j
             end
             if @res_consumption[j] < min_net_load_res
               min_net_load_res = @res_consumption[j]
-              @peak_hour_min_res = (@time[j].split(' ')[1]).split(':')[0].to_i # defined the most-stressing scenario
+              @peak_hour_min_res = (@time[j].split(' ')[1]) # defined the most-stressing scenario
               @hour_index_min_res = j
             end
           end
@@ -98,12 +98,12 @@ module URBANopt
           (0..@commercial_consumption.length - 1).each do |j|
             if @commercial_consumption[j] > max_net_load_comm
               max_net_load_comm = @commercial_consumption[j]
-              @peak_hour_max_comm = (@time[j].split(' ')[1]).split(':')[0].to_i # defined the most-stressing scenario
+              @peak_hour_max_comm = (@time[j].split(' ')[1]) # defined the most-stressing scenario
               @hour_index_max_comm = j
             end
             if @res_consumption[j] > max_net_load_res
               max_net_load_res = @res_consumption[j]
-              @peak_hour_max_res = (@time[j].split(' ')[1]).split(':')[0].to_i # defined the most-stressing scenario
+              @peak_hour_max_res = (@time[j].split(' ')[1]) # defined the most-stressing scenario
               @hour_index_max_res = j
             end
           end
@@ -112,7 +112,7 @@ module URBANopt
       def aggregate_consumption(file_csv, file_json, n_feature)
         feature_type = file_json['program']['building_types'][0]['building_type']
         # residential_building_types = "Single-Family Detached" #add the other types
-        residential_building_types = ['Single-Family Detached', 'Single-Family Attached', 'MultiFamily', 'Single-Family', 'Multifamily Detached (2 to 4 units)', 'Multifamily Detached (5 or more units)'] # add the other types
+        residential_building_types = ['Single-Family Detached', 'Single-Family Attached', 'Multifamily', 'Single-Family', 'Multifamily Detached (2 to 4 units)', 'Multifamily Detached (5 or more units)'] # add the other types
         puts feature_type
         j = 0
         CSV.foreach(file_csv, headers: true) do |power|

data/lib/urbanopt/rnm/version.rb

@@ -40,6 +40,6 @@
 
 module URBANopt
   module RNM
-    VERSION = '0.1.0'.freeze
+    VERSION = '0.2.0'.freeze
   end
 end

data/urbanopt-rnm-us-gem.gemspec

@@ -23,10 +23,11 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib', 'catalogs']
   spec.required_ruby_version = '~> 2.7.0'
 
-  spec.add_dependency 'faraday', '1.0.1'
-  spec.add_dependency 'geoutm', '~>1.0.2'
-  spec.add_dependency 'rubyzip', '2.3.0'
-  spec.add_dependency 'urbanopt-geojson', '~> 0.6.5'
+  spec.add_dependency 'certified', '~> 1'
+  spec.add_dependency 'faraday', '~> 1.0.1'
+  spec.add_dependency 'geoutm', '~> 1.0.2'
+  spec.add_dependency 'rubyzip', '~> 2.3.2'
+  spec.add_dependency 'urbanopt-geojson', '~> 0.7.0'
 
   spec.add_development_dependency 'bundler', '~> 2.1'
   spec.add_development_dependency 'rake', '~> 13.0'

metadata

@@ -1,28 +1,42 @@
 --- !ruby/object:Gem::Specification
 name: urbanopt-rnm-us
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Katherine Fleming
 - Luca de Rosa
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-07-22 00:00:00.000000000 Z
+date: 2021-12-07 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: certified
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
 - !ruby/object:Gem::Dependency
   name: faraday
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 1.0.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 1.0.1
 - !ruby/object:Gem::Dependency
@@ -43,30 +57,30 @@ dependencies:
   name: rubyzip
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.3.0
+        version: 2.3.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.3.0
+        version: 2.3.2
 - !ruby/object:Gem::Dependency
   name: urbanopt-geojson
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.6.5
+        version: 0.7.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.6.5
+        version: 0.7.0
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -164,6 +178,7 @@ files:
 - CHANGELOG.md
 - CONTRIBUTING.md
 - Gemfile
+- Jenkinsfile
 - LICENSE.md
 - README.md
 - Rakefile
@@ -195,7 +210,7 @@ files:
 homepage: https://github.com/urbanopt/urbanopt-RNM-us-gem
 licenses: []
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -212,7 +227,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.1.4
-signing_key: 
+signing_key:
 specification_version: 4
 summary: Library to create input files for RNM-US
 test_files: []