urbanopt-cli 0.4.1 → 0.6.1

data/example_files/visualization/input_visualization_scenario.html

@@ -182,8 +182,8 @@
                         <md-card-title-text>
                             <span class="md-headline">{{ scenario.name }}</span>
                             <span class="md-subhead">Annual Net Energy - {{
-                            annualNetChartData[scenario.name] }} (kWh)</span>
-                            <span class="md-subhead">Monthly Net Energy (kWh)</span>
+                            annualNetChartData[scenario.name] }} </span>
+                            <span class="md-subhead">Monthly Net Energy </span>
                             <span ng-if="scenario.complete_simulation!=true" class="md-subhead error">{{errorText}}</span>
                         </md-card-title-text>
                     </md-card-title>
@@ -229,7 +229,7 @@
         $scope.monthlyFuelChartOptions = {
           chart: {
             type: 'multiBarChart',
-            color: ['#187C7C', '#8CC025', '#CE2828'],
+            color: ['#187C7C', '#8CC025', '#CE2828', '#AFECE7', '#F19953'],
             height: 320,
             margin: {
               top: 45,
@@ -373,9 +373,9 @@
 
         var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
         
-        var datasets = ['Electricity:Facility', 'ElectricityProduced:Facility', 'Gas:Facility'];
+        var datasets = ['Electricity:Facility', 'ElectricityProduced:Facility', 'NaturalGas:Facility', 'Propane:Facility', 'FuelOilNo2:Facility', 'OtherFuels:Facility'];
 
-        var endUseKeys = ['Heating:Electricity', 'Cooling:Electricity', 'InteriorLights:Electricity', 'ExteriorLights:Electricity', 'InteriorEquipment:Electricity', 'Fans:Electricity', 'Pumps:Electricity', 'HeatRejection:Electricity', 'WaterSystems:Electricity'];
+        var endUseKeys = ['Heating:Electricity', 'Cooling:Electricity', 'InteriorLights:Electricity', 'ExteriorLights:Electricity', 'InteriorEquipment:Electricity', 'ExteriorEquipment:Electricity', 'Fans:Electricity', 'Pumps:Electricity', 'HeatRejection:Electricity', 'WaterSystems:Electricity'];
         
         var applicableEndUseKeys = [];
 
@@ -419,44 +419,106 @@
         _.forEach($scope.scenarios, function (scenario) {
 
           if(scenario['complete_simulation'] == true){
+
             // 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];
+              if (!(values.every(item => item === 0))) {
+                changeToKbtu = true;
+              }
+            });
+
             _.forEach(datasets, function (dataset) {
+              
               var values = scenario.monthly_values[dataset];
+              var datasetUnit = "";
 
               if (dataset == 'Electricity:Facility') {
-                var datasetUnit = 'Electricity:Facility(kWh)';
-                } else if (dataset == 'ElectricityProduced:Facility') {
-                  var datasetUnit = 'ElectricityProduced:Facility(kWh)'
-                } else if (dataset == 'Gas:Facility') {
-                  var datasetUnit = 'Gas:Facility(kBtu)'
-                };
-
-              $scope.monthlyFuelChartData[scenario.name].push({
-                key: datasetUnit,
-                values: _.map(values, function (value, i) {
-                  value;
-                  monthlyFuelYMax = _.max([monthlyFuelYMax, value]);
-                  return {
-                    x: months[i],
-                    y: value
-                  };
-                })
-              });
+                // first check if there is data to include
+                if (!(values.every(item => item === 0))) {
+                  console.log(changeToKbtu);
+                  if (changeToKbtu) {
+                    var kBtuValues = [];
+                    var kwhValues = scenario.monthly_values[dataset]
+                    _.forEach(kwhValues, function (kwhValue) {
+                      new_value = kwhValue*3.4121416; //convert kwh to kbtu
+                      kBtuValues.push(new_value);
+                    })
+                    values = kBtuValues;
+                    datasetUnit = 'Electricity:Facility(kBtu)';
+                  } else {
+                    datasetUnit = 'Electricity:Facility(kWh)';
+                  }
+                }
+              } else if (dataset == 'ElectricityProduced:Facility') {
+                // first check if there is data to include
+                if (!(values.every(item => item === 0))) {
+                  if (changeToKbtu) {
+                    var kBtuValues = [];
+                    var kwhValues = scenario.monthly_values[dataset];
+                    _.forEach(kwhValues, function (kwhValue) {
+                      new_value = kwhValue*3.4121416; //convert kwh to kbtu
+                      kBtuValues.push(new_value);
+                    })
+                    values = kBtuValues;
+                    datasetUnit = 'ElectricityProduced:Facility(kBtu)';
+
+                  } else {
+                    datasetUnit = 'ElectricityProduced:Facility(kWh)'
+                  }
+                }
+              } else {
+                // everything else gets kBtu for now
+                if (!(values.every(item => item === 0))) {
+                  datasetUnit = dataset + '(kBtu)';
+                }
+              };
+              // if datasetUnit is empty string, there is no data so don't push it in the array
+              if (datasetUnit != ""){
+                $scope.monthlyFuelChartData[scenario.name].push({
+                  key: datasetUnit,
+                  values: _.map(values, function (value, i) {
+                    value;
+                    monthlyFuelYMax = _.max([monthlyFuelYMax, value]);
+                    return {
+                      x: months[i],
+                      y: value
+                    };
+                  })
+                });
+              }
             });
-            $scope.monthlyFuelChartOptions.chart['yDomain'] = [0, _.round(monthlyFuelYMax)];
           }
 
           // monthly net use
-          
           if(scenario['complete_simulation'] == true){
             $scope.monthlyNetChartData[scenario.name] = [];
+            var values = scenario.monthly_values['NaturalGas:Facility'];
+            var changeToKbtu = false;
+            if (!(values.every(item => item === 0))) {
+              changeToKbtu = true
+            }
+            if (changeToKbtu){
+              var unit = ' (kBtu)'
+            }
+            else {
+              var unit = ' (kWh)'
+            }
+
             $scope.annualNetChartData[scenario.name] = 0;
             $scope.monthlyNetChartData[scenario.name].push({
-              key: 'Net Energy Use',
+              key: 'Net Energy Use' + unit,
               values: _.map(months, function (month, i) {
-
-                var value = scenario.monthly_values['Electricity:Facility'][i] - scenario.monthly_values['ElectricityProduced:Facility'][i] + (scenario.monthly_values['Gas:Facility'][i]*0.293); //kBtu to kWh
+                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
+                 }
+                else {
+                  var value = scenario.monthly_values['Electricity:Facility'][i] - scenario.monthly_values['ElectricityProduced:Facility'][i]; //Values are in kWh
+                }
                 value;
                 $scope.annualNetChartData[scenario.name] += value;
                 monthlyNetYMin = _.min([monthlyNetYMin, value]);
@@ -488,7 +550,7 @@
               }]
             });
           });
