urbanopt-rnm-us 0.1.0

data/lib/urbanopt/rnm/carson_eq.rb

@@ -0,0 +1,389 @@
+# *********************************************************************************
+# URBANopt (tm), Copyright (c) 2019-2021, Alliance for Sustainable Energy, LLC, and other
+# contributors. All rights reserved.
+
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+
+# Redistributions of source code must retain the above copyright notice, this list
+# of conditions and the following disclaimer.
+
+# Redistributions in binary form must reproduce the above copyright notice, this
+# list of conditions and the following disclaimer in the documentation and/or other
+# materials provided with the distribution.
+
+# Neither the name of the copyright holder nor the names of its contributors may be
+# used to endorse or promote products derived from this software without specific
+# prior written permission.
+
+# Redistribution of this software, without modification, must refer to the software
+# by the same designation. Redistribution of a modified version of this software
+# (i) may not refer to the modified version by the same designation, or by any
+# confusingly similar designation, and (ii) must refer to the underlying software
+# originally provided by Alliance as "URBANopt". Except to comply with the foregoing,
+# the term "URBANopt", or any confusingly similar designation may not be used to
+# refer to any modified version of this software or any modified version of the
+# underlying software originally provided by Alliance without the prior written
+# consent of Alliance.
+
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+# IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+# INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+# LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+# OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+# OF THE POSSIBILITY OF SUCH DAMAGE.
+# *********************************************************************************
+
+require 'urbanopt/rnm/logger'
+require 'json'
+require 'csv'
+require 'set'
+require 'matrix'
+
+module URBANopt
+  module RNM
+    # creating a class which is able to convert the line-geometry information for each power line and the
+    # conductors information, into power lines information, obtaining their impedances and capacitance
+    # applying carsons equations
+    class CarsonEq
+      def initialize(hash)
+        @power_line = hash
+      end
+
+      # method to place the new parameters created in the right position in the final RNM-US catalog
+      def insert_field(key, fields, proximity = :before)
+        @power_line = @power_line.to_a.insert(@power_line.keys.index(key) + (proximity == :after ? 1 : 0), fields.first).to_h
+      end
+
+      # method to convert initial SI units in the ext catalog into Imperial units used by the Carson equation
+      # create the one from ft to m
+      def si_to_imperial_units(quantity, unit_input, unit_output)
+        if unit_output == 'ft' && unit_input == 'mm'
+          return quantity * 0.003281
+        elsif unit_output == 'ft' && unit_input == 'm'
+          quantity / 0.3048
+          return quantity / 0.3048
+        elsif unit_output == 'mi' && unit_input == 'km'
+          return quantity / 1.6093
+        elsif unit_output == '1/mi' && unit_input == '1/km'
+          return quantity * 1.6093
+        elsif unit_output == '1/ft' && unit_input == '1/m'
+          return quantity * 0.3048
+        end
+      end
+
+      # method to convert the results in Imperial units into SI units used by the RNM-US model
+      # create the one from ft to m
+      def imperial_to_si_units(quantity, unit_input, unit_output)
+        if unit_output == 'ft'
+          return quantity * 0.3048
+        elsif unit_output == 'mi' && unit_input == 'km'
+          return quantity * 1.60934
+        elsif unit_output == '1/km' && unit_input == '1/mi'
+          return (quantity / 1.60934)
+        end
+      end
+
+      def get_sequence_impedance_matrix(phase_impedance_matrix)
+        a = Complex(Math.cos(Math::PI * 2 / 3), Math.sin(Math::PI * 2 / 3))
+        a_matrix = Matrix[[1, 1, 1], [1, a**2, a], [1, a, a**2]]
+        a_matrix_inv = a_matrix.inverse
+        half = phase_impedance_matrix * a_matrix
+        final_matrix = a_matrix_inv * half
+        return final_matrix
+      end
+
+      # method which applies the kron reduction to reduce the primitive impedance matrix by one dimension
+      def kron_reduction(primitive_impedance_matrix, n_concentric_neutrals)
+        if n_concentric_neutrals == 0
+          neutrals = primitive_impedance_matrix.length - 1 # position of the neutral in primitive_imp_matrix
+          dim_neutrals = primitive_impedance_matrix.length - neutrals
+        else
+          neutrals = primitive_impedance_matrix.length - n_concentric_neutrals # position of the neutral in primitive_imp_matrix
+          dim_neutrals = n_concentric_neutrals
+        end
+        dim_phase = primitive_impedance_matrix.length - dim_neutrals
+        zij = Array.new(dim_phase) { Array.new(dim_phase) }
+        for i in 0..dim_phase - 1
+          for j in 0..dim_phase - 1
+            j < dim_phase && i < dim_phase
+            zij[i][j] = primitive_impedance_matrix[i][j]
+          end
+        end
+        znn = Array.new(dim_neutrals) { Array.new(dim_neutrals) }
+        for i in 0..znn.length - 1
+          for j in 0..znn.length - 1
+            znn[i][j] = primitive_impedance_matrix[neutrals + i][neutrals + j] # neutrals e l indice del neutro
+          end
+        end
+        zin = Array.new(dim_phase) { Array.new(dim_neutrals) } # z[i][n]
+        for i in 0..dim_phase - 1
+          for j in 0..dim_neutrals - 1
+            i < dim_phase
+            zin[i][j] = primitive_impedance_matrix[i][neutrals + j]
+          end
+        end
+        znj = Array.new(dim_neutrals) { Array.new(dim_phase) } # z[n][j]
+        for i in 0..dim_neutrals - 1
+          for j in 0..dim_phase - 1
+            j < dim_phase
+            znj[i][j] = primitive_impedance_matrix[i + neutrals][j]
+          end
+        end
+
+        half = Matrix[*znn].inverse * Matrix[*znj] # first step to obtain the first matrix
+        seq = Matrix[*zij] - (Matrix[*zin] * half)
+        return seq
+      end
+
+      # methods to apply the modified Carson equation to either the diagonal components of the primitive impedance matrix or to the other components
+      def carson_equation_self(ri, gmri)
+        # Carson's equation for self impedance
+        return Complex(ri + 0.0953, 0.12134 * (Math.log(1.0 / gmri) + 7.93402)) # GMR e il geometric mean radius del conduttore
+      end
+
+      def carson_equation(dij)
+        # """Carson's equation for mutual impedance
+        if dij != 0
+          return Complex(0.09530, 0.12134 * (Math.log(1.0 / dij) + 7.93402))
+        end
+      end
+
+      # method applying a similar concept of the Carson equation, but for obtaining the primitive potential coeff matrix
+      # for obtaining the lines capacitance
+      def get_primitive_potential_coeff_matrix(diamaters, images_matrix, dist_matrix)
+        n_rows = images_matrix.length
+        n_cols = images_matrix.length
+        primitive_potential_coeff_matrix = Array.new(n_rows) { Array.new(n_rows) }
+        for i in 0..n_rows - 1
+          for j in 0..n_cols - 1
+            if i == j
+              primitive_potential_coeff_matrix[i][j] = 11.17689 * Math.log(images_matrix[i][j] / (diamaters[i] / 2)) # assuming relative permittivity of air of 1.4240 x 10 mF/mile
+            else
+              primitive_potential_coeff_matrix[i][j] = 11.17689 * Math.log(images_matrix[i][j] / dist_matrix[i][j]) # assuming relative permittivity of air of 1.4240 x 10 mF/mile
+            end
+          end
+        end
+        return primitive_potential_coeff_matrix
+      end
+
+      # method for obtaining the primitive impedance matrix
+      def get_primitive_impedance_matrix(dist_matrix, gmr_list, r_list)
+        '''Get primitive impedance matrix from distance matrix between the wires, GMR list, and resistance list.'''
+        n_rows = dist_matrix.length
+        n_cols = dist_matrix.length
+        primitive_impedance_matrix = Array.new(n_rows) { Array.new(n_rows) }
+        for i in 0..n_rows - 1
+          for j in 0..n_cols - 1
+            if i == j
+              primitive_impedance_matrix[i][j] = carson_equation_self(r_list[i], gmr_list[i])
+            else
+              primitive_impedance_matrix[i][j] = carson_equation(dist_matrix[i][j])
+            end
+          end
+        end
+        return primitive_impedance_matrix
+      end
+
+      # method to obtain the lines capacitance
+      def get_capacitance(wire_list)
+        nphases = wire_list.height.length
+        conc_neutrals = wire_list.r_neutral.length
+        distance_matrix = Array.new(nphases) { Array.new(nphases) }
+        distance_matrix_feet = Array.new(nphases) { Array.new(nphases) }
+        image_matrix = Array.new(nphases) { Array.new(nphases) }
+        image_matrix_ft = Array.new(nphases) { Array.new(nphases) }
+        diameters_conductors_ft = []
+        w = 2 * Math::PI * 60
+        for i in 0..nphases - 1
+          diameters_conductors_ft[i] = si_to_imperial_units(wire_list.diameter[i], 'mm', 'ft')
+          for j in 0..nphases - 1
+            distance_matrix[i][j] = (((wire_list.x[i] - wire_list.x[j])**2 + (wire_list.height[i] - wire_list.height[j])**2)**0.5).to_f.round(5) # ((i - j).abs() * 0.6) #60cm apart one above the other or side by side
+            image_matrix[i][j] = (((wire_list.x[i] - wire_list.x[j])**2 + (wire_list.height[i] - -wire_list.height[j])**2)**0.5).to_f.round(5) # computing matrix with distances among images of the cables referred to the ground
+            distance_matrix_feet[i][j] = si_to_imperial_units(distance_matrix[i][j], 'm', 'ft')
+            image_matrix_ft[i][j] = si_to_imperial_units(image_matrix[i][j], 'm', 'ft')
+          end
+        end
+        if conc_neutrals == 0 # meaning that we are NOT considering concentric neutrals
+          primitive_potential_coeff = get_primitive_potential_coeff_matrix(diameters_conductors_ft, image_matrix_ft, distance_matrix_feet)
+          if primitive_potential_coeff.length != 3
+            reduced_potential_coeff = kron_reduction(primitive_potential_coeff, conc_neutrals)
+          else
+            reduced_potential_coeff = Matrix[*primitive_potential_coeff]
+          end
+          capacitance_matrix = reduced_potential_coeff.inverse # obtaining the capacitance matrix in micro Farad
+          for i in 0..capacitance_matrix.column_size - 1
+            for j in 0..capacitance_matrix.column_size - 1
+              capacitance_matrix[i, j] = Complex(0, capacitance_matrix[i, j] * w)
+            end
+          end
+          if capacitance_matrix.column_size > 1
+            seq_capacitance = Array.new(3) { Array.new(3) }
+            seq_admittance_ft = get_sequence_impedance_matrix(capacitance_matrix)
+            for i in 0..seq_admittance_ft.column_size - 1
+              for j in 0..seq_admittance_ft.column_size - 1
+                seq_capacitance[i][j] = imperial_to_si_units((seq_admittance_ft[i, j] / w) * 1000, '1/mi', '1/km') # to be provided in nF
+              end
+            end
+            capacitance = { 'Capacitance(nF/km)' => seq_capacitance[1][1].imag, 'C0 (nF/km)' => seq_capacitance[0][0].imag }
+          else
+            seq_capacitance = imperial_to_si_units((capacitance_matrix[0, 0] / w) * 1000, '1/mi', '1/km')
+            capacitance = { 'Capacitance(nF/km)' => seq_capacitance.imag, 'C0 (nF/km)' => seq_capacitance.imag }
+          end
+        else # now computing the capacitance for UG concentric neutral power lines
+          material_permettivity = 2.3 # assuming using the minimum permittivity value for "cross-linked polyethlyene", as the insulation material
+          free_space_permittivity = 0.0142 # in microfaraday/mile
+          radius = (wire_list.outside_diamater_neutral[0] - wire_list.diameter_n_strand[0]) / 2 # in mm
+          radius_ft = si_to_imperial_units(radius, 'mm', 'ft')
+          radius_neutral_ft = si_to_imperial_units(wire_list.diameter_n_strand[0] / 2, 'mm', 'ft')
+          radius_conductor_ft = diameters_conductors_ft[0] / 2
+          numerator = 2 * Math::PI * material_permettivity * free_space_permittivity
+          denominator = (Math.log(radius_ft / radius_conductor_ft) - ((1 / wire_list.neutral_strands[0]) * Math.log((wire_list.neutral_strands[0] * radius_neutral_ft) / radius_ft)))
+          (numerator / denominator) * 1000
+          seq_capacitance = imperial_to_si_units((numerator / denominator) * 1000, '1/mi', '1/km')
+          capacitance = { 'Capacitance(nF/km)' => seq_capacitance, 'C0 (nF/km)' => seq_capacitance }
+        end
+        return capacitance
+      end
+
+      # method to obtain the line sequence impedances
+      def get_sequence_impedances(wire_list)
+        '''Get sequence impedances Z0, Z+, Z- from distance matrix between the wires, GMR list, and resistance list.'''
+        nphases = wire_list.height.length
+        conc_neutrals = wire_list.r_neutral.length
+        distance_matrix = Array.new(nphases + conc_neutrals) { Array.new(nphases + conc_neutrals) }
+        distance_matrix_feet = Array.new(nphases + conc_neutrals) { Array.new(nphases + conc_neutrals) }
+        gmr_ft = []
+        resistance_mi = []
+        gmr_neutral = []
+        for i in 0..nphases - 1
+          for j in 0..nphases - 1
+            distance_matrix[i][j] = (((wire_list.x[i] - wire_list.x[j])**2 + (wire_list.height[i] - wire_list.height[j])**2)**0.5).to_f.round(5) # ((i - j).abs() * 0.6) #60cm apart one above the other or side by side
+          end
+        end
+        if !wire_list.r_neutral[0].nil? # computing parameters for concentric neutrals wires
+          for j in 0..conc_neutrals - 1
+            radius = (wire_list.outside_diamater_neutral[j] - wire_list.diameter_n_strand[j]) / 2
+            wire_list.gmr.push(wire_list.gmr_neutral[j] * wire_list.neutral_strands[j] * (radius**(wire_list.neutral_strands[j] - 1))**(1 / wire_list.neutral_strands[j]))
+            wire_list.r.push(wire_list.r_neutral[j] / wire_list.neutral_strands[j])
+            for k in 0..conc_neutrals - 1
+              distance_matrix[conc_neutrals + j][conc_neutrals + k] = distance_matrix[j][k]
+              if j == k
+                distance_matrix[j + conc_neutrals][k] = radius / 1000 # converting from mm to m
+                distance_matrix[j][k + conc_neutrals] = radius / 1000
+              # As per Example 4.2 of Kersting. phase-neutral = phase-phase distance for different cables
+              else
+                distance_matrix[j + conc_neutrals][k] = distance_matrix[j][k]
+                distance_matrix[j][k + conc_neutrals] = distance_matrix[j][k]
+              end
+            end
+          end
+        end
+        for i in 0..distance_matrix.length - 1
+          gmr_ft[i] = si_to_imperial_units(wire_list.gmr[i], 'mm', 'ft') # in ft
+          resistance_mi[i] = si_to_imperial_units(wire_list.r[i], '1/km', '1/mi') # in miles verify if it was provided in miles
+          for j in 0..distance_matrix.length - 1
+            distance_matrix_feet[i][j] = si_to_imperial_units(distance_matrix[i][j], 'm', 'ft')
+          end
+        end
+        primitive = get_primitive_impedance_matrix(distance_matrix_feet, gmr_ft, resistance_mi)
+        if primitive.length != 3 # not for V-phase lines, I keep these lines as a 3x3 Matrix, without executing Kron Reduction
+          phase = kron_reduction(primitive, conc_neutrals) # passing number of concentric neutrals if any
+        else
+          phase = Matrix[*primitive] # still treated as a 3x3 Matrix
+        end
+        if phase.column_size != 1 # if single-phase lines the sequence impedance value is already obtained
+          seq_new = Array.new(3) { Array.new(3) }
+          seq = get_sequence_impedance_matrix(phase)
+          for i in 0..seq.column_size - 1
+            for j in 0..seq.column_size - 1
+              seq_new[i][j] = imperial_to_si_units(seq[i, j], '1/mi', '1/km')
+            end
+          end
+          impedances = { 'Resistance(ohms/km)' => seq_new[1][1].real, 'Ind. Reactance(ohms/km)' => seq_new[1][1].imag, 'R0 (ohms/km)' => seq_new[0][0].real, 'X0 (ohms/km)' => seq_new[0][0].imag }
+        else
+          seq_new = imperial_to_si_units(phase[0, 0], '1/mi', '1/km')
+          impedances = { 'Resistance(ohms/km)' => seq_new.real, 'Ind. Reactance(ohms/km)' => seq_new.imag, 'R0 (ohms/km)' => seq_new.real, 'X0 (ohms/km)' => seq_new.imag }
+        end
+        return impedances
+      end
+
+      # method that starting from each line geometry finds the parameters of each wire forming that power line
+      def creation(wires)
+        seq_impedances = []
+        wire_list = []
+        hash = {}
+        jj = 0
+        wire_list = URBANopt::RNM::WiresExtendedCatalog.new
+        # puts wire_list
+        for j in 0..@power_line['Line geometry'].length - 1
+          for k in 0..wires['WIRES CATALOG'].length - 1
+            if @power_line['Line geometry'][j]['wire'] == wires['WIRES CATALOG'][k]['nameclass']
+              wire_list.name.push(wires['WIRES CATALOG'][k]['nameclass'])
+              wire_list.diameter.push(wires['WIRES CATALOG'][k]['diameter (mm)'])
+              wire_list.r.push(wires['WIRES CATALOG'][k]['resistance (ohm/km)'])
+              wire_list.gmr.push(wires['WIRES CATALOG'][k]['gmr (mm)'])
+              wire_list.ampacity.push(wires['WIRES CATALOG'][k]['ampacity (A)'])
+              wire_list.type.push(wires['WIRES CATALOG'][k]['type'])
+              if wires['WIRES CATALOG'][k].include? 'resistance neutral (ohm/km)'
+                wire_list.r_neutral.push(wires['WIRES CATALOG'][k]['resistance neutral (ohm/km)'])
+                wire_list.gmr_neutral.push(wires['WIRES CATALOG'][k]['gmr neutral (mm)'])
+                wire_list.neutral_strands.push(wires['WIRES CATALOG'][k]['# concentric neutral strands'])
+                wire_list.diameter_n_strand.push(wires['WIRES CATALOG'][k]['concentric diameter neutral strand (mm)'])
+                wire_list.outside_diamater_neutral.push(wires['WIRES CATALOG'][k]['concentric neutral outside diameter (mm)'])
+              end
+            end
+          end
+          if @power_line['Line geometry'][j]['phase'] != 'N' # && @power_line["Current(A) "] != nil
+            line_current = wire_list.ampacity[j]
+          end
+          wire_list.x.push(@power_line['Line geometry'][j]['x (m)'])
+          wire_list.height.push(@power_line['Line geometry'][j]['height (m)'])
+        end
+        capacitances = get_capacitance(wire_list)
+        impedances = get_sequence_impedances(wire_list)
+        # electric_parameters = impedances.merge(capacitances)
+        @power_line.delete('Line geometry')
+        cont = 0
+        pair = []
+        key = 0
+        # organizing the impedances and capacitance values found to be placed in the right order in the RNM-US catalog
+        impedances.each do |k, v| # place the new fields in the right positions
+          pair[cont] = { k => v }
+          if cont < 2
+            field =
+              if  cont == 0
+                insert_field('Nphases', pair[cont], :after)
+              else
+                insert_field(key, pair[cont], :after)
+              end
+            key = k
+          else
+            if cont == 2
+              insert_field(key, { 'Current(A)' => line_current }, :after)
+              insert_field('Repair time maximum (hours)', pair[cont], :after)
+            else
+              insert_field(key, pair[cont], :after)
+            end
+            key = k
+          end
+          cont += 1
+        end
+        cont = 0
+        capacitances.each do |k, v|
+          if cont == 0
+            insert_field('Ind. Reactance(ohms/km)', { k => v }, :after)
+          else
+            insert_field('X0 (ohms/km)', { k => v }, :after)
+          end
+          cont += 1
+        end
+        return @power_line
+      end
+    end
+  end
+end

