urbanopt-cli 0.5.1 → 0.6.2

data/example_files/{measures/BuildResidentialModel/resources → resources}/meta_measure.rb

@@ -1,11 +1,13 @@
+# frozen_string_literal: true
+
 # Helper methods related to having a meta-measure
 
 def get_measures(workflow_json, include_only = nil)
   result = []
-  JSON.parse(File.read(workflow_json), :symbolize_names => true).each do |group|
+  JSON.parse(File.read(workflow_json), symbolize_names: true).each do |group|
     group[:group_steps].each do |step|
       step[:measures].each do |measure_dir|
-        if (not include_only.nil?) and (not include_only.include? measure_dir)
+        if (not include_only.nil?) && (not include_only.include? measure_dir)
           next
         end
 
@@ -16,7 +18,7 @@ def get_measures(workflow_json, include_only = nil)
   return result
 end
 
-def apply_measures(measures_dir, measures, runner, model, workflow_json = nil, osw_out = nil, show_measure_calls = true)
+def apply_child_measures(measures_dir, measures, runner, model, workflow_json = nil, osw_out = nil, show_measure_calls = true)
   require 'openstudio'
 
   workflow_order = []
@@ -40,13 +42,8 @@ def apply_measures(measures_dir, measures, runner, model, workflow_json = nil, o
     # Create a workflow based on the measures we're going to call. Convenient for debugging.
     workflowJSON = OpenStudio::WorkflowJSON.new
     workflowJSON.setOswPath(File.expand_path("../#{osw_out}"))
-    workflowJSON.addMeasurePath("resources/hpxml-measures")
-
-    # pull in measure paths from primary OSW which will give accss to openstudio-model-articulation gems
-    # osw_measure_paths = runner.workflow.measurePaths
-    # osw_measure_paths.each do |orig_measure_path|
-    #   workflowJSON.addMeasurePath(orig_measure_path)
-    # end
+    workflowJSON.addMeasurePath('measures')
+    workflowJSON.addMeasurePath('resources/hpxml-measures')
     steps = OpenStudio::WorkflowStepVector.new
     workflow_order.each do |measure_subdir|
       measures[measure_subdir].each do |args|
@@ -66,7 +63,7 @@ def apply_measures(measures_dir, measures, runner, model, workflow_json = nil, o
   # Call each measure in the specified order
   workflow_order.each do |measure_subdir|
     # Gather measure arguments and call measure
-    full_measure_path = File.join(measures_dir, measure_subdir, "measure.rb")
+    full_measure_path = File.join(measures_dir, measure_subdir, 'measure.rb')
     check_file_exists(full_measure_path, runner)
     measure_instance = get_measure_instance(full_measure_path)
     measures[measure_subdir].each do |args|
@@ -85,54 +82,61 @@ def apply_measures(measures_dir, measures, runner, model, workflow_json = nil, o
 end
 
 def print_measure_call(measure_args, measure_dir, runner)
-  if measure_args.nil? or measure_dir.nil?
+  if measure_args.nil? || measure_dir.nil?
     return
   end
 
-  args_s = hash_to_string(measure_args, delim = " -> ", separator = " \n")
+  args_s = hash_to_string(measure_args, delim = ' -> ', separator = ' \n')
   if args_s.size > 0
-    runner.registerInfo("Calling #{measure_dir.to_s} measure with arguments:\n#{args_s}")
+    runner.registerInfo("Calling #{measure_dir} measure with arguments:\n#{args_s}")
   else
-    runner.registerInfo("Calling #{measure_dir.to_s} measure with no arguments.")
+    runner.registerInfo("Calling #{measure_dir} measure with no arguments.")
   end
 end
 
 def get_measure_instance(measure_rb_path)
   # Parse XML file for class name
-  require 'rexml/document'
-  require 'rexml/xpath'
-  xmldoc = REXML::Document.new(File.read(measure_rb_path.sub(".rb", ".xml")))
-  measure_class = REXML::XPath.first(xmldoc, "//measure/class_name").text
+  # Avoid REXML for performance reasons
+  measure_class = nil
+  File.readlines(measure_rb_path.sub('.rb', '.xml')).each do |xml_line|
+    next unless xml_line.include? '<class_name>'
+
+    measure_class = xml_line.gsub('<class_name>', '').gsub('</class_name>', '').strip
+    break
+  end
   # Create new instance
-  require (File.absolute_path(measure_rb_path))
+  require File.absolute_path(measure_rb_path)
   measure = eval(measure_class).new
   return measure
 end
 
 def validate_measure_args(measure_args, provided_args, lookup_file, measure_name, runner = nil)
   measure_arg_names = measure_args.map { |arg| arg.name }
-  lookup_file_str = ""
+  lookup_file_str = ''
   if not lookup_file.nil?
-    lookup_file_str = " in #{lookup_file.to_s}"
+    lookup_file_str = " in #{lookup_file}"
   end
   # Verify all arguments have been provided
   measure_args.each do |arg|
     next if provided_args.keys.include?(arg.name)
     next if not arg.required
+    next if arg.name.include?('hpxml_path')
 
-    register_error("Required argument '#{arg.name}' not provided#{lookup_file_str} for measure '#{measure_name.to_s}'.", runner)
+    register_error("Required argument '#{arg.name}' not provided#{lookup_file_str} for measure '#{measure_name}'.", runner)
   end
   provided_args.keys.each do |k|
     next if measure_arg_names.include?(k)
 
-    register_error("Extra argument '#{k}' specified#{lookup_file_str} for measure '#{measure_name.to_s}'.", runner)
+    register_error("Extra argument '#{k}' specified#{lookup_file_str} for measure '#{measure_name}'.", runner)
   end
   # Check for valid argument values
   measure_args.each do |arg|
     # Get measure provided arg
     if provided_args[arg.name].nil?
       if arg.required
-        register_error("Required argument '#{arg.name.to_s}' for measure '#{measure_name.to_s}' must have a value provided.", runner)
+        next if arg.name.include?('hpxml_path')
+
+        register_error("Required argument '#{arg.name}' for measure '#{measure_name}' must have a value provided.", runner)
       else
         next
       end
@@ -140,23 +144,23 @@ def validate_measure_args(measure_args, provided_args, lookup_file, measure_name
       provided_args[arg.name] = provided_args[arg.name].to_s
     end
     case arg.type.valueName.downcase
-    when "boolean"
+    when 'boolean'
       if not ['true', 'false'].include?(provided_args[arg.name])
-        register_error("Value of '#{provided_args[arg.name].to_s}' for argument '#{arg.name.to_s}' and measure '#{measure_name.to_s}' must be 'true' or 'false'.", runner)
+        register_error("Value of '#{provided_args[arg.name]}' for argument '#{arg.name}' and measure '#{measure_name}' must be 'true' or 'false'.", runner)
       end
-    when "double"
+    when 'double'
       if not provided_args[arg.name].is_number?
-        register_error("Value of '#{provided_args[arg.name].to_s}' for argument '#{arg.name.to_s}' and measure '#{measure_name.to_s}' must be a number.", runner)
+        register_error("Value of '#{provided_args[arg.name]}' for argument '#{arg.name}' and measure '#{measure_name}' must be a number.", runner)
       end
-    when "integer"
+    when 'integer'
       if not provided_args[arg.name].is_integer?
-        register_error("Value of '#{provided_args[arg.name].to_s}' for argument '#{arg.name.to_s}' and measure '#{measure_name.to_s}' must be an integer.", runner)
+        register_error("Value of '#{provided_args[arg.name]}' for argument '#{arg.name}' and measure '#{measure_name}' must be an integer.", runner)
       end
-    when "string"
+    when 'string'
     # no op
-    when "choice"
-      if not arg.choiceValues.include?(provided_args[arg.name]) and not arg.modelDependent
-        register_error("Value of '#{provided_args[arg.name].to_s}' for argument '#{arg.name.to_s}' and measure '#{measure_name.to_s}' must be one of: #{arg.choiceValues.to_s}.", runner)
+    when 'choice'
+      if (not arg.choiceValues.include?(provided_args[arg.name])) && (not arg.modelDependent)
+        register_error("Value of '#{provided_args[arg.name]}' for argument '#{arg.name}' and measure '#{measure_name}' must be one of: #{arg.choiceValues}.", runner)
       end
     end
   end
@@ -199,6 +203,11 @@ def run_measure(model, measure, argument_map, runner)
       runner.registerFinalCondition(result_child.finalCondition.get.logMessage)
     end
 
+    # re-register runner child registered values on the parent runner
+    result_child.stepValues.each do |step_value|
+      runner.registerValue(step_value.name, get_value_from_workflow_step_value(step_value))
+    end
+
     # log messages
     result_child.warnings.each do |warning|
       runner.registerWarning(warning.logMessage)
@@ -214,21 +223,21 @@ def run_measure(model, measure, argument_map, runner)
     end
 
     # convert a return false in the measure to a return false and error here.
-    if result_child.value.valueName == "Fail"
-      runner.registerError("The measure was not successful")
+    if result_child.value.valueName == 'Fail'
+      runner.registerError('The measure was not successful')
       return false
     end
   rescue => e
-    runner.registerError("Measure Failed with an error: #{e.inspect.to_s} at: #{e.backtrace.join("\n")}")
+    runner.registerError("Measure Failed with an error: #{e.inspect} at: #{e.backtrace.join("\n")}")
     return false
   end
   return true
 end
 
-def hash_to_string(hash, delim = "=", separator = ",")
-  hash_s = ""
+def hash_to_string(hash, delim = '=', separator = ',')
+  hash_s = ''
   hash.each do |k, v|
-    hash_s << "#{k.to_s}#{delim.to_s}#{v.to_s}#{separator.to_s}"
+    hash_s += "#{k}#{delim}#{v}#{separator}"
   end
   if hash_s.size > 0
     hash_s = hash_s.chomp(separator.to_s)
@@ -247,13 +256,13 @@ end
 
 def check_file_exists(full_path, runner = nil)
   if not File.exist?(full_path)
-    register_error("Cannot find file #{full_path.to_s}.", runner)
+    register_error("Cannot find file #{full_path}.", runner)
   end
 end
 
 def check_dir_exists(full_path, runner = nil)
   if not Dir.exist?(full_path)
-    register_error("Cannot find directory #{full_path.to_s}.", runner)
+    register_error("Cannot find directory #{full_path}.", runner)
   end
 end
 
@@ -275,7 +284,7 @@ class String
   end
 
   def is_integer?
-    if not self.is_number?
+    if not is_number?
       return false
     end
     if Integer(Float(self)).to_f != Float(self)

data/example_files/visualization/input_visualization_feature.html

@@ -387,6 +387,9 @@
         
         var endUseKeys = ['Heating:Electricity', 'Cooling:Electricity', 'InteriorLights:Electricity', 'ExteriorLights:Electricity', 'ExteriorEquipment:Electricity', 'InteriorEquipment:Electricity', 'Fans:Electricity', 'Pumps:Electricity', 'HeatRejection:Electricity', 'WaterSystems:Electricity'];
 
+        var kbtu_datasets = ['NaturalGas:Facility', 'Propane:Facility', 'FuelOilNo2:Facility', 'OtherFuels:Facility'];
+        var changeToKbtu = false;
+
         
         var applicableEndUseKeys = [];
 
@@ -449,8 +452,7 @@
 
             // monthly fuel use
             $scope.monthlyFuelChartData[feature.name] = [];
-            var changeToKbtu = false;
-            var kbtu_datasets = ['NaturalGas:Facility', 'Propane:Facility', 'FuelOilNo2:Facility', 'OtherFuels:Facility'];
+            
             // first iterate through all kbtu datasets to see if you'll need to change to kBtu units
             _.forEach(kbtu_datasets, function (kbtu_dataset) {
               var values = feature.monthly_values[kbtu_dataset];
@@ -530,29 +532,26 @@
           // monthly net use
           if(feature['complete_simulation'] == true){
             $scope.monthlyNetChartData[feature.name] = [];
-            var values = feature.monthly_values['NaturalGas:Facility'];
-            var changeToKbtu = false;
-            if (!(values.every(item => item === 0))) {
-              changeToKbtu = true
-            }
+            var unit = ' (kWh)'
             if (changeToKbtu){
-              var unit = ' (kBtu)'
-            }
-            else {
-              var unit = ' (kWh)'
+              unit = ' (kBtu)'
             }
 
             $scope.annualNetChartData[feature.name] = 0;
             $scope.monthlyNetChartData[feature.name].push({
               key: 'Net Energy Use' + unit,
               values: _.map(months, function (month, i) {
+                var value = 0;
                  if (changeToKbtu){
-                  var value = feature.monthly_values['Electricity:Facility'][i]*3.41 - feature.monthly_values['ElectricityProduced:Facility'][i]*3.41 + feature.monthly_values['NaturalGas:Facility'][i]; //Values are in kBtu
+                  value = feature.monthly_values['Electricity:Facility'][i]*3.41 - feature.monthly_values['ElectricityProduced:Facility'][i]*3.41;
+                  _.forEach(kbtu_datasets, function(ds){
+                    value += feature.monthly_values[ds][i];
+                  });
                  }
                 else {
-                  var value = feature.monthly_values['Electricity:Facility'][i] - feature.monthly_values['ElectricityProduced:Facility'][i]; //Values are in kWh
+                  value = feature.monthly_values['Electricity:Facility'][i] - feature.monthly_values['ElectricityProduced:Facility'][i]; //Values are in kWh
                 }
-                value;
+
                 $scope.annualNetChartData[feature.name] += value;
                 // global
                 monthlyNetYMin = _.min([monthlyNetYMin, value]);

data/example_files/visualization/input_visualization_scenario.html

@@ -377,6 +377,9 @@
 
         var endUseKeys = ['Heating:Electricity', 'Cooling:Electricity', 'InteriorLights:Electricity', 'ExteriorLights:Electricity', 'InteriorEquipment:Electricity', 'ExteriorEquipment:Electricity', 'Fans:Electricity', 'Pumps:Electricity', 'HeatRejection:Electricity', 'WaterSystems:Electricity'];
         
+        var kbtu_datasets = ['NaturalGas:Facility', 'Propane:Facility', 'FuelOilNo2:Facility', 'OtherFuels:Facility'];
+        var changeToKbtu = false;
+
         var applicableEndUseKeys = [];
 
         $scope.monthlyFuelChartData = {};
@@ -422,8 +425,7 @@
 
             // monthly fuel use
             $scope.monthlyFuelChartData[scenario.name] = [];
-              var changeToKbtu = false;
-              var kbtu_datasets = ['NaturalGas:Facility', 'Propane:Facility', 'FuelOilNo2:Facility', 'OtherFuels:Facility'];
+             
               // first iterate through all kbtu datasets to see if you'll need to change to kBtu units
             _.forEach(kbtu_datasets, function (kbtu_dataset) {
               var values = scenario.monthly_values[kbtu_dataset];
@@ -502,24 +504,27 @@
             if (!(values.every(item => item === 0))) {
               changeToKbtu = true
             }
+            var unit = ' (kWh)'
             if (changeToKbtu){
-              var unit = ' (kBtu)'
-            }
-            else {
-              var unit = ' (kWh)'
+              unit = ' (kBtu)'
             }
 
             $scope.annualNetChartData[scenario.name] = 0;
             $scope.monthlyNetChartData[scenario.name].push({
               key: 'Net Energy Use' + unit,
               values: _.map(months, function (month, i) {
+                var value = 0;
                 if (changeToKbtu){
-                  var value = scenario.monthly_values['Electricity:Facility'][i]*3.41 - scenario.monthly_values['ElectricityProduced:Facility'][i]*3.41 + scenario.monthly_values['NaturalGas:Facility'][i]; //Values are in kBtu
+                  value = scenario.monthly_values['Electricity:Facility'][i]*3.41 - scenario.monthly_values['ElectricityProduced:Facility'][i]*3.41 + scenario.monthly_values['NaturalGas:Facility'][i]; //Values are in kBtu
+
+                   _.forEach(kbtu_datasets, function(ds){
+                     value += scenario.monthly_values[ds][i];
+                   });
                  }
                 else {
-                  var value = scenario.monthly_values['Electricity:Facility'][i] - scenario.monthly_values['ElectricityProduced:Facility'][i]; //Values are in kWh
+                  value = scenario.monthly_values['Electricity:Facility'][i] - scenario.monthly_values['ElectricityProduced:Facility'][i]; //Values are in kWh
                 }
-                value;
+                // value;
                 $scope.annualNetChartData[scenario.name] += value;
                 monthlyNetYMin = _.min([monthlyNetYMin, value]);
                 monthlyNetYMax = _.max([monthlyNetYMax, value]);

data/lib/uo_cli.rb

@@ -1,23 +1,33 @@
 #!/usr/bin/ ruby
 
 # *********************************************************************************
-# URBANopt™, Copyright (c) 2019-2020, Alliance for Sustainable Energy, LLC, and other
+# URBANopt™, 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.
@@ -36,6 +46,7 @@ require 'urbanopt/geojson'
 require 'urbanopt/scenario'
 require 'urbanopt/reopt'
 require 'urbanopt/reopt_scenario'
+require 'urbanopt/rnm'
 require 'csv'
 require 'fileutils'
 require 'json'
@@ -49,11 +60,15 @@ module URBANopt
       COMMAND_MAP = {
         'create' => 'Make new things - project directory or files',
         'run' => 'Use files in your directory to simulate district energy use',
-        'opendss' => 'Run OpenDSS simulation',
         'process' => 'Post-process URBANopt simulations for additional insights',
         'visualize' => 'Visualize and compare results for features and scenarios',
         'validate' => 'Validate results with custom rules',
-        'delete' => 'Delete simulations for a specified scenario'
+        'opendss' => 'Run OpenDSS simulation',
+        'rnm' => 'Run RNM simulation',
+        'delete' => 'Delete simulations for a specified scenario',
+        'des_params' => 'Make a DES system parameters config file',
+        'des_create' => 'Create a Modelica model',
+        'des_run' => 'Run a Modelica DES model'
       }.freeze
 
       def initialize
@@ -77,22 +92,22 @@ module URBANopt
         end
         return if ARGV.empty?
         @command = ARGV.shift
-        send("opt_#{@command}") ## dispatch to command handling method
+        begin
+          send("opt_#{@command}") ## dispatch to command handling method
+        rescue NoMethodError
+          abort("Invalid command, please run uo --help for a list of available commands")
+        end
       end
 
       # Define creation commands
       def opt_create
-        cmd = @command
         @subopts = Optimist.options do
-          banner "\nURBANopt #{cmd}:\n \n"
+          banner "\nURBANopt #{@command}:\n \n"
 
           opt :project_folder, "\nCreate project directory in your current folder. Name the directory\n" \
           "Add additional tags to specify the method for creating geometry, or use the default urban geometry creation method to create building geometry from geojson coordinates with core and perimeter zoning\n" \
           'Example: uo create --project-folder urbanopt_example_project', type: String, short: :p
 
-          opt :electric, "\nCreate default project with FeatureFile containing electrical network\n" \
-          "Example: uo create --project-folder urbanopt_example_project --electric", short: :l
-
           opt :create_bar, "\nCreate building geometry and add space types using the create bar from building type ratios measure\n" \
           "Refer to https://docs.urbanopt.net/ for more details about the workflow\n" \
           "Used with --project-folder\n" \
@@ -107,6 +122,12 @@ module URBANopt
           "This functionality has not been exhaustively tested and currently supports the Single-Family Detached building type and the Baseline Scenario only\n" \
           "Used with --project-folder\n" \
           "Example: uo create --project-folder urbanopt_example_project --combined\n", short: :d
+          
+          opt :electric, "\nCreate default project with FeatureFile containing electrical network, used for OpenDSS analysis\n" \
+          "Example: uo create --project-folder urbanopt_example_project --electric", short: :l
+
+          opt :streets, "\nCreate default project wiht FeatureFile containing streets, used for RNM analysis\n" \
+          "Example: uo create --project-folder urbanopt_example_project --streets", short: :t
 
           opt :empty, "\nUse with --project-folder argument to create an empty project folder\n" \
           "Then add your own Feature file in the project directory you created,\n" \
@@ -135,35 +156,33 @@ module URBANopt
 
       # Define running commands
       def opt_run
-        cmd = @command
         @subopts = Optimist.options do
-          banner "\nURBANopt #{cmd}:\n \n"
+          banner "\nURBANopt #{@command}:\n \n"
 
           opt :reopt, "\nSimulate with additional REopt functionality. Must do this before post-processing with REopt"
 
           opt :scenario, "\nRun URBANopt simulations for <scenario>\n" \
           "Requires --feature also be specified\n" \
-          'Example: uo run --scenario baseline_scenario-2.csv --feature example_project.json', default: 'baseline_scenario.csv', required: true
+          'Example: uo run --scenario baseline_scenario-2.csv --feature example_project.json', default: 'baseline_scenario.csv', required: true, short: :s
 
           opt :feature, "\nRun URBANopt simulations according to <featurefile>\n" \
           "Requires --scenario also be specified\n" \
-          'Example: uo run --scenario baseline_scenario.csv --feature example_project.json', default: 'example_project.json', required: true
+          'Example: uo run --scenario baseline_scenario.csv --feature example_project.json', default: 'example_project.json', required: true, short: :f
         end
       end
 
       # Define opendss commands
       def opt_opendss
-        cmd = @command
         @subopts = Optimist.options do
-          banner "\nURBANopt #{cmd}:\n\n"
+          banner "\nURBANopt #{@command}:\n\n"
 
           opt :scenario, "\nRun OpenDSS simulations for <scenario>\n" \
           "Requires --feature also be specified\n" \
-          'Example: uo opendss --scenario baseline_scenario-2.csv --feature example_project.json', default: 'baseline_scenario.csv'
+          'Example: uo opendss --scenario baseline_scenario-2.csv --feature example_project.json', default: 'baseline_scenario.csv', required: true, short: :s
 
           opt :feature, "\nRun OpenDSS simulations according to <featurefile>\n" \
           "Requires --scenario also be specified\n" \
-          'Example: uo opendss --scenario baseline_scenario.csv --feature example_project.json', default: 'example_project_with_electric_network.json'
+          'Example: uo opendss --scenario baseline_scenario.csv --feature example_project.json', default: 'example_project_with_electric_network.json', required: true, short: :f
 
           opt :equipment, "\nRun OpenDSS simulations using <equipmentfile>. If not specified, the electrical_database.json from urbanopt-ditto-reader will be used.\n" \
           'Example: uo opendss --scenario baseline_scenario.csv --feature example_project.json', type: String, short: :e
@@ -190,11 +209,37 @@ module URBANopt
         end
       end
 
+      # Define RNM commands
+      def opt_rnm
+        @subopts = Optimist.options do
+          banner "\nURBANopt #{@command}:\n\n"
+
+          opt :scenario, "\nRun RNM simulation for <scenario>. Scenario must be run and post-processed prior to calling the rnm command.\n" \
+          "Requires --feature also be specified\n" \
+          'Example: uo rnm --scenario baseline_scenario-2.csv --feature example_project.json', default: 'baseline_scenario.csv', required: true, short: :s
+
+          opt :feature, "\nRun RNM simulation according to <featurefile>\n" \
+          "Requires --scenario also be specified\n" \
+          'Example: uo rnm --scenario baseline_scenario.csv --feature example_project.json', default: 'example_project_with_streets.json', required: true, short: :f
+
+          opt :reopt, "\nInclude processed REopt optimization results in the simulation.\n" \
+          "Example: uo rnm --scenario baseline_scenario.csv --feature example_project.json --reopt", short: :r
+
+          opt :extended_catalog, "\nUse this option to specify the extended electrical catalog path.\n" \
+          "If this option is not included, the default catalog will be used", short: :c
+
+          opt :average_peak_catalog, "\nUse this option to specify the average peak catalog path.\n" \
+          "If this option is not included, the default catalog will be used", short: :a
+
+          opt :opendss, "\n If this option is specified, an OpenDSS-compatible electrical database will be created \n" \
+          "Example: uo rnm --scenario baseline_scenario.csv --feature example_project_with_streets.json --opendss", short: :o
+        end
+      end
+
       # Define post-processing commands
       def opt_process
-        cmd = @command
         @subopts = Optimist.options do
-          banner "\nURBANopt #{cmd}:\n \n"
+          banner "\nURBANopt #{@command}:\n \n"
 
           opt :default, "\nStandard post-processing for your scenario"
 
@@ -206,23 +251,28 @@ module URBANopt
           opt :reopt_feature, "\nOptimize for each building individually with REopt\n" \
           'Example: uo process --reopt-feature'
 
+          opt :reopt_resilience, "\nInclude resilience reporting in REopt optimization\n" \
+          'Example: uo process --reopt-scenario --reopt-resilience'
+
+          opt :reopt_keep_existing, "\nKeep existing reopt feature optimizations instead of rerunning them to avoid rate limit issues.\n" \
+          'Example: uo process --reopt-feature --reopt-keep-existing', short: :k
+
           opt :with_database, "\nInclude a sql database output of post-processed results\n" \
           'Example: uo process --default --with-database'
 
-          opt :reopt_scenario_assumptions_file, "\nPath to the scenario REopt assumptions JSON file you want to use. Use with the --reopt-scenario post-processor. " \
+          opt :reopt_scenario_assumptions_file, "\nPath to the scenario REopt assumptions JSON file you want to use. Use with the --reopt-scenario post-processor.\n" \
           "If not specified, the reopt/base_assumptions.json file will be used", type: String, short: :a
 
-          opt :scenario, "\nSelect which scenario to optimize", default: 'baseline_scenario.csv', required: true
+          opt :scenario, "\nSelect which scenario to optimize", default: 'baseline_scenario.csv', required: true, short: :s
 
-          opt :feature, "\nSelect which FeatureFile to use", default: 'example_project.json', required: true
+          opt :feature, "\nSelect which FeatureFile to use", default: 'example_project.json', required: true, short: :f
         end
       end
 
       # Define visualization commands
       def opt_visualize
-        cmd = @command
         @subopts = Optimist.options do
-          banner "\nURBANopt #{cmd}:\n \n"
+          banner "\nURBANopt #{@command}:\n \n"
 
           opt :feature, "\nVisualize results for all scenarios for a feature file\n" \
             "Provide the FeatureFile to visualize each associated scenario\n" \
@@ -243,33 +293,84 @@ module URBANopt
             "Provide path to the validation_schema.yaml file in your project directory\n" \
             "Example: uo validate --eui validation_schema.yaml", type: String
 
-          opt :scenario, "\nProvide the scenario CSV file to validate features from that scenario\n", type: String, required: true
+          opt :scenario, "\nProvide the scenario CSV file to validate features from that scenario\n", type: String, required: true, short: :s
 
-          opt :feature, "\nProvide the Feature JSON file to include info about each feature\n", type: String, required: true
+          opt :feature, "\nProvide the Feature JSON file to include info about each feature\n", type: String, required: true, short: :f
 
           opt :units, "\nSI (kWh/m2/yr) or IP (kBtu/ft2/yr)", type: String, default: 'IP'
         end
       end
 
       def opt_delete
-        cmd = @command
         @subopts = Optimist.options do
-          banner "\nURBANopt #{cmd}:\n \n"
+          banner "\nURBANopt #{@command}:\n \n"
 
           opt :scenario, "\nDelete simulation files for this scenario", default: 'baseline_scenario.csv', required: true
         end
       end
 
+      def opt_des_params
+        @subopts = Optimist.options do
+          banner "\nURBANopt #{@command}:\n \n"
+
+          opt :sys_param_file, "\nBuild a system parameters JSON config file for Modelica DES simulation using URBANopt SDK outputs\n" \
+            "Provide path/name of json file to be created\n" \
+            "Example: uo des_params --sys-param-file path/to/sys_params.json", type: String, required: true, short: :y
+
+          opt :scenario, "\nPath to the scenario CSV file\n" \
+            "Example: uo des_params --sys-param-file path/to/sys_params.json --scenario path/to/baseline_scenario.csv\n", type: String, required: true, short: :s
+
+          opt :feature, "\nPath to the feature JSON file\n" \
+            "Example: uo des_params --sys-param-file path/to/sys_params.json --feature path/to/example_project.json\n", type: String, required: true, short: :f
+
+          opt :model_type, "\nSelection for which kind of DES simulation to perform\n" \
+            "Valid choices: 'time_series'", type: String, default: 'time_series'
+        end
+      end
+
+      def opt_des_create
+        @subopts = Optimist.options do
+          banner "\nURBANopt #{@command}:\n"
+          banner ""
+          opt :sys_param, "Path to system parameters config file, possibly created with 'des_params' command in this CLI\n" \
+            "Example: uo des_create --sys-param system_parameters.json\n", type: String, required: true, short: :y
+          banner ""
+          opt :feature, "Path to the feature JSON file\n" \
+            "Example: uo des_create --feature path/to/example_project.json", type: String, required: true, short: :f
+
+          opt :des_name, "\nPath to Modelica project dir to be created\n" \
+            "Example: uo des_create --des-name path/to/example_modelica_project", type: String, required: true
+
+          opt :model_type, "\nSelection for which kind of DES simulation to perform\n" \
+            "Valid choices: 'time_series'", type: String, default: 'time_series'
+        end
+      end
+
+      def opt_des_run
+        @subopts = Optimist.options do
+          banner "\nURBANopt #{@command}:\n \n"
+
+          opt :model, "\nPath to Modelica model dir, possibly created with 'des_create' command in this CLI\n" \
+            "Example: uo des_run --model path/to/model/dir", type: String, required: true
+        end
+      end
+
       attr_reader :mainopts, :command, :subopts
     end
 
     # Initialize the CLI class
     @opthash = UrbanOptCLI.new
 
-    # Pull out feature and scenario filenames and paths
-    if @opthash.subopts[:scenario_file]
-      @feature_path, @feature_name = File.split(File.expand_path(@opthash.subopts[:scenario_file]))
+    # Rescue if user only enters 'uo' without a command
+    begin
+      # Pull out feature and scenario filenames and paths
+      if @opthash.subopts[:scenario_file]
+        @feature_path, @feature_name = File.split(File.expand_path(@opthash.subopts[:scenario_file]))
+      end
+    rescue NoMethodError
+      abort("Invalid command, please run uo --help for a list of available commands")
     end
+
     # FIXME: Can this be combined with the above block? This isn't very DRY
     # One solution would be changing scenario_file to feature.
     #   Would that be confusing when creating a ScenarioFile from the FeatureFile?
@@ -281,7 +382,7 @@ module URBANopt
       @scenario_name = File.basename(@scenario_file_name, File.extname(@scenario_file_name))
     end
 
-    # Simulate energy usage as defined by ScenarioCSV\
+    # Simulate energy usage as defined by ScenarioCSV
     def self.run_func
       run_dir = File.join(@root_dir, 'run', @scenario_name.downcase)
       csv_file = File.join(@root_dir, @scenario_file_name)
@@ -312,7 +413,16 @@ module URBANopt
     # params\
     # +feature_file_path+:: _string_ Path to a FeatureFile
     def self.create_scenario_csv_file(feature_id)
-      feature_file_json = JSON.parse(File.read(File.expand_path(@opthash.subopts[:scenario_file])), symbolize_names: true)
+      begin
+        feature_file_json = JSON.parse(File.read(File.expand_path(@opthash.subopts[:scenario_file])), symbolize_names: true)
+      # Rescue if user provides path to a dir and not a file
+      rescue Errno::EISDIR => dir_error
+        wrong_path = dir_error.to_s.split(' - ')[-1]
+        abort("\nOops! '#{wrong_path}' is a directory. Please provide path to the geojson feature_file")
+        # Rescue if file isn't json
+      rescue JSON::ParserError => json_error
+        abort("\nOops! You didn't provide a json file. Please provide path to the geojson feature_file")
+      end
       Dir["#{@feature_path}/mappers/*.rb"].each do |mapper_file|
         mapper_name = File.basename(mapper_file, File.extname(mapper_file))
         scenario_file_name = if feature_id == 'SKIP'
@@ -322,20 +432,25 @@ module URBANopt
                              end
         CSV.open(File.join(@feature_path, scenario_file_name), 'wb', write_headers: true,
                                                                      headers: ['Feature Id', 'Feature Name', 'Mapper Class']) do |csv|
-          feature_file_json[:features].each do |feature|
-            if feature_id == 'SKIP'
-              # ensure that feature is a building
-              if feature[:properties][:type] == 'Building'
+          begin
+              feature_file_json[:features].each do |feature|
+              if feature_id == 'SKIP'
+                # ensure that feature is a building
+                if feature[:properties][:type] == 'Building'
+                  csv << [feature[:properties][:id], feature[:properties][:name], "URBANopt::Scenario::#{mapper_name}Mapper"]
+                end
+              elsif feature_id == feature[:properties][:id]
                 csv << [feature[:properties][:id], feature[:properties][:name], "URBANopt::Scenario::#{mapper_name}Mapper"]
-              end
-            elsif feature_id == feature[:properties][:id]
-              csv << [feature[:properties][:id], feature[:properties][:name], "URBANopt::Scenario::#{mapper_name}Mapper"]
-            elsif
-              # If Feature ID specified does not exist in the Feature File raise error
-              unless feature_file_json[:features].any? { |hash| hash[:properties][:id].include?(feature_id.to_s) }
-                abort("\nYou must provide Feature ID from FeatureFile!\n---\n\n")
+              elsif
+                # If Feature ID specified does not exist in the Feature File raise error
+                unless feature_file_json[:features].any? { |hash| hash[:properties][:id].include?(feature_id.to_s) }
+                  abort("\nYou must provide Feature ID from FeatureFile!\n---\n\n")
+                end
               end
             end
+            # Rescue if json isn't a geojson feature_file
+          rescue NoMethodError
+            abort("\nOops! You didn't provde a valid feature_file. Please provide path to the geojson feature_file")
           end
         end
       end
@@ -416,11 +531,13 @@ module URBANopt
 
             if @opthash.subopts[:electric] == true
               FileUtils.cp(File.join(path_item, 'example_project_with_electric_network.json'), dir_name)
+            elsif @opthash.subopts[:streets] == true
+              FileUtils.cp(File.join(path_item, 'example_project_with_streets.json'), dir_name)
             end
 
             if @opthash.subopts[:floorspace] == false
 
-              if @opthash.subopts[:electric] != true
+              if @opthash.subopts[:electric] != true && @opthash.subopts[:streets] != true
                 # copy feature file
                 FileUtils.cp(File.join(path_item, 'example_project.json'), dir_name)
               end
@@ -651,6 +768,7 @@ module URBANopt
       puts "\nDone\n"
     end
 
+    # Run OpenDSS simulation
     if @opthash.command == 'opendss'
 
       # first check python
@@ -720,9 +838,43 @@ module URBANopt
       begin
         system(ditto_cli_root + ditto_cli_addition)
       rescue FileNotFoundError
-        abort("\nMust post-process results before running opendss. We recommend 'process --default'." \
-        "Once opendss is run, you may then 'process --opendss'")
+        abort("\nMust post-process results before running OpenDSS. We recommend 'process --default'." \
+        "Once OpenDSS is run, you may then 'process --opendss'")
+      end
+    end
+
+    # Run RNM Simulation
+    if @opthash.command == 'rnm'
+
+      run_dir =  File.join(@root_dir, 'run', @scenario_name.downcase)
+      # check if project has been post-processed appropriately
+      if !File.exist?(File.join(run_dir, 'default_scenario_report.json'))
+        abort("\nYou must first post-process the scenario before running RNM.  We recommend 'process --default'.")
       end
+
+      puts 'Preparing RNM inputs'
+      # prep arguments
+      reopt = @opthash.subopts[:reopt] ? true : false
+      opendss_catalog = @opthash.subopts[:opendss] ? true : false
+
+      # if paths below are nil, default paths will be used
+      extended_catalog_path =  @opthash.subopts[:extended_catalog] ? @opthash.subopts[:extended_catalog] : nil 
+      average_peak_catalog_path = @opthash.subopts[:average_peak_catalog] ? @opthash.subopts[:average_peak_catalog] : nil
+
+      # create inputs, run sim and get results
+      begin
+        runner = URBANopt::RNM::Runner.new(@scenario_name, run_dir, @opthash.subopts[:scenario], @opthash.subopts[:feature], extended_catalog_path:extended_catalog_path, average_peak_catalog_path:average_peak_catalog_path, reopt:reopt, opendss_catalog:opendss_catalog)
+        runner.create_simulation_files
+        runner.run
+        runner.post_process
+      rescue => error
+        abort("\nError: #{error.message}")
+      end
+
+      # TODO: aggregate back into scenario reports and geojson file
+      puts "\nRNM Results saved to: #{File.join(run_dir, 'rnm-us', 'results')}"
+      puts "\nDone\n"
+
     end
 
     # Post-process the scenario
@@ -740,7 +892,7 @@ module URBANopt
 
       default_post_processor = URBANopt::Scenario::ScenarioDefaultPostProcessor.new(run_func)
       scenario_report = default_post_processor.run
-      scenario_report.save
+      scenario_report.save(file_name = 'default_scenario_report', save_feature_reports = false)
       scenario_report.feature_reports.each(&:save)
 
       if @opthash.subopts[:with_database] == true
@@ -752,7 +904,7 @@ module URBANopt
         results << { "process_type": 'default', "status": 'Complete', "timestamp": Time.now.strftime('%Y-%m-%dT%k:%M:%S.%L') }
       elsif @opthash.subopts[:opendss] == true
         puts "\nPost-processing OpenDSS results\n"
-        opendss_folder = File.join(@root_dir, 'run', @scenario_name, 'opendss')
+        opendss_folder = File.join(@root_dir, 'run', @scenario_name.downcase, 'opendss')
         if File.directory?(opendss_folder)
           opendss_folder_name = File.basename(opendss_folder)
           opendss_post_processor = URBANopt::Scenario::OpenDSSPostProcessor.new(scenario_report, opendss_results_dir_name = opendss_folder_name)
@@ -771,15 +923,30 @@ module URBANopt
           scenario_assumptions = File.expand_path(@opthash.subopts[:reopt_scenario_assumptions_file]).to_s
         end
         puts "\nRunning the REopt Scenario post-processor with scenario assumptions file: #{scenario_assumptions}\n"
-        reopt_post_processor = URBANopt::REopt::REoptPostProcessor.new(scenario_report, scenario_assumptions, scenario_base.reopt_feature_assumptions, DEVELOPER_NREL_KEY)
+        reopt_post_processor = URBANopt::REopt::REoptPostProcessor.new(
+          scenario_report,
+          scenario_assumptions,
+          scenario_base.reopt_feature_assumptions,
+          DEVELOPER_NREL_KEY
+        )
         if @opthash.subopts[:reopt_scenario] == true
           puts "\nPost-processing entire scenario with REopt\n"
-          scenario_report_scenario = reopt_post_processor.run_scenario_report(scenario_report: scenario_report, save_name: 'scenario_optimization')
+          scenario_report_scenario = reopt_post_processor.run_scenario_report(
+            scenario_report: scenario_report,
+            save_name: 'scenario_optimization',
+            run_resilience: @opthash.subopts[:reopt_resilience]
+          )
           results << { "process_type": 'reopt_scenario', "status": 'Complete', "timestamp": Time.now.strftime('%Y-%m-%dT%k:%M:%S.%L') }
           puts "\nDone\n"
         elsif @opthash.subopts[:reopt_feature] == true
           puts "\nPost-processing each building individually with REopt\n"
-          scenario_report_features = reopt_post_processor.run_scenario_report_features(scenario_report: scenario_report, save_names_feature_reports: ['feature_optimization'] * scenario_report.feature_reports.length, save_name_scenario_report: 'feature_optimization')
+            scenario_report_features = reopt_post_processor.run_scenario_report_features(
+              scenario_report: scenario_report,
+              save_names_feature_reports: ['feature_optimization'] * scenario_report.feature_reports.length,
+              save_name_scenario_report: 'feature_optimization',
+              run_resilience: @opthash.subopts[:reopt_resilience],
+              keep_existing_output: @opthash.subopts[:reopt_keep_existing]
+            )
           results << { "process_type": 'reopt_feature', "status": 'Complete', "timestamp": Time.now.strftime('%Y-%m-%dT%k:%M:%S.%L') }
           puts "\nDone\n"
         end
@@ -867,7 +1034,7 @@ module URBANopt
               end
             end
           end
-          html_out_path = File.join(@root_dir, 'run', @scenario_name, 'feature_comparison.html')
+          html_out_path = File.join(@root_dir, 'run', @scenario_name.downcase, 'feature_comparison.html')
           FileUtils.cp(html_in_path, html_out_path)
           puts "\nDone\n"
         end
@@ -889,8 +1056,8 @@ module URBANopt
         feature_ids = CSV.read(@opthash.subopts[:scenario], headers: true)
         feature_list = []
         feature_ids['Feature Id'].each do |feature|
-          if Dir.exist?(File.join(@root_dir, 'run', @scenario_name, feature))
-            feature_list << File.join(@root_dir, 'run', @scenario_name, feature)
+          if Dir.exist?(File.join(@root_dir, 'run', @scenario_name.downcase, feature))
+            feature_list << File.join(@root_dir, 'run', @scenario_name.downcase, feature)
           else
             puts "Warning: did not find a directory for FeatureID: #{feature} ...skipping"
           end
@@ -931,6 +1098,72 @@ module URBANopt
       end
     end
 
+    if @opthash.command == 'des_params'
+      # We're calling the python cli that gets installed when the user pip installs geojson-modelica-reader.
+      # If geojson-modelica-reader is installed into a venv (recommended), that venv must be activated when this command is called.
+      des_cli_root = "uo_des build-sys-param"
+      if @opthash.subopts[:sys_param_file]
+        des_cli_addition = " #{@opthash.subopts[:sys_param_file]}"
+        if @opthash.subopts[:scenario]
+          des_cli_addition += " #{@opthash.subopts[:scenario]}"
+        end
+        if @opthash.subopts[:feature]
+          des_cli_addition += " #{@opthash.subopts[:feature]}"
+        end
+        if @opthash.subopts[:model_type]
+          des_cli_addition += " #{@opthash.subopts[:model_type]}"
+        end
+      else
+        abort("\nCommand must include new system parameter file name, ScenarioFile, & FeatureFile. Please try again")
+      end
+      begin
+        system(des_cli_root + des_cli_addition)
+      rescue FileNotFoundError
+        abort("\nMust simulate using 'uo run' before preparing Modelica models.")
+      end
+    end
+
+    if @opthash.command == 'des_create'
+      # We're calling the python cli that gets installed when the user pip installs geojson-modelica-reader.
+      # If geojson-modelica-reader is installed into a venv (recommended), that venv must be activated when this command is called.
+      des_cli_root = "uo_des create-model"
+      if @opthash.subopts[:sys_param]
+        des_cli_addition = " #{@opthash.subopts[:sys_param]}"
+        if @opthash.subopts[:feature]
+          des_cli_addition += " #{@opthash.subopts[:feature]}"
+        end
+        if @opthash.subopts[:des_name]
+          des_cli_addition += " #{File.expand_path(@opthash.subopts[:des_name])}"
+        end
+        if @opthash.subopts[:model_type]
+          des_cli_addition += " #{@opthash.subopts[:model_type]}"
+        end
+      else
+        abort("\nCommand must include system parameter file name, FeatureFile, and model name. Please try again")
+      end
+      begin
+        system(des_cli_root + des_cli_addition)
+      rescue FileNotFoundError
+        abort("\nMust simulate using 'uo run' before preparing Modelica models.")
+      end
+    end
+
+    if @opthash.command == 'des_run'
+      # We're calling the python cli that gets installed when the user pip installs geojson-modelica-reader.
+      # If geojson-modelica-reader is installed into a venv (recommended), that venv must be activated when this command is called.
+      des_cli_root = "uo_des run-model"
+      if @opthash.subopts[:model]
+        des_cli_addition = " #{File.expand_path(@opthash.subopts[:model])}"
+      else
+        abort("\nCommand must include Modelica model name. Please try again")
+      end
+      begin
+        system(des_cli_root + des_cli_addition)
+      rescue FileNotFoundError
+        abort("\nMust simulate using 'uo run' before preparing Modelica models.")
+      end
+    end
+
     # Delete simulations from a scenario
     if @opthash.command == 'delete'
       scenario_results_dir = File.join(@root_dir, 'run', @scenario_name.downcase)