-          $scope.annualEndUseChartOptions.chart['yDomain'] = [0, _.round(1.1 * annualTotalYMax)];
+          $scope.annualEndUseChartOptions.chart['yDomain'] = [0, _.round(annualTotalYMax)];
         
           }
         });
@@ -502,4 +564,4 @@
     </script>
 
 </body>
-</html>
+</html>

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.
@@ -41,9 +51,7 @@ require 'fileutils'
 require 'json'
 require 'openssl'
 require 'open3'
-require_relative '../developer_nrel_key'
-require 'pycall/import'
-include PyCall::Import
+require 'yaml'
 
 module URBANopt
   module CLI
@@ -54,7 +62,11 @@ module URBANopt
         'opendss' => 'Run OpenDSS simulation',
         'process' => 'Post-process URBANopt simulations for additional insights',
         'visualize' => 'Visualize and compare results for features and scenarios',
-        'delete' => 'Delete simulations for a specified scenario'
+        'validate' => 'Validate results with custom rules',
+        '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
@@ -78,19 +90,25 @@ 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 tag 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" \
+          "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" \
@@ -133,73 +151,96 @@ 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', required: true
+          'Example: uo opendss --scenario baseline_scenario-2.csv --feature example_project.json', default: 'baseline_scenario.csv', 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.json', required: true
+          'Example: uo opendss --scenario baseline_scenario.csv --feature example_project.json', default: 'example_project_with_electric_network.json', 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'
+          'Example: uo opendss --scenario baseline_scenario.csv --feature example_project.json', type: String, short: :e
+
+          opt :timestep, "\nNumber of minutes per timestep in the OpenDSS simulation.\n" \
+          "Optional, defaults to analog of simulation timestep set in the FeatureFile\n" \
+          "Example: uo opendss --scenario baseline_scenario.csv --feature example_project.json --timestep 15", type: Integer, short: :t
+
+          opt :start_time, "\nBeginning of the period for OpenDSS analysis\n" \
+          "Optional, defaults to beginning of simulation time\n" \
+          "Example: uo opendss --scenario baseline_scenario.csv --feature example_project.json --start-time '2017/01/15 01:00:00'\n" \
+          "Ensure you have quotes around the timestamp, to allow for the space between date & time.", type: String
 
