urbanopt-rnm-us 0.1.0

data/lib/urbanopt/rnm/conversion_to_opendss.rb

@@ -0,0 +1,152 @@
+# *********************************************************************************
+# 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 'json'
+module URBANopt
+  module RNM
+    # class created to convert the extended catalog into the OpenDSS catalog to be used by the OpenDSS Gem
+    class ConversionToOpendssCatalog
+      attr_accessor :hash
+
+      def initialize(extended_catalog_path)
+        @extended_catalog_path = extended_catalog_path
+        @hash = hash
+      end
+
+      # method to convert initial SI units in the ext catalog into Imperial units used by the Carson equation
+      def convert_to_imperial_units(hash)
+        hash_new = {}
+        hash.each do |k, v|
+          if k.include? '(mm)'
+            mm_ft = 0.00328
+            hash_new[k] = (v * mm_ft).round(5)
+          elsif k.include? '(ohm/km)'
+            km_miles = 0.6214
+            hash_new[k] = (v / km_miles).round(2)
+          elsif k.include? '(m)'
+            m_ft = 3.281
+            hash_new[k] = (v * m_ft).round(2)
+          else
+            hash_new[k] = hash[k]
+          end
+        end
+        return hash_new
+      end
+
+      def create_catalog(save_path)
+        @hash = {}
+        component = []
+        catalog = JSON.parse(File.read(@extended_catalog_path))
+        i = 0
+        z = 0
+
+        catalog.each do |key, value|
+          case key
+          when 'SUBSTATIONS AND DISTRIBUTION TRANSFORMERS'
+            transformers = URBANopt::RNM::ProcessorOpendss.new
+            component = []
+            for ii in 0..catalog[key].length - 1 # assessing each type of transformer (Urban, Inter)
+              catalog[key][ii].each do |k, v|
+                # calling a method to verify that the same transformers are not repeated in the OpenDSS catalog
+                transformers.process_data(catalog[key][ii][k])
+              end
+            end
+            for i in 0..transformers.list.length - 1
+              trafo = URBANopt::RNM::Transformers.new
+              component.push(trafo.create(transformers.list[i]))
+            end
+            @hash['transformers_properties'] = component
+          when 'CAPACITORS'
+            capacitors = URBANopt::RNM::ProcessorOpendss.new
+            component = []
+            catalog[key].each do |k, v|
+              # calling a method to verify that the same capacitors are not repeated in the OpenDSS catalog
+              capacitors.process_data(catalog[key][k])
+              for i in 0..capacitors.list.length - 1
+                capacitor = URBANopt::RNM::Capacitor.new
+                component.push(capacitor.create(capacitors.list[i]))
+              end
+            end
+            @hash['capacitor_properties'] = component
+          when 'LINES'
+            @conductors = URBANopt::RNM::ProcessorOpendss.new
+            component = []
+            for ii in 1..catalog[key].length - 1
+              catalog[key][ii].each do |k, v| # assessing if interurban section, urban section, etc.
+                for jj in 0..catalog[key][ii][k].length - 1 # assessing each power line
+                  catalog[key][ii][k][jj].each do |attribute, values|
+                    if attribute == 'Line geometry'
+                      # calling a method to verify that the same lines are not repeated in the OpenDSS catalog
+                      @conductors.process_data(catalog[key][ii][k][jj][attribute])
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+
+        key = 'WIRES'
+        component = []
+        updated_value = 0
+        i = 0 # counter for all the lines in the OpenDSS catalog
+        catalog[key].each do |k, v|
+          for jj in 0..@conductors.cont - 1
+            for ii in 0..catalog[key][k].length - 1
+              if @conductors.list[jj]['wire'] == catalog[key][k][ii]['nameclass']
+                @conductors.list[jj] = convert_to_imperial_units(@conductors.list[jj])
+                updated_value = convert_to_imperial_units(catalog[key][k][ii])
+                wire = URBANopt::RNM::WiresOpendss.new
+                component.push(wire.create(@conductors.list[jj], updated_value))
+                i += 1
+              end
+            end
+          end
+        end
+        @hash['wires'] = component
+
+        # save to save_path
+        File.open(save_path, 'w') do |f|
+          f.write(JSON.pretty_generate(@hash))
+        end
+      end
+    end
+  end
+end

data/lib/urbanopt/rnm/geojson_input.rb