data/lib/urbanopt/rnm/consumers.rb

@@ -0,0 +1,255 @@
+# *********************************************************************************
+# URBANopt (tm), Copyright (c) 2019-2021, Alliance for Sustainable Energy, LLC, and other
+# contributors. All rights reserved.
+
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+
+# Redistributions of source code must retain the above copyright notice, this list
+# of conditions and the following disclaimer.
+
+# Redistributions in binary form must reproduce the above copyright notice, this
+# list of conditions and the following disclaimer in the documentation and/or other
+# materials provided with the distribution.
+
+# Neither the name of the copyright holder nor the names of its contributors may be
+# used to endorse or promote products derived from this software without specific
+# prior written permission.
+
+# Redistribution of this software, without modification, must refer to the software
+# by the same designation. Redistribution of a modified version of this software
+# (i) may not refer to the modified version by the same designation, or by any
+# confusingly similar designation, and (ii) must refer to the underlying software
+# originally provided by Alliance as "URBANopt". Except to comply with the foregoing,
+# the term "URBANopt", or any confusingly similar designation may not be used to
+# refer to any modified version of this software or any modified version of the
+# underlying software originally provided by Alliance without the prior written
+# consent of Alliance.
+
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+# IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+# INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+# LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+# OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+# OF THE POSSIBILITY OF SUCH DAMAGE.
+# *********************************************************************************
+
+# 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
+require 'json'
+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
+
+      # 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)
+        @reopt = reopt
+        @average_building_peak_catalog_path = average_building_peak_catalog_path
+        @only_lv_consumers = only_lv_consumers
+        @max_num_lv_nodes = max_num_lv_nodes
+        @customers = []
+        @customers_ext = []
+        @profile_customer_p = []
+        @profile_customer_q = []
+        @profile_customer_p_ext = []
+        @profile_customer_q_ext = []
+        @power_factor = power_factor
+        @lv_limit = lv_limit
+      end
+
+      # creating a method to process each building electricity consumption
+      # the method receives as argument the required data obtained from each feature csv and json urbanopt output files
+      # and returns the customer_ext array for each feature, with the required customer data needed for RNM-US
+      # and the profiles consumers files
+
+      # the method is divided in 2 part, the first is run in case the user uses the "only LV" option to run the network,
+      # defining a certain numb of nodes for each building
+      # 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_profile_node_active = []
+          planning_profile_node_reactive = []
+          yearly_profile_node_active = []
+          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)
+          closest_node = building_map[3].split('_')[1].to_i # refers to the node, found in the class above
+          node = closest_node
+          cont = 1
+          cont_reverse = 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
+            node_reverse = closest_node - cont_reverse
+            if i > 1 && node <= building_nodes.length - 1
+              coordinates = building_nodes[node] # take the closest building node index to the street and pass the nodes after it
+              cont += 1
+            elsif i > 1
+              coordinates = building_nodes[node_reverse]
+              cont_reverse += 1
+            end
+            # creating the lists for the customers text files required by the model
+            id = coordinates[3]
+            peak_active_power_cons = ((single_values[:peak_active_power_cons]) / nodes_per_bldg).round(2)
+            peak_reactive_power_cons = ((single_values[:peak_reactive_power_cons]) / nodes_per_bldg).round(2)
+            # introducing this for consistency
+            if medium_voltage
+              voltage_default = 12.47
+              phases = 3
+            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_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_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_customer_q.push([id, 24, planning_profile_node_reactive])
+            @profile_customer_p.push([id, 24, planning_profile_node_active])
+            @profile_customer_p_ext.push([id, 8760, yearly_profile_node_active])
+            @profile_customer_q_ext.push([id, 8760, yearly_profile_node_reactive])
+
+          end
+        # 2nd option run in case the building consumption is represented by a single node
+        else
+          id = building_map[3]
+          # this key seems to change between floor_area or floor_area_ft
+          area = folder.key?('floor_area') ? (folder['floor_area']).round(2) : (folder['floor_area_sqft']).round(2)
+          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_customer_q.push([id, 24, profiles[:planning_profile_cust_reactive]])
+          @profile_customer_p.push([id, 24, profiles[: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]])
+        end
+      end
+
+      # creating a function that for each  node defines the connection (e.g LV, MV, single-phase, 3-phase)
+      # according to the catalog limits previously calculated
+      def voltage_values(peak_apparent_power)
+        case peak_apparent_power
+          when 0..@lv_limit[:single_phase] # set by the catalog limits
+            phases = 1
+            voltage_default = 0.416
+          when @lv_limit[:single_phase]..@lv_limit[:three_phase] # defined from the catalog (from the wires)
+            phases = 3
+            voltage_default = 0.416
+            # MV and 3 phases untill 16 MVA, defined by the SMART-DS project
+          when @lv_limit[:three_phase]..16000
+            phases = 3
+            voltage_default = 12.47
+          else
+            # HV and 3 phases for over 16 MVA
+            phases = 3
+            voltage_default = 69
+        end
+        return voltage_default, phases
+      end
+
+      # creating a method to define the number of nodes for each building in case the user set the option "only LV" to true.
+      # this method calculates the number of nodes for each building in the project and in case the numb of nodes is higher than 4
+      # than the building is considered as a single node connected in MV
+      # the numb of nodes is calculated based on the average_peak_catalog which is obtained from DOE open_source data per location and per building type
+      def av_peak_cons_per_building_type(feature_file)
+        average_peak_by_size = []
+        floor_area = []
+        average_peak = 5 # defining a random value first, since now the residential buildings are not considered in the catalog
+        mixed_use_av_peak = 0
+        area_mixed_use = 0
+        medium_voltage = false
+        # defining a conservative factor which creates some margin with the number of nodes found using the av_peak catalog, with the
+        # actual nodes that could be found with the current buildings peak consumptions in the project
+        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
+          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']
+              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 reasonable because we assume always 1 node per RES consumers single-detached family houses
+            end
+          end
+          if counter > 1
+            index = floor_area.index(floor_area.min)
+            average_peak = average_peak_by_size[index]
+          end
+          if feature_file.length > 1 # defined for Mixed_use buildings, which include more building types
+            mixed_use_av_peak += average_peak
+            area_mixed_use += area
+          end
+        end
+        if feature_file.length > 1
+          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 # to define this as an input in the geojson file
+          nodes_per_bldg = 1
+          medium_voltage = true
+        end
+        return nodes_per_bldg, area, medium_voltage
+      end
+
+      # defining a method for the customers files creation:
+      # obtaining all the needed input from each feature_report.csv file (active & apparent power and tot energy consumed)
+      # and from each feature_report.json file (area, height, number of users)
+      # 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)
+        profiles = Hash.new { |h, k| h[k] = [] }
+        single_values = Hash.new(0)
+        hours = 23
+        feature_type = json_feature_report['program']['building_types'][0]['building_type']
+        residential_building_types = 'Single-Family Detached' # add the other types
+        # 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
+        else
+          profile_start_max = hour.hour_index_max_comm - hour.peak_hour_max_comm
+        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
+        # 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['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_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
+              single_values[:peak_reactive_power_cons] = single_values[:peak_active_power_cons] * Math.tan(Math.acos(@power_factor))
+            end
+            profiles[:planning_profile_cust_reactive][i] = profiles[:planning_profile_cust_active][i] * Math.tan(Math.acos(@power_factor))
+            i += 1
+          end
+          k += 1
+        end
+        # parsing the required information from feature.json file
+        # folder =  JSON.parse(json_feature_report)
+        height = (json_feature_report['program']['maximum_roof_height_ft']).round(2) # here depends on the feature version
+        users = json_feature_report['program']['number_of_residential_units']
+        construct_consumer(profiles, single_values, building_map, building_nodes, height, users, json_feature_report['program'])
+      end
+    end
+  end
+end