-          opt :reopt, "\nRun with additional REopt functionality."
+          opt :end_time, "\nEnd of the period for OpenDSS analysis\n" \
+          "Optional, defaults to end of simulation time\n" \
+          "Example: uo opendss --scenario baseline_scenario.csv --feature example_project.json --end-time '2017/01/16 01:00:00'\n" \
+          "Ensure you have quotes around the timestamp, to allow for the space between date & time.", type: String
+
+          opt :reopt, "\nRun with additional REopt functionality.\n" \
+          "Example: uo opendss --scenario baseline_scenario.csv --feature example_project.json --reopt", short: :r
+
+          opt :config, "\nRun OpenDSS using a json config file to specify the above settings.\n" \
+          "Example: uo opendss --config path/to/config.json", type: String, short: :c
         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"
 
           opt :opendss, "\nPost-process with OpenDSS"
 
-          opt :reopt_scenario, "\nOptimize for entire scenario with REopt\n" \
+          opt :reopt_scenario, "\nOptimize for entire scenario with REopt.  Used with the --reopt-scenario-assumptions-file to specify the assumptions to use.\n" \
           'Example: uo process --reopt-scenario'
 
           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 :scenario, "\nSelect which scenario to optimize", default: 'baseline_scenario.csv', required: true
+          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, 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" \
@@ -211,39 +252,107 @@ module URBANopt
         end
       end
 
+      # Define validation commands
+      def opt_validate
+        @subopts = Optimist.options do
+          banner "\nURBANopt #{@command}:\n \n"
+
+          opt :eui, "\nCompare eui results in feature reports to limits in validation_schema.yaml\n" \
+            "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, short: :s
+
+          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.absolute_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?
     if @opthash.subopts[:feature]
-      @feature_path, @feature_name = File.split(File.absolute_path(@opthash.subopts[:feature]))
+      @feature_path, @feature_name = File.split(File.expand_path(@opthash.subopts[:feature]))
     end
     if @opthash.subopts[:scenario]
-      @root_dir, @scenario_file_name = File.split(File.absolute_path(@opthash.subopts[:scenario]))
+      @root_dir, @scenario_file_name = File.split(File.expand_path(@opthash.subopts[:scenario]))
+      @scenario_name = File.basename(@scenario_file_name, File.extname(@scenario_file_name))
     end
 
     # Simulate energy usage as defined by ScenarioCSV\
     def self.run_func
-      name = File.basename(@scenario_file_name, File.extname(@scenario_file_name))
-      run_dir = File.join(@root_dir, 'run', name.downcase)
+      run_dir = File.join(@root_dir, 'run', @scenario_name.downcase)
       csv_file = File.join(@root_dir, @scenario_file_name)
       featurefile = File.join(@root_dir, @feature_name)
       mapper_files_dir = File.join(@root_dir, 'mappers')
@@ -261,9 +370,9 @@ module URBANopt
         # TODO: Better way of grabbing assumptions file than the first file in the folder
         reopt_files_dir_contents_list = Dir.children(reopt_files_dir.to_s)
         reopt_assumptions_filename = File.basename(reopt_files_dir_contents_list[0])
-        scenario_output = URBANopt::Scenario::REoptScenarioCSV.new(name, @root_dir, run_dir, feature_file, mapper_files_dir, csv_file, num_header_rows, reopt_files_dir, reopt_assumptions_filename)
+        scenario_output = URBANopt::Scenario::REoptScenarioCSV.new(@scenario_name.downcase, @root_dir, run_dir, feature_file, mapper_files_dir, csv_file, num_header_rows, reopt_files_dir, reopt_assumptions_filename)
       else
-        scenario_output = URBANopt::Scenario::ScenarioCSV.new(name, @root_dir, run_dir, feature_file, mapper_files_dir, csv_file, num_header_rows)
+        scenario_output = URBANopt::Scenario::ScenarioCSV.new(@scenario_name.downcase, @root_dir, run_dir, feature_file, mapper_files_dir, csv_file, num_header_rows)
       end
       scenario_output
     end
@@ -272,7 +381,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.absolute_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'
@@ -282,20 +400,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
@@ -305,7 +428,7 @@ module URBANopt
     # params \
     # +existing_scenario_file+:: _string_ - Name of existing ScenarioFile
     def self.create_reopt_scenario_file(existing_scenario_file)
-      existing_path, existing_name = File.split(File.absolute_path(existing_scenario_file))
+      existing_path, existing_name = File.split(File.expand_path(existing_scenario_file))
 
       # make reopt folder
       Dir.mkdir File.join(existing_path, 'reopt')
@@ -363,6 +486,9 @@ module URBANopt
             # copy gemfile
             FileUtils.cp(File.join(path_item, 'Gemfile'), dir_name)
 
+            # copy validation schema
+            FileUtils.cp(File.join(path_item, 'validation_schema.yaml'), dir_name)
+
             # copy weather files
             weather_files = File.join(path_item, 'weather')
             Pathname.new(weather_files).children.each { |weather_file| FileUtils.cp(weather_file, File.join(dir_name, 'weather')) }
@@ -371,10 +497,16 @@ module URBANopt
             viz_files = File.join(path_item, 'visualization')
             Pathname.new(viz_files).children.each { |viz_file| FileUtils.cp(viz_file, File.join(dir_name, 'visualization')) }
 
+            if @opthash.subopts[:electric] == true
+              FileUtils.cp(File.join(path_item, 'example_project_with_electric_network.json'), dir_name)
+            end
+
             if @opthash.subopts[:floorspace] == false
 
-              # copy feature file
-              FileUtils.cp(File.join(path_item, 'example_project.json'), dir_name)
+              if @opthash.subopts[:electric] != true
+                # copy feature file
+                FileUtils.cp(File.join(path_item, 'example_project.json'), dir_name)
+              end
 
               # copy osm
               FileUtils.cp(File.join(path_item, 'osm_building/7.osm'), File.join(dir_name, 'osm_building'))
@@ -387,6 +519,7 @@ module URBANopt
                 FileUtils.cp(File.join(path_item, 'mappers/Baseline.rb'), File.join(dir_name, 'mappers'))
                 FileUtils.cp(File.join(path_item, 'mappers/HighEfficiency.rb'), File.join(dir_name, 'mappers'))
                 FileUtils.cp(File.join(path_item, 'mappers/ThermalStorage.rb'), File.join(dir_name, 'mappers'))
+                FileUtils.cp(File.join(path_item, 'mappers/EvCharging.rb'), File.join(dir_name, 'mappers'))
 
                 # copy osw file
                 FileUtils.cp(File.join(path_item, 'mappers/base_workflow.osw'), File.join(dir_name, 'mappers'))
@@ -464,7 +597,7 @@ module URBANopt
       puts 'Checking system.....'
 
       # platform agnostic
-      stdout, stderr, status = Open3.capture3('python -V')
+      stdout, stderr, status = Open3.capture3('python3 -V')
       if stderr && !stderr == ''
         # error
         results[:message] = "ERROR: #{stderr}"
@@ -473,7 +606,7 @@ module URBANopt
       end
 
       # check version
-      stdout.slice! 'Python '
+      stdout.slice! 'Python3 '
       if stdout[0].to_i == 2 || (stdout[0].to_i == 3 && stdout[2].to_i < 7)
         # global python version is not 3.7+
         results[:message] = "ERROR: Python version must be at least 3.7.  Found python with version #{stdout}."
@@ -484,7 +617,7 @@ module URBANopt
       end
 
       # check pip
-      stdout, stderr, status = Open3.capture3('pip -V')
+      stdout, stderr, status = Open3.capture3('pip3 -V')
       if stderr && !stderr == ''
         # error
         results[:message] = "ERROR finding pip: #{stderr}"
@@ -503,9 +636,9 @@ module URBANopt
     def self.check_reader
       results = { reader: false, message: '' }
 
-      puts 'Checking for UrbanoptDittoReader...'
+      puts 'Checking for urbanopt-ditto-reader...'
 
-      stdout, stderr, status = Open3.capture3('pip list')
+      stdout, stderr, status = Open3.capture3('pip3 list')
       if stderr && !stderr == ''
         # error
         results[:message] = 'ERROR running pip list'
@@ -513,25 +646,25 @@ module URBANopt
         return results
       end
 
-      res = /^UrbanoptDittoReader.*$/.match(stdout)
+      res = /^urbanopt-ditto-reader.*$/.match(stdout)
       if res
         # extract version
         version = /\d+.\d+.\d+/.match(res.to_s)
         path = res.to_s.split(' ')[-1]
         puts "...path: #{path}"
         if version
-          results[:message] = "Found UrbanoptDittoReader version #{version}"
+          results[:message] = "Found urbanopt-ditto-reader version #{version}"
           puts "...#{results[:message]}"
           results[:reader] = true
-          puts "UrbanoptDittoReader check done. \n\n"
+          puts "urbanopt-ditto-reader check done. \n\n"
           return results
         else
-          results[:message] = 'UrbanoptDittoReader version not found.'
+          results[:message] = 'urbanopt-ditto-reader version not found.'
           return results
         end
       else
         # no ditto reader
-        results[:message] = 'UrbanoptDittoReader not found.'
+        results[:message] = 'urbanopt-ditto-reader not found.'
         return results
       end
     end
@@ -593,10 +726,7 @@ module URBANopt
     # Run simulations
     if @opthash.command == 'run' && @opthash.subopts[:scenario] && @opthash.subopts[:feature]
       if @opthash.subopts[:scenario].to_s.include? '-'
-        @scenario_folder = @scenario_file_name.split(/\W+/)[0].capitalize.to_s
         @feature_id = (@feature_name.split(/\W+/)[1]).to_s
-      else
-        @scenario_folder = @scenario_file_name.split('.')[0].capitalize.to_s
       end
       puts "\nSimulating features of '#{@feature_name}' as directed by '#{@scenario_file_name}'...\n\n"
       scenario_runner = URBANopt::Scenario::ScenarioRunnerOSW.new
@@ -617,54 +747,65 @@ module URBANopt
       res = check_reader
       if res[:reader] == false
         puts "\nURBANopt ditto reader error: #{res[:message]}"
-        abort("\nYou must install urbanopt-ditto-reader to use this workflow: https://github.com/urbanopt/urbanopt-ditto-reader \n")
+        abort("\nYou must install urbanopt-ditto-reader to use this workflow: pip install urbanopt-ditto-reader \n")
       end
 
-      name = File.basename(@scenario_file_name, File.extname(@scenario_file_name))
-      run_dir = File.join(@root_dir, 'run', name.downcase)
-      featurefile = File.join(@root_dir, @feature_name)
+      # If a config file is supplied, use the data specified there.
+      if @opthash.subopts[:config]
+        opendss_config = JSON.parse(File.read(File.expand_path(@opthash.subopts[:config])), symbolize_names: true)
+        config_scenario_file = opendss_config[:urbanopt_scenario_file]
+        config_root_dir = File.dirname(config_scenario_file)
+        config_scenario_name = File.basename(config_scenario_file, File.extname(config_scenario_file))
+        run_dir = File.join(config_root_dir, 'run', config_scenario_name.downcase)
+        featurefile = File.expand_path(opendss_config[:urbanopt_geojson_file])
+        # Otherwise use the user-supplied scenario & feature files
+      elsif @opthash.subopts[:scenario] && @opthash.subopts[:feature]
+        run_dir = File.join(@root_dir, 'run', @scenario_name.downcase)
+        featurefile = File.join(@root_dir, @feature_name)
+      end
 
       # Ensure building simulations have been run already
       begin
-        feature_list = Pathname.new(run_dir).children.select(&:directory?)
-        first_feature = File.basename(feature_list[0])
-        if !File.exist?(File.join(run_dir, first_feature, 'eplusout.sql'))
-          abort("\nERROR: URBANopt simulations are required before using opendss. Please run and process simulations, then try again.\n")
+        feature_list = Pathname.new(File.expand_path(run_dir)).children.select(&:directory?)
+        some_random_feature = File.basename(feature_list[0])
+        if !File.exist?(File.expand_path(File.join(run_dir, some_random_feature, 'eplusout.sql')))
+          abort("ERROR: URBANopt simulations are required before using opendss. Please run and process simulations, then try again.\n")
         end
       rescue Errno::ENOENT # Same abort message if there is no run_dir
-        abort("\nERROR: URBANopt simulations are required before using opendss. Please run and process simulations, then try again.\n")
+        abort("ERROR: URBANopt simulations are required before using opendss. Please run and process simulations, then try again.\n")
       end
 
-      # TODO: make this work for virtualenv
-      # TODO: document adding PYTHON env var
-
-      # create config hash
-      config = {}
-
-      config['use_reopt'] = @opthash.subopts[:reopt] == true
-      config['urbanopt_scenario'] = run_dir
-      config['geojson_file'] = featurefile
-      if @opthash.subopts[:equipment]
-        config['equipment_file'] = @opthash.subopts[:equipment].to_s
+      # We're calling the python cli that gets installed when the user installs ditto-reader.
+      # If ditto-reader is installed into a venv (recommended), that venv must be activated when this command is called.
+      ditto_cli_root = "ditto_reader_cli run-opendss "
+      if @opthash.subopts[:config]
+        ditto_cli_addition = "--config #{@opthash.subopts[:config]}"
+      elsif @opthash.subopts[:scenario] && @opthash.subopts[:feature]
+        ditto_cli_addition = "--scenario_file #{@opthash.subopts[:scenario]} --feature_file #{@opthash.subopts[:feature]}"
+        if @opthash.subopts[:reopt]
+          ditto_cli_addition += " --reopt"
+        end
+        if @opthash.subopts[:equipment]
+          ditto_cli_addition += " --equipment #{@opthash.subopts[:equipment]}"
+        end
+        if @opthash.subopts[:timestep]
+          ditto_cli_addition += " --timestep #{@opthash.subopts[:timestep]}"
+        end
+        if @opthash.subopts[:start_time]
+          ditto_cli_addition += " --start_time '#{@opthash.subopts[:start_time]}'"
+        end
+        if @opthash.subopts[:end_time]
+          ditto_cli_addition += " --end_time '#{@opthash.subopts[:end_time]}'"
+        end
+      else
+        abort("\nCommand must include ScenarioFile & FeatureFile, or a config file that specifies both. Please try again")
       end
-      config['opendss_folder'] = File.join(config['urbanopt_scenario'], 'opendss')
-
-      # TODO: allow users to specify ditto install location?
-      # Currently using ditto within the urbanopt-ditto-reader install
-
-      # run ditto_reader
-      pyfrom 'urbanopt_ditto_reader', import: 'UrbanoptDittoReader'
-
       begin
-        pconf = PyCall::Dict.new(config)
-        r = UrbanoptDittoReader.new(pconf)
-        r.run
-      rescue StandardError => e
-        abort("\nOpenDSS run did not complete successfully: #{e.message}")
+        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'")
       end
-
-      puts "\nDone. Results located in #{config['opendss_folder']}\n"
-
     end
 
     # Post-process the scenario
@@ -676,16 +817,14 @@ module URBANopt
       puts 'Post-processing URBANopt results'
 
       # delete process_status.json
-      process_filename = File.join(@root_dir, 'run', @scenario_file_name.split('.')[0].downcase, 'process_status.json')
+      process_filename = File.join(@root_dir, 'run', @scenario_name.downcase, 'process_status.json')
       FileUtils.rm_rf(process_filename) if File.exist?(process_filename)
       results = []
 
-      @scenario_folder = @scenario_file_name.split('.')[0].capitalize.to_s
       default_post_processor = URBANopt::Scenario::ScenarioDefaultPostProcessor.new(run_func)
       scenario_report = default_post_processor.run
-      scenario_report.save
-      scenario_report.feature_reports.each(&:save_json_report)
-      scenario_report.feature_reports.each(&:save_csv_report)
+      scenario_report.save(file_name = 'default_scenario_report', save_feature_reports = false)
+      scenario_report.feature_reports.each(&:save)
 
       if @opthash.subopts[:with_database] == true
         default_post_processor.create_scenario_db_file
@@ -696,7 +835,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_file_name.split('.')[0], 'opendss')
+        opendss_folder = File.join(@root_dir, 'run', @scenario_name, '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)
@@ -709,15 +848,36 @@ module URBANopt
         end
       elsif (@opthash.subopts[:reopt_scenario] == true) || (@opthash.subopts[:reopt_feature] == true)
         scenario_base = default_post_processor.scenario_base
-        reopt_post_processor = URBANopt::REopt::REoptPostProcessor.new(scenario_report, scenario_base.scenario_reopt_assumptions_file, scenario_base.reopt_feature_assumptions, DEVELOPER_NREL_KEY)
+        # see if reopt-scenario-assumptions-file was passed in, otherwise use the default
+        scenario_assumptions = scenario_base.scenario_reopt_assumptions_file
+        if (@opthash.subopts[:reopt_scenario] == true && @opthash.subopts[:reopt_scenario_assumptions_file])
+          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
+        )
         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
@@ -738,7 +898,6 @@ module URBANopt
         if !@opthash.subopts[:feature].to_s.include? (".json")
           abort("\nERROR: No Feature File specified. Please specify Feature File for creating scenario visualizations.\n")
         end
-        @feature_path = File.split(File.absolute_path(@opthash.subopts[:feature]))[0]
         run_dir = File.join(@feature_path, 'run')
         scenario_folders = []
         scenario_report_exists = false
@@ -766,7 +925,7 @@ module URBANopt
               end
             end
           end
-          html_out_path = File.join(@feature_path, '/run/scenario_comparison.html')
+          html_out_path = File.join(@feature_path, 'run', 'scenario_comparison.html')
           FileUtils.cp(html_in_path, html_out_path)
           puts "\nDone\n"
         end
@@ -776,14 +935,13 @@ module URBANopt
         if !@opthash.subopts[:scenario].to_s.include? (".csv")
           abort("\nERROR: No Scenario File specified. Please specify Scenario File for feature visualizations.\n")
         end
-        @root_dir, @scenario_file_name = File.split(File.absolute_path(@opthash.subopts[:scenario]))
-        name = File.basename(@scenario_file_name, File.extname(@scenario_file_name))
-        run_dir = File.join(@root_dir, 'run', name.downcase)
+        run_dir = File.join(@root_dir, 'run', @scenario_name.downcase)
         feature_report_exists = false
-        feature_id = CSV.read(File.absolute_path(@opthash.subopts[:scenario]), headers: true)
+        csv = CSV.read(File.expand_path(@opthash.subopts[:scenario]), headers: true)
+        feature_names = csv['Feature Name']
         feature_folders = []
         # loop through building feature ids from scenario csv
-        feature_id['Feature Id'].each do |feature|
+        csv['Feature Id'].each do |feature|
           feature_report = File.join(run_dir, feature, 'feature_reports')
           if File.exist?(feature_report)
             feature_report_exists = true
@@ -794,7 +952,7 @@ module URBANopt
         end
         if feature_report_exists == true
           puts "\nCreating visualizations for Feature results in the Scenario\n"
-          URBANopt::Scenario::ResultVisualization.create_visualization(feature_folders, true)
+          URBANopt::Scenario::ResultVisualization.create_visualization(feature_folders, true, feature_names)
           vis_file_path = File.join(@root_dir, 'visualization')
           if !File.exist?(vis_file_path)
             Dir.mkdir File.join(@root_dir, 'visualization')
@@ -807,7 +965,7 @@ module URBANopt
               end
             end
           end
-          html_out_path = File.join(@root_dir, 'run', name, 'feature_comparison.html')
+          html_out_path = File.join(@root_dir, 'run', @scenario_name, 'feature_comparison.html')
           FileUtils.cp(html_in_path, html_out_path)
           puts "\nDone\n"
         end
@@ -815,12 +973,132 @@ module URBANopt
 
     end
 
+    # Compare EUI in default_feature_reports.json with a user-editable set of bounds
+    if @opthash.command == 'validate'
+      puts "\nValidating:"
+      if !@opthash.subopts[:eui] && !@opthash.subopts[:foobar]
+        abort("\nERROR: No type of validation specified. Please enter a sub-command when using validate.\n")
+      end
+      # Validate EUI
+      if @opthash.subopts[:eui]
+        puts "Energy Use Intensity"
+        original_feature_file = JSON.parse(File.read(File.expand_path(@opthash.subopts[:feature])), symbolize_names: true)
+        # Build list of paths to each feature in the given Scenario
+        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)
+          else
+            puts "Warning: did not find a directory for FeatureID: #{feature} ...skipping"
+          end
+        end
+        validation_file_name = File.basename(@opthash.subopts[:eui])
+        validation_params = YAML.load_file(File.expand_path(@opthash.subopts[:eui]))
+        unit_value = validation_params['EUI'][@opthash.subopts[:units]]['Units']
+        # Validate EUI for only the features used in the scenario
+        original_feature_file[:features].each do |feature| # Loop through each feature in the scenario
+          next if !feature_ids['Feature Id'].include? feature[:properties][:id] # Skip features not in the scenario
+          feature_list.each do |feature_path| # Match ids in FeatureFile
+            next if feature_path.split('/')[-1] != feature[:properties][:id] # Skip until feature ids match
+            feature_dir_list = Pathname.new(feature_path).children.select(&:directory?) # Folders in the feature directory
+            feature_dir_list.each do |feature_dir|
+              next if !File.basename(feature_dir).include? "default_feature_reports" # Get the folder which can have a variable name
+              @json_feature_report = JSON.parse(File.read(File.join(feature_dir, 'default_feature_reports.json')), symbolize_names: true)
+            end
+            if !@json_feature_report[:reporting_periods][0][:site_EUI_kbtu_per_ft2]
+              abort("ERROR: No EUI present. Perhaps you didn't simulate an entire year?")
+            end
+            if @opthash.subopts[:units] == 'IP'
+              feature_eui_value = @json_feature_report[:reporting_periods][0][:site_EUI_kbtu_per_ft2]
+            elsif @opthash.subopts[:units] == 'SI'
+              feature_eui_value = @json_feature_report[:reporting_periods][0][:site_EUI_kwh_per_m2]
+            else
+              abort("\nERROR: Units type not recognized. Please use a valid option in the CLI")
+            end
+            building_type = feature[:properties][:building_type] # From FeatureFile
+            if feature_eui_value > validation_params['EUI'][@opthash.subopts[:units]][building_type]['max']
+              puts "\nFeature #{File.basename(feature_path)} EUI of #{feature_eui_value.round(2)} #{unit_value} is greater than the validation maximum."
+            elsif feature_eui_value < validation_params['EUI'][@opthash.subopts[:units]][building_type]['min']
+              puts "\nFeature #{File.basename(feature_path)} EUI of #{feature_eui_value.round(2)} #{unit_value} is less than the validation minimum."
+            else
+              puts "\nFeature #{File.basename(feature_path)} EUI of #{feature_eui_value.round(2)} #{unit_value} is within bounds set by #{validation_file_name}."
+            end
+          end
+        end
+      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_name = @scenario_file_name.split('.')[0]
-      scenario_path = File.absolute_path(@root_dir)
-      scenario_results_dir = File.join(scenario_path, 'run', scenario_name)
-      puts "\nDeleting previous results from '#{@scenario_file_name}'...\n"
+      scenario_results_dir = File.join(@root_dir, 'run', @scenario_name.downcase)
+      puts "\nDeleting previous results from '#{@scenario_name}'...\n"
       FileUtils.rm_rf(scenario_results_dir)
       puts "\nDone\n"
     end