@@ -0,0 +1,261 @@
+# *********************************************************************************
+# 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 'geoutm'
+require 'json'
+
+module URBANopt
+  module RNM
+    # creating a class to process parse and process the geographic information for buildings, streets and substations
+    class GeojsonInput
+      # Set constants
+      UG_RATIO_DEFAULT = 0.9
+      ONLY_LV_CONSUMERS_DEFAULT = true
+      MAX_LV_NODES_DEFAULT = 1
+
+      # defining a method to set each street nodes to a uniform distance among eachothers, valid for both streets and buildings
+      # the method is passing as arguments the hash with each feature info from the geojson file, the latitude and longitude to be converted to UTM,
+      # the array containing the already processed nodes, the index defining the position of the lat and lon passed in this method
+      # and the index defining the reached position in the array with the processed nodes
+      # this method returns the array with the processed nodes and its index
+      def coordinates(hash, lat, lon, coordinates, k, i)
+        lat_lon = GeoUtm::LatLon.new(lat, lon)
+        z = 0 # default value for surface elevation
+        uniform_distance = 15 # values set as uniform distance among nodes
+        utm = lat_lon.to_utm # converting latitude and longitude to UTM
+        x_utm = utm.e.round(2) # UTM x-distance from the origin
+        y_utm = utm.n.round(2) # UTM y-distance from the origin
+        identifier = hash['properties']['id']
+        # creating streetmap nodes every 10 m for each road, considering the angle of each road
+        if k != 0
+          distance_y = y_utm - coordinates[i - 1][1]
+          distance_x = x_utm - coordinates[i - 1][0]
+          distance = (distance_x**2 + distance_y**2)**0.5
+          intervals = (distance / uniform_distance).to_i
+          # creating variables for x, y for each node, with the right street inclination
+          x_uniform = uniform_distance * (distance_x / distance)
+          y_uniform = uniform_distance * (distance_y / distance)
+          n = 1 # counter to keep track when the number of intervals for each "distnce" is reached
+          # creating nodes in the coordinates array with the right street inclination and uniform distance among each others
+          while n <= intervals
+            id = identifier.to_s + "_#{i}"
+            coordinates[i] = (coordinates[i - 1][0] + x_uniform).round(2), (coordinates[i - 1][1] + y_uniform).round(2), z, id
+            i += 1
+            n += 1
+          end
+          # when the last interval of each road is reached, the last node values are given as the streets coordinates
+          # imported from the street.json file
+          id = identifier.to_s + "_#{i}"
+          coordinates[i] = x_utm.round(2), y_utm.round(2), z, id
+          i += 1
+        else
+          # in the 1st node of each road, the coordinates are tacken directly from the streetmap.json file
+          id = identifier.to_s + "_#{i}"
+          coordinates[i] = x_utm, y_utm, z, id
+          i += 1
+        end
+        return coordinates, i
+      end
+
+      # defining a method to find the coordinates of the closest node of each building building to the closest street, to be used for the customers_ext.txt file
+      # the method receives as arguments every nodes of 1 building and the array containing all the street nodes computed before
+      # and it returns the coordinates and id of the closest node of the building to the street
+      ## The new algorithm developed calculates an approximate distance: (x+y)/2, of each building-node with each street-node and compares it with the "minimum_distance"
+      # this approximate distance has been defined in order to be able to disregard all the distances which are greater than the "minimum distance" computed until that moment, without being required to compute the Pithagorean Theorem, which requires a long computational time.
+      # Therefore (x+y)/2 has been computed knowing that: if the minimum length of the hypothenuse of a right triangle is when the triangle is isosceles so when the hyphothenuse (d) is equal to d = sqrt(2)*x (where x is the distance among the nodes on the x-axis),
+      # so we can assume that x = (x+y)/2, than if d = sqrt(2)*((x+y)/2) > (x+y)/2 > minimum_distance
+      # than it confirmes that x and y can be disregarded and there is no need to compute the real distance for that node since the approximate distance value (which represents the minimum possible distance for the sum of those catheti)
+      # is greater than the minimum_distance that it is been compared with.
+      # This process it is iterated for all the distances among the building-nodes with the street-nodes until an approximate distance (x+y)/2 is lower than the minimum distance computed until that moment
+      # and in that case the real distance with the Pythagorean Theorem is computed and compared with the minimum distance.
+      def consumer_coordinates(building, street)
+        dist_min = 5000 # assuming a first fitticious minimum distance that will be replaced later on by the real minimum distance
+        # iterating the distance among each node of each street and each node of each building until the minimum distance is found
+        for j in 0..building.length - 1 # assessing each building node of the considered building
+          for i in 0..street.length - 1 # assessing each street node
+            y = building[j][1] - street[i][1] # calculating the distance on the y-axis
+            x = building[j][0] - street[i][0] # calculating the distance on the x-axis
+            distance_approx = (x + y) / 2 # finding the "approximate" distance of each building node with each street node, in order to reduce computational time (considering that if the sum of the 2 cathets divided by 2 is lower than the minimum distance, than the real distance of this building node to the closest street-node will be further processed to see if it can be a "candidate" for the minimum distance)
+            if distance_approx < dist_min # if the the new distance found is lower than the minimum one than the real distance considering this building-node and this street-node will be computed
+              distance = (x**2 + y**2)**0.5 # the real distance between the building node and the street node is computed
+              if distance < dist_min # if the new distance is lower than the minimum distance found until that moment, than this new "distance" value will be set as the minimum distance between the building node and the street node
+                dist_min = distance
+                chosen_coord = building[j] # assigning the node coordinates values and id of the building with the minimium distance to the street to chose_coord variable
+              end
+            end
+            end
+        end
+        return chosen_coord
+      end
+
+      # defining a method for parsing the coordinates of the substations to be passed in the RNM-US model
+      # choose the closes coord to the street or the one in the midle of the polygon since the sub is far away from district and streets
+      def sub_coordinates(points_coord, id)
+        x_utm = []
+        y_utm = []
+        for i in 0..points_coord.length - 1
+          lat_lon = GeoUtm::LatLon.new(points_coord[i][1], points_coord[i][0])
+          utm = lat_lon.to_utm # converting latitude and longitude to UTM
+          x_utm[i] = utm.e.round(2) # UTM x-distance from the origin
+          y_utm[i] = utm.n.round(2) # UTM y-distance from the origin
+        end
+        coord_sub = [(x_utm[0] + x_utm[2]) / 2, (y_utm[0] + y_utm[2]) / 2, 0, "sub_#{id}"]
+        return coord_sub
+      end
+
+      # creating a method passing the GeoJSON file from URBANopt as the argument to define options that can be modified by the user
+      # streets and building and primary substation coordinates
+      # and returning the street coordinates array, the building coordinates array and the tot number of buildings in the project
+      def coordinates_feature_hash(geojson_hash,scenario_features=[])
+        i = 0 # index representing the number of street_nodes
+        building_number = 0 # variable created to keep track the number of buildings in the project
+        street_number = 0 # variable created to keep track the number of streets in the project
+        substation_number = 0 # variable created to keep track the number of substations in the project
+        customers_coordinates = [] # array containing the coordinates and id of the closest node of each building to the street
+        street_coordinates = [] # array containing every street node coordinates and id
+        coordinates_buildings = [] # array containing every building node coordinates and id
+        building_ids = [] # array containing building_ids to retrieve urbanopt results later
+        building_floors = [] # array containing numb of floors for each building
+        substation_location = []
+        utm_zone = 0
+        streets = geojson_hash
+        puts "SCENARIO FEATURES: #{scenario_features}"
+        # parsing the options defined by the user to run the RNM-US with a certain % of UG cables and designing the network with only LV nodes
+        # to be consistent in case several case-studies are run to have an homogenous parameter on how to compare the same buildings with different energy consumption
+        # Use defaults and warn user if these fields are unset
+        if streets.key?('project') && streets['project'].key?('underground_cables_ratio')
+          ug_ratio = streets['project']['underground_cables_ratio'].to_f
+          puts "RNM-US gem INFO: using underground_cables_ratio of #{ug_ratio}"
+        else
+          ug_ratio = UG_RATIO_DEFAULT
+          puts "RNM-US gem WARNING: field ['project']['underground_cables_ratio'] not specified in Feature File...using default value of #{UG_RATIO_DEFAULT}"
+        end
+        if streets.key?('project') && streets['project'].key?('only_lv_consumers')
+          only_lv_consumers = streets['project']['only_lv_consumers']
+          puts "RNM-US gem INFO: using only_lv_consumers ratio of #{only_lv_consumers}"
+        else
+          only_lv_consumers = ONLY_LV_CONSUMERS_DEFAULT
+          puts "RNM-US gem WARNING: field ['project']['only_lv_consumers'] not specified in Feature File...using default value of #{ONLY_LV_CONSUMERS_DEFAULT}"
+        end
+        if streets.key?('project') && streets['project'].key?('max_number_of_lv_nodes_per_building')
+          max_num_lv_nodes = streets['project']['max_number_of_lv_nodes_per_building']
+          puts "RNM-US gem INFO: using at max #{max_num_lv_nodes} lv nodes per building"
+        else
+          max_num_lv_nodes = MAX_LV_NODES_DEFAULT
+          puts "RNM-US gem WARNING: field ['project']['max_number_of_lv_nodes_per_building'] not specified in Feature File...using default value of #{MAX_LV_NODES_DEFAULT}"
+        end
+        # each features (linestring, multilinestring and polygon) are processed in an external method, to create intermediate nodes
+        # for a better graphical representation of the district
+        # "Point" geometry is ignored (site origin feature)
+        # put error if there is not this info, and use default values
+        streets['features'].each do |street|
+          # the geojson file is read and according to the "type" of feature (linestring, multilinestring, polygon)
+          # a different loop is executed to fill every node coordinates in a specific array
+          if street['properties']['type'] == 'District System' && street['properties']['district_system_type'] == 'Electrical Substation'
+            substation_location[substation_number] = sub_coordinates(street['geometry']['coordinates'][0], street['properties']['id'])
+            substation_number += 1
+          elsif street['geometry']['type'] == 'LineString' && street['properties']['type'] == 'Road'
+            each_street = [] # defining an array for each street, that includes all the nodes coordinates for each street
+            i = 0 # index representing the number of street_nodes
+            for k in 0..street['geometry']['coordinates'].length - 1
+              each_street, i = coordinates(street, street['geometry']['coordinates'][k][1], street['geometry']['coordinates'][k][0], each_street, k, i)
+                end
+            street_coordinates[street_number] = each_street
+            street_number += 1
+          elsif street['geometry']['type'] == 'MultiLineString' && street['properties']['type'] == 'Road'
+            each_street = []
+            i = 0 # index representing the number of street_nodes
+            for k in 0..street['geometry']['coordinates'].length - 1
+              for j in 0..street['geometry']['coordinates'][k].length - 1
+                each_street, i = coordinates(street, street['geometry']['coordinates'][k][j][1], street['geometry']['coordinates'][k][j][0], each_street, j, i)
+                end
+            end
+            street_coordinates[street_number] = each_street
+            street_number += 1
+          elsif street['geometry']['type'] == 'Polygon' && street['properties']['type'] == 'Building' and scenario_features.include? street['properties']['id']
+            for k in 0..street['geometry']['coordinates'].length - 1
+              h = 0 # index representing number of nodes for each single building
+              building = [] # array containing every building node coordinates and id of 1 building
+              for j in 0..street['geometry']['coordinates'][k].length - 1
+                building, h = URBANopt::RNM::GeojsonInput.new.coordinates(street, street['geometry']['coordinates'][k][j][1], street['geometry']['coordinates'][k][j][0], building, j, h)
+              end
+              coordinates_buildings[building_number] = building # inserting in each index the nodes coordinates and id of each building
+              building_ids[building_number] = street['properties']['id']
+              building_floors[building_number] = street['properties']['number_of_stories']
+              if building_number == 0
+                utm = GeoUtm::LatLon.new(street['geometry']['coordinates'][k][j][1], street['geometry']['coordinates'][k][j][0]).to_utm
+                utm_zone = utm.zone
+              end
+              building_number += 1
+            end
+          end
+        end
+
+        # raise error if no streets were found
+        if street_number == 0
+          raise 'ERROR: No roads were found in the Feature File. Road locations must be in the Feature File for RNM analysis.'
+        end
+
+        street_type = []
+        for i in 0..street_number - 1
+          # creating a class to define when the lines in each street have to be considered OH or UG
+          street_type[i] = URBANopt::RNM::OhUgRate.new
+          # obtaining the average height for each street and numb of buildings in each street
+          street_type[i].height_building(coordinates_buildings, street_coordinates[i], building_floors)
+        end
+        street = []
+        jj = 0
+        # defining each street as "OH" or "UG" according to the threshold value obtained from the user's input
+        for i in 0..street_number - 1
+          street_type[i].classify_street_type(street_type, ug_ratio)
+          for j in 0..street_coordinates[i].length - 1
+            street[jj] = street_coordinates[i][j][0], street_coordinates[i][j][1], street_coordinates[i][j][2], street_coordinates[i][j][3], street_type[i].type
+            jj += 1
+          end
+        end
+        # an external method is called to find the coordinates of the closest node of each building to the street
+        for i in 0..building_number - 1
+          customers_coordinates[i] = consumer_coordinates(coordinates_buildings[i], street)
+        end
+        return street, customers_coordinates, coordinates_buildings, building_number, building_ids, substation_location, only_lv_consumers, max_num_lv_nodes, utm_zone # considering creating an hash as attribute
+      end
+    end
+  end
+end

data/lib/urbanopt/rnm/input_files.rb

@@ -0,0 +1,335 @@
+# *********************************************************************************
+# 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 'csv'
+require 'json'
+require 'urbanopt/rnm/logger'
+require 'urbanopt/geojson'
+
+module URBANopt
+  module RNM
+    class InputFiles
+      ##
+      # Initialize InputFiles attributes: +run_dir+, +feature_file_path+, +reopt+, +extended_catalog_path+, +average_building_peak_catalog_path+, +rnm_dirname+, +opendss_catalog+
+      ##
+      # [parameters:]
+      # * +run_dir+ - _String_ - Full path to directory for simulation of this scenario
+      # * +feature_file_path+ - _String_ - Full path to GeoJSON feature file containing features and streets for simulation.
+      # * +extended_catalog_path+ - _String_ - Full path to the extended_catalog which include all the info about electric equipment and RNM-US parameters
+      # * +average_building_peak_catalog_path+ - _String_ - Full path to the catalog providing average peak building consumption per floor area and average floor area per building type
+      # * +reopt+ - _Boolean_ - Input command from the user to either include or not DG capabilities in planning the network, if REopt was ran before
+      # * +opendss_catalog+ - _Boolean_ - Input command from the user to either run or not the opendss_conversion_script to convert the extended_catalog in OpenDSS catalog
+      # * +rnm_dirname+ - _String_ - name of RNM-US directory that will contain the input files (within the scenario directory)
+      ##
+      def initialize(run_dir, scenario_features, feature_file, extended_catalog_path, average_building_peak_catalog_path, reopt: false, opendss_catalog: true, rnm_dirname: 'rnm-us')
+        @run_dir = run_dir
+        @feature_file = feature_file
+        @scenario_features = scenario_features
+        @rnm_dirname = rnm_dirname
+        @extended_catalog_path = extended_catalog_path
+        @average_building_peak_catalog_path = average_building_peak_catalog_path
+        @reopt = reopt
+        @opendss_catalog = opendss_catalog
+        # initialize @@logger
+        @@logger ||= URBANopt::RNM.logger
+
+        # initialize RNM directory
+        if !Dir.exist?(File.join(@run_dir, @rnm_dirname))
+          FileUtils.mkdir_p(File.join(@run_dir, @rnm_dirname))
+          @@logger.info("Created directory: #{File.join(@run_dir, @rnm_dirname)}")
+        end
+      end
+
+      # finding the limits on LV defined by the equipments in the catalog
+      def catalog_limits
+        catalog = JSON.parse(File.read(@extended_catalog_path))
+        limit = Hash.new(0)
+        limit_lines = Hash.new(0)
+        limit_trafo = Hash.new(0)
+        # evaluating first all the LV power lines included in the extended catalog and finding the LV 3-phase and single-phase
+        # lines with the highest capacity
+        catalog['LINES'][1].each do |key, v|
+          (0..catalog['LINES'][1][key].length - 1).each do |ii|
+            if catalog['LINES'][1][key][ii]['Voltage(kV)'] == '0.416'
+              if catalog['LINES'][1][key][ii]['Line geometry'][0]['phase'] != 'N'
+                wire = catalog['LINES'][1][key][ii]['Line geometry'][0]['wire']
+              else
+                wire = catalog['LINES'][1][key][ii]['Line geometry'][1]['wire']
+              end
+              jj = 0
+              jj += 1 while catalog['WIRES']['WIRES CATALOG'][jj]['nameclass'] != wire
+              current = catalog['WIRES']['WIRES CATALOG'][jj]['ampacity (A)'].to_i
+              if catalog['LINES'][1][key][ii]['Nphases'].to_i == 3
+                if ((current * (catalog['LINES'][1][key][ii]['Voltage(kV)']).to_f) * (3**0.5)) > limit_lines[:three_phase]
+                  limit_lines[:three_phase] = ((current * (catalog['LINES'][1][key][ii]['Voltage(kV)']).to_f) * (3**0.5)).round(2)
+                end
+              else
+                if (current * (catalog['LINES'][1][key][ii]['Voltage(kV)']).to_f) > limit_lines[:single_phase]
+                  limit_lines[:single_phase] = (current * (catalog['LINES'][1][key][ii]['Voltage(kV)']).to_f).round(2)
+                end
+              end
+            end
+          end
+        end
+        # evaluating all the distribution transformers included in the extended catalog and finding 3-phase and single-phase
+        # distr. transformers with the highest capacity
+        (0..catalog['SUBSTATIONS AND DISTRIBUTION TRANSFORMERS'].length - 1).each do |k, v|
+          catalog['SUBSTATIONS AND DISTRIBUTION TRANSFORMERS'][k].each do |key, value|
+            if catalog['SUBSTATIONS AND DISTRIBUTION TRANSFORMERS'][k][key][0]['Voltage level'] == 'MV-LV'
+              (0..catalog['SUBSTATIONS AND DISTRIBUTION TRANSFORMERS'][k][key].length - 1).each do |i|
+                if catalog['SUBSTATIONS AND DISTRIBUTION TRANSFORMERS'][k][key][i]['Nphases'] == '3'
+                  if (catalog['SUBSTATIONS AND DISTRIBUTION TRANSFORMERS'][k][key][i]['Guaranteed Power(kVA)'].to_i) > limit_trafo[:three_phase]
+                    limit_trafo[:three_phase] = catalog['SUBSTATIONS AND DISTRIBUTION TRANSFORMERS'][k][key][i]['Guaranteed Power(kVA)'].to_i
+                  end
+                else
+                  if (catalog['SUBSTATIONS AND DISTRIBUTION TRANSFORMERS'][k][key][i]['Guaranteed Power(kVA)'].to_i) > limit_trafo[:single_phase]
+                    limit_trafo[:single_phase] = catalog['SUBSTATIONS AND DISTRIBUTION TRANSFORMERS'][k][key][i]['Guaranteed Power(kVA)'].to_i
+                  end
+                end
+              end
+            end
+          end
+        end
+        trafo_margin = catalog['OTHERS']['Margin of design of new facilities LV (100.0 = designs with double so that 50% is left over)'].to_i
+        limit_trafo[:single_phase] = limit_trafo[:single_phase] / (1 + (trafo_margin / 100))
+        limit_trafo[:three_phase] = limit_trafo[:three_phase] / (1 + (trafo_margin / 100))
+        # setting as the limit for single-phase and 3-phase the component with the lowest capacity
+        if limit_trafo[:three_phase] < limit_lines[:three_phase]
+          limit[:three_phase] = limit_trafo[:three_phase]
+        else
+          limit[:three_phase] = limit_lines[:three_phase]
+        end
+        if limit_trafo[:single_phase] < limit_lines[:single_phase]
+          limit[:single_phase] = limit_trafo[:single_phase]
+        else
+          limit[:single_phase] = limit_lines[:single_phase]
+        end
+        return limit
+      end
+
+      ##
+      # Create the files that are required as input in RNM-US.
+      # (e.g. streetmapAS.txt, customers.txt, customers_ext.txt, customers_profiles_p.txt, customers_profiles_q.txt,
+      # customers_profiles_p_ext.txt, customers_profiles_q_ext.txt,substation_location.txt, generators.txt,
+      # generator_profiles_p.txt, generator_profiles_q.txt, generator_profiles_p_ext.txt, generator_profiles_q_ext.txt,
+      # ficheros_entrada.txt, ficheros_entrada_inc.txt, udcons.csv)
+      ##
+      def create
+        # the GEOjson file is loaded and a method is called to extract the required information regarding the street, building and substation location
+        street_coordinates, customers_coordinates, coordinates_buildings, tot_buildings, building_ids, substation_location, only_lv_consumers, max_num_lv_nodes, utm_zone = URBANopt::RNM::GeojsonInput.new.coordinates_feature_hash(@feature_file, @scenario_features)
+        # puts("BUILDING IDS: #{building_ids}")
+        # define the LV/MV limit imposed by the components of the catalog: distr.transformers and power lines and exporting the utm_zone to the catalog
+        lv_limit = catalog_limits
+        # verifying if running RNM-US with REopt option
+
+        if @reopt
+          if !File.join(@run_dir, 'feature_optimization').nil?
+            scenario_report_path = File.join(@run_dir, 'feature_optimization')
+            # creating a class prosumers with all the info for all the DER and consumption for each building
+            prosumers = URBANopt::RNM::Prosumers.new(@reopt, only_lv_consumers, max_num_lv_nodes, @average_building_peak_catalog_path, lv_limit) # passing these 2 conditions to see what option did the user
+          else
+            raise 'scenario report is not found'
+          end
+
+        else
+          if !File.join(@run_dir, 'scenario_report').nil?
+            scenario_report_path = File.join(@run_dir, 'default_scenario_report')
+            # creating a class consumers with all the info about the consumption for each building
+            consumers = URBANopt::RNM::Consumers.new(@reopt, only_lv_consumers, max_num_lv_nodes, @average_building_peak_catalog_path, lv_limit) # passing these 2 conditions to see what option did the user applied
+          else
+            raise 'scenario_report is not found'
+          end
+        end
+        file_csv = []
+        file_json = []
+        # finding the 2 most extreme hours of the year (maximum net demand and maximum net generation) the distribution network is planned
+        hours = URBANopt::RNM::ReportScenario.new(@reopt)
+        # hours_commercial = URBANopt::RNM::ReportScenario.new(@reopt)
+        (0..tot_buildings - 1).each do |j|
+          if @reopt
+            file_csv[j] = File.join(@run_dir, (building_ids[j]).to_s, 'feature_reports', 'feature_optimization.csv')
+
+            # check that reopt json file exists (feature optimization only)
+            if !File.exist?(File.join(@run_dir, (building_ids[j]).to_s, 'feature_reports', 'feature_optimization.json'))
+              msg = 'REopt feature_optimization.json file not found. To use REopt results in the RNM analysis,' \
+              'first post-process the project with the --reopt-feature flag.'
+              raise msg
+            end
+
+            file_json[j] = JSON.parse(File.read(File.join(@run_dir, (building_ids[j]).to_s, 'feature_reports', 'feature_optimization.json')))
+            hours.aggregate_consumption(file_csv[j], file_json[j], j)
+          else
+
+            file_csv[j] = File.join(@run_dir, (building_ids[j]).to_s, 'feature_reports', 'default_feature_report.csv')
+            file_json[j] = JSON.parse(File.read(File.join(@run_dir, (building_ids[j]).to_s, 'feature_reports', 'default_feature_report.json')))
+
+            hours.aggregate_consumption(file_csv[j], file_json[j], j)
+          end
+        end
+        hours.scenario_report_results
+
+        # iterating over each building to define each consumer/prosumer
+        (0..tot_buildings - 1).each do |j| # (0..20).each do |j|
+          # use building_ids lookup to get name of results directory
+          # reports will be in 'feature_reports' directory
+          if @reopt
+            # file_path = File.join(@run_dir, "#{building_ids[j]}", 'feature_reports', 'feature_optimization')
+            # prosumers.prosumer_files_load(file_path[j] + ".csv", File.read(file_path + ".json"), customers_coordinates[j], coordinates_buildings[j], hours)
+            prosumers.prosumer_files_load(file_csv[j], file_json[j], customers_coordinates[j], coordinates_buildings[j], hours)
+          else
+            # file_path = File.join(@run_dir, "#{building_ids[j]}", '014_default_feature_reports', 'default_feature_reports')
+            consumers.customer_files_load(file_csv[j], file_json[j], customers_coordinates[j], coordinates_buildings[j], hours)
+          end
+        end
+        rnm_us_catalog = URBANopt::RNM::RnmUsCatalogConversion.new(@extended_catalog_path, @run_dir, @rnm_dirname)
+        rnm_us_catalog.processing_data(utm_zone)
+        # call and create the opendss_catalog class if the user wants to convert the extended catalog into OpenDSS catalog
+        if @opendss_catalog
+          @opendss_catalog = URBANopt::RNM::ConversionToOpendssCatalog.new(@extended_catalog_path)
+          # create catalog and save to specified path
+          @opendss_catalog.create_catalog(File.join(@run_dir, 'opendss_catalog.json'))
+        end
+        # creating all the inputs files required by the RNM-US model in the folder Inputs in the RNM folder
+        File.open(File.join(@run_dir, @rnm_dirname, 'streetmapAS.txt'), 'w+') do |f|
+          f.puts(street_coordinates.map { |x| x.join(';') })
+        end
+        ficheros_entrada = []
+        if substation_location != 'nil'
+          File.open(File.join(@run_dir, @rnm_dirname, 'primary_substations.txt'), 'w+') do |f|
+            f.puts(substation_location.map { |x| x.join(';') })
+          end
+          ficheros_entrada = []
+          ficheros_entrada.push('CSubestacionDistribucionGreenfield;primary_substations.txt')
+          ficheros_entrada.push('CPuntoCallejero;streetmapAS.txt')
+          ficheros_entrada.push('END')
+          File.open(File.join(@run_dir, @rnm_dirname, 'ficheros_entrada.txt'), 'w+') do |f|
+            f.puts(ficheros_entrada)
+          end
+        else
+          puts('substation location automatically chosen by RNM-US model')
+          ficheros_entrada.push('CPuntoCallejero;streetmapAS.txt')
+          ficheros_entrada.push('END')
+          File.open(File.join(@run_dir, @rnm_dirname, 'ficheros_entrada.txt'), 'w+') do |f|
+            f.puts(ficheros_entrada)
+          end
+        end
+        ficheros_entrada_inc = []
+        if @reopt
+          File.open(File.join(@run_dir, @rnm_dirname, 'customers.txt'), 'w+') do |f|
+            f.puts(prosumers.customers.map { |x| x.join(';') })
+          end
+          File.open(File.join(@run_dir, @rnm_dirname, 'customers_ext.txt'), 'w+') do |g|
+            g.puts(prosumers.customers_ext.map { |w| w.join(';') })
+          end
+          File.open(File.join(@run_dir, @rnm_dirname, 'cust_profile_p.txt'), 'w+') do |g|
+            g.puts(prosumers.profile_customer_p.map { |w| w.join(';') })
+          end
+          File.open(File.join(@run_dir, @rnm_dirname, 'cust_profile_q.txt'), 'w+') do |g|
+            g.puts(prosumers.profile_customer_q.map { |w| w.join(';') })
+          end
+          # CSV.open(File.join(@run_dir, @rnm_dirname, "cust_profile_q_extendido.csv"), "w") do |csv|
+          #             csv << [prosumers.profile_customer_q_ext]
+          #         end
+          File.open(File.join(@run_dir, @rnm_dirname, 'cust_profile_q_extendido.txt'), 'w+') do |g|
+            g.puts(prosumers.profile_customer_q_ext.map { |w| w.join(';') })
+          end
+          File.open(File.join(@run_dir, @rnm_dirname, 'cust_profile_p_extendido.txt'), 'w+') do |g|
+            g.puts(prosumers.profile_customer_p_ext.map { |w| w.join(';') })
+          end
+          File.open(File.join(@run_dir, @rnm_dirname, 'generators.txt'), 'w+') do |g|
+            g.puts(prosumers.dg.map { |w| w.join(';') })
+          end
+          # creating profiles txt files
+          File.open(File.join(@run_dir, @rnm_dirname, 'gen_profile_p.txt'), 'w+') do |g|
+            g.puts(prosumers.dg_profile_p.map { |w| w.join(';') })
+          end
+          File.open(File.join(@run_dir, @rnm_dirname, 'gen_profile_q.txt'), 'w+') do |g|
+            g.puts(prosumers.dg_profile_q.map { |w| w.join(';') })
+          end
+          File.open(File.join(@run_dir, @rnm_dirname, 'gen_profile_q_extendido.txt'), 'w+') do |g|
+            g.puts(prosumers.profile_dg_q_extended.map { |w| w.join(';') })
+          end
+          File.open(File.join(@run_dir, @rnm_dirname, 'gen_profile_p_extendido.txt'), 'w+') do |g|
+            g.puts(prosumers.profile_dg_p_extended.map { |w| w.join(';') })
+          end
+          ficheros_entrada_inc.push('CClienteGreenfield;customers_ext.txt;cust_profile_p.txt;cust_profile_q.txt;cust_profile_p_extendido.txt;cust_profile_q_extendido.txt')
+          ficheros_entrada_inc.push('CGeneradorGreenfield;generators.txt;gen_profile_p.txt;gen_profile_q.txt;gen_profile_p_extendido.txt;gen_profile_q_extendido.txt')
+          ficheros_entrada_inc.push('END')
+          File.open(File.join(@run_dir, @rnm_dirname, 'ficheros_entrada_inc.txt'), 'w+') do |g|
+            g.puts(ficheros_entrada_inc)
+          end
+        else
+          File.open(File.join(@run_dir, @rnm_dirname, 'customers.txt'), 'w+') do |f|
+            f.puts(consumers.customers.map { |x| x.join(';') })
+          end
+          File.open(File.join(@run_dir, @rnm_dirname, 'customers_ext.txt'), 'w+') do |g|
+            g.puts(consumers.customers_ext.map { |w| w.join(';') })
+          end
+          File.open(File.join(@run_dir, @rnm_dirname, 'cust_profile_p.txt'), 'w+') do |g|
+            g.puts(consumers.profile_customer_p.map { |w| w.join(';') })
+          end
+          File.open(File.join(@run_dir, @rnm_dirname, 'cust_profile_q.txt'), 'w+') do |g|
+            g.puts(consumers.profile_customer_q.map { |w| w.join(';') })
+          end
+          File.open(File.join(@run_dir, @rnm_dirname, 'cust_profile_q_extendido.txt'), 'w+') do |g|
+            g.puts(consumers.profile_customer_q_ext.map { |w| w.join(';') })
+          end
+          File.open(File.join(@run_dir, @rnm_dirname, 'cust_profile_p_extendido.txt'), 'w+') do |g|
+            g.puts(consumers.profile_customer_p_ext.map { |w| w.join(';') })
+          end
+          ficheros_entrada_inc.push('CClienteGreenfield;customers_ext.txt;cust_profile_p.txt;cust_profile_q.txt;cust_profile_p_extendido.txt;cust_profile_q_extendido.txt')
+          ficheros_entrada_inc.push('END')
+          File.open(File.join(@run_dir, @rnm_dirname, 'ficheros_entrada_inc.txt'), 'w+') do |g|
+            g.puts(ficheros_entrada_inc)
+          end
+        end
+      end
+
+      ##
+      # Delete the RNM-US input files directory
+      ##
+      def delete
+        if Dir.exist?(File.join(@run_dir, @rnm_dirname))
+          FileUtils.rm_rf(File.join(@run_dir, @rnm_dirname))
+        end
+      end
+    end
+  end
+end