urbanopt-rnm-us 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bfd1fdcbaf0908d6ec884147fd9a26c78429181063cadb15fd5210e89bacd83e
-  data.tar.gz: d8ca20d16669801961c405b8609f6a8adf21bfc2c5862e604e74f90732cece6d
+  metadata.gz: f7601a8b6f72052bb8b84d726e2bf579d955b00a69fe4087400f89934ed68ea2
+  data.tar.gz: cd015470a41029e2c0b9c811467ac0609b6fea56beb1f885ba9c86ddd13c1e1d
 SHA512:
-  metadata.gz: 9364a3a2cd150e57ee2dff2e1f070065fdc83b35dc519361e9c076393e7f3ee9b290899fef8952b26eae42abc8872989fe5ad8a7ef00b7a1a35397273578a3c7
-  data.tar.gz: 0fcaf071315fac36a51abace8a64f3278d80c854fd6d85bbb7a63affa774cd0a09e7c4196e2aa0e71ee446d7e8f9cd8349e3c068b67d4ae7c235b82f03433a79
+  metadata.gz: b823b847e4774a055c7923388a349aa7552527fb2974d5b061fcf820ffa71a4e77dfb4c5b874f72d1223e3c4da9d5877d3a1b8353b5e08ae5a0aed925bdef55e
+  data.tar.gz: d62a00a1f4869153476975a00299d730d16dde5789f8ab114395846b2e466dc47dabb378821c1f008b2eddccede50af2f3bcd26e1e81afa5f677ba14fb6e5dcc

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 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/lib/urbanopt/rnm/consumers.rb

@@ -175,7 +175,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 +214,17 @@ 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"]
         # 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,107 @@ 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"]
         # 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

data/lib/urbanopt/rnm/version.rb

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

data/urbanopt-rnm-us-gem.gemspec

@@ -26,7 +26,7 @@ Gem::Specification.new do |spec|
   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 'urbanopt-geojson', '~> 0.6.6'
 
   spec.add_development_dependency 'bundler', '~> 2.1'
   spec.add_development_dependency 'rake', '~> 13.0'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: urbanopt-rnm-us
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Katherine Fleming
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-07-22 00:00:00.000000000 Z
+date: 2021-10-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -59,14 +59,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.6.5
+        version: 0.6.6
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.6.5
+        version: 0.6.6
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement