urbanopt-cli 0.2.0 → 0.3.0

data/example_files/mappers/HighEfficiency.rb

@@ -1,3 +1,4 @@
+
 # *********************************************************************************
 # URBANopt, Copyright (c) 2019-2020, Alliance for Sustainable Energy, LLC, and other
 # contributors. All rights reserved.
@@ -51,7 +52,7 @@ module URBANopt
         OpenStudio::Extension.set_measure_argument(osw, 'ReduceLightingLoadsByPercentage', '__SKIP__', false)
         OpenStudio::Extension.set_measure_argument(osw, 'ReduceLightingLoadsByPercentage', 'lighting_power_reduction_percent', 10)
 
-        osw
+        return osw
       end
     end
   end

data/lib/uo_cli.rb

@@ -31,7 +31,7 @@
 # *********************************************************************************
 
 require 'uo_cli/version'
-require 'optparse'
+require 'optimist'
 require 'urbanopt/geojson'
 require 'urbanopt/scenario'
 require 'urbanopt/reopt'
@@ -43,101 +43,145 @@ require_relative '../developer_nrel_key'
 
 module URBANopt
   module CLI
-    # Set up user interface
-    @user_input = {}
-    the_parser = OptionParser.new do |opts|
-      opts.banner = "Usage: uo [-peomrgdsfitv]\n" \
-                    "\n" \
-                    "URBANopt CLI\n" \
-                    "First create a project folder with -p, then run additional commands as desired\n" \
-                    "Additional config options can be set with the 'runner.conf' file inside your new project folder"
-      opts.separator ''
-
-      opts.on('-p', '--project_folder <DIR>', String, "Create project directory named <DIR> in your current folder\n" \
-          '                                     You must be inside the project directory you just created for all following commands to work') do |folder|
-        @user_input[:project_folder] = folder
+    class UrbanOptCLI
+      COMMAND_MAP = {
+        'create' => 'Make new things - project directory or files',
+        'run' => 'Use files in your directory to simulate district energy use',
+        'process' => 'Post-process URBANopt simulations for additional insights',
+        'delete' => 'Delete simulations for a specified scenario'
+      }.freeze
+
+      def initialize
+        @subopts = nil
+        @command = nil
+        @mainopts = Optimist.options do
+          version VERSION
+          banner "\nURBANopt CLI version: #{version}"
+          banner "\nUsage:"
+          banner "  uo [options] [<command> [suboptions]]\n \n"
+          banner 'Options:'
+          opt :version, 'Print version and exit'  ## add this here or it goes to bottom of help
+          opt :help, 'Show this help message'     ## add this here or it goes to bottom of help
+          # opt :no_pager, "Disable paging"
+          stop_on COMMAND_MAP.keys
+          banner "\nCommands:"
+          COMMAND_MAP.each { |cmd, desc| banner format('  %-10s %s', cmd, desc) }
+          banner "\nFor help with a specific command: uo <command> --help"
+          banner "\nAdditional config options can be set with the 'runner.conf' file inside your project folder"
+          banner 'Fewer warnings are presented when using full paths and the user is not inside the project folder'
+        end
+        return if ARGV.empty?
+        @command = ARGV.shift
+        send("opt_#{@command}") ## dispatch to command handling method
       end
 
-      opts.on('-e', '--empty_project_folder', String, "Use with -p argument to create an empty project folder\n" \
-          "                                     Example: uo -e -p <DIR>\n" \
-          "                                     Then add your own Feature file in the project directory you created,\n" \
-          "                                     add Weather files in the weather folder and add OpenStudio models of Features \n" \
-          "                                     in the Feature File, if any in the osm_building folder \n" \
-          '                                     You must be inside the project directory you just created for all following commands to work') do
-        @user_input[:empty_project_folder] = 'Create empty project folder' # This text does not get displayed to the user
+      # Define creation commands
+      def opt_create
+        cmd = @command
+        @subopts = Optimist.options do
+          banner "\nURBANopt #{cmd}:\n \n"
+
+          opt :project_folder, "\nCreate project directory in your current folder. Name the directory\n" \
+          'Example: uo create --project urbanopt_example_project', type: String
+
+          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" \
+          "add Weather files in the weather folder and add OpenStudio models of Features\n" \
+          "in the Feature File, if any, in the osm_building folder\n" \
+          "Example: uo create --empty --project-folder urbanopt_example_project\n" \
+
+          opt :overwrite, "\nUse with --project-folder argument to overwrite existing project folder and replace with new project folder.\n" \
+          "May be combined with --empty as well to overwrite existing project folder and replace with new empty project folder.\n" \
+          'Example: uo create --overwrite --empty --project-folder urbanopt_project_folder_I_want_destroyed'
+
+          opt :scenario_file, "\nAutomatically create a ScenarioFile containing the features in FeatureFile for each scenario\n" \
+          "Provide the FeatureFile used to create the ScenarioFile\n" \
+          'Example: uo create --scenario-file example_project.json', type: String
+
+          opt :single_feature, "\nCreate a ScenarioFile with only a single feature\n" \
+          "Use the FeatureID from your FeatureFile\n" \
+          "Requires 'scenario-file' also be specified, to say which FeatureFile will create the ScenarioFile\n" \
+          'Example: uo create --single-feature 2 --scenario-file example_project.json', type: String
+
+          opt :reopt_scenario_file, "\nCreate a ScenarioFile that includes a column defining the REopt assumptions file\n" \
+          "Specify the existing ScenarioFile that you want to extend with REopt functionality\n" \
+          'Example: uo create --reopt-scenario-file baseline_scenario.csv', type: String
+        end
       end
 
-      opts.on('-o', '--overwrite_project_folder', String, "Use with -p argument to overwrite existing project folder and replace with new project folder.\n" \
-          "                                     Or, use with -e and -p argument to overwrite existing project folder and replace with new empty project folder.\n" \
-          "                                     Usage: uo -o -p <DIR>\n" \
-          "                                     or, uo -o -e -p <DIR>\n" \
-          '                                     Where, <DIR> is the existing project folder') do
-        @user_input[:overwrite_project_folder] = 'Overwriting existing project folder' # This text does not get displayed to the user
-      end
+      # Define running commands
+      def opt_run
+        cmd = @command
+        @subopts = Optimist.options do
+          banner "\nURBANopt #{cmd}:\n \n"
 
-      opts.on('-m', '--make_scenario', String, "Create ScenarioCSV files for each MapperFile using the Feature file path. Must specify -f argument\n" \
-          "                                     Example: uo -m -f example_project.json\n" \
-          "                                     Or, Create Scenario CSV for each MapperFile for a single Feature from Feature File. Must specify -f and -i argument\n" \
-          '                                     Example: uo -m -f example_project.json -i 1') do
-        @user_input[:make_scenario_from] = "Create scenario files from FeatureFiles or for single Feature according to the MapperFiles in the 'mappers' directory" # This text does not get displayed to the user
-      end
+          opt :reopt, "\nSimulate with additional REopt functionality. Must do this before post-processing with REopt"
 
-      opts.on('-r', '--run', String, "Run simulations. Must specify -s & -f arguments\n" \
-          '                                     Example: uo -r -s baseline_scenario.csv -f example_project.json') do
-        @user_input[:run_scenario] = 'Run simulations' # This text does not get displayed to the user
-      end
+          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.jsonn', default: 'baseline_scenario.csv', required: true
 
-      opts.on('-g', '--gather', String, "group individual feature results to scenario-level results. Must specify -t, -s, & -f arguments\n" \
-          '                                     Example: uo -g -t default -s baseline_scenario.csv -f example_project.json') do
-        @user_input[:gather] = 'Aggregate all features to a whole Scenario' # This text does not get displayed to the user
+          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
+        end
       end
 
-      opts.on('-d', '--delete_scenario', String, "Delete results from scenario. Must specify -s argument\n" \
-          '                                     Example: uo -d -s baseline_scenario.csv') do
-        @user_input[:delete_scenario] = 'Delete scenario results that were created from <SFP>' # This text does not get displayed to the user
-      end
+      # Define post-processing commands
+      def opt_process
+        cmd = @command
+        @subopts = Optimist.options do
+          banner "\nURBANopt #{cmd}:\n \n"
 
-      opts.on('-s', '--scenario_file <SFP>', String, 'Specify <SFP> (ScenarioCSV file path). Used as input for other commands') do |scenario|
-        @user_input[:scenario] = scenario
-        @root_dir, @scenario_file_name = File.split(File.absolute_path(@user_input[:scenario]))
-      end
+          opt :default, "\nStandard post-processing for your scenario"
 
-      opts.on('-f', '--feature_file <FFP>', String, 'Specify <FFP> (Feature file path). Used as input for other commands') do |feature|
-        @user_input[:feature] = feature
-        @feature_path, @feature_name = File.split(File.absolute_path(@user_input[:feature]))
-      end
+          opt :opendss, "\nPost-process with OpenDSS"
 
-      opts.on('-i', '--feature_id <FID>', Integer, 'Specify <FID> (Feature ID). Used as input for other commands') do |feature_id|
-        @user_input[:feature_id] = feature_id
-      end
+          opt :reopt_scenario, "\nOptimize for entire scenario with REopt\n" \
+          'Example: uo process --reopt-scenario'
+
+          opt :reopt_feature, "\nOptimize for each building individually with REopt\n" \
+          'Example: uo process --reopt-feature'
 
-      opts.on('-t', '--type <TYPE>', String, "Specify <TYPE> of post-processor to run:\n" \
-          "                                       default\n" \
-          "                                       reopt-scenario\n" \
-          "                                       reopt-feature\n" \
-          "                                       opendss\n") do |type|
-        @user_input[:type] = type
+          opt :scenario, "\nSelect which scenario to optimize", default: 'baseline_scenario.csv', required: true
+
+          opt :feature, "\nSelect which FeatureFile to use", default: 'example_project.json', required: true
+        end
       end
 
-      opts.on('-v', '--version', 'Show CLI version and exit') do
-        @user_input[:version_request] = VERSION
+      def opt_delete
+        cmd = @command
+        @subopts = Optimist.options do
+          banner "\nURBANopt #{cmd}:\n \n"
+
+          opt :scenario, "\nDelete simulation files for this scenario", default: 'baseline_scenario.csv', required: true
+        end
       end
+
+      attr_reader :mainopts, :command, :subopts
     end
 
-    begin
-      the_parser.parse!
-    rescue OptionParser::InvalidOption => e
-      puts e
+    # 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]))
+    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]))
+    end
+    if @opthash.subopts[:scenario]
+      @root_dir, @scenario_file_name = File.split(File.absolute_path(@opthash.subopts[:scenario]))
     end
 
     # Simulate energy usage as defined by ScenarioCSV\
     # params\
     # +scenario+:: _string_ Path to csv file that defines the scenario\
     # +feature_file_path+:: _string_ Path to Feature File used to describe set of features in the district
-    #
-    # FIXME: This only works when scenario_file and feature_file are in the project root directory
-    # This works when called with filename (from inside project directory) and with absolute filepaths
-    # Also, feels a little weird that now I'm only using instance variables and not passing anything to this function. I guess it's ok?
     def self.run_func
       name = File.basename(@scenario_file_name, File.extname(@scenario_file_name))
       run_dir = File.join(@root_dir, 'run', name.downcase)
@@ -147,8 +191,9 @@ module URBANopt
       reopt_files_dir = File.join(@root_dir, 'reopt/')
       num_header_rows = 1
       # FIXME: This can be cleaned up in Ruby 2.5 with Dir.children(<"foldername">)
+      # TODO: Better way of grabbing assumptions file than the first file in the folder
       reopt_files_dir_contents_list = Dir["#{reopt_files_dir}/*"]
-      reopt_folder_path, reopt_assumptions_filename = File.split(reopt_files_dir_contents_list[0])
+      reopt_assumptions_filename = File.basename(reopt_files_dir_contents_list[0])
 
       if @feature_id
         feature_run_dir = File.join(run_dir, @feature_id)
@@ -157,7 +202,11 @@ module URBANopt
       end
 
       feature_file = URBANopt::GeoJSON::GeoFile.from_file(featurefile)
-      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)
+      if @opthash.subopts[:reopt] == true || @opthash.subopts[:reopt_scenario] == true || @opthash.subopts[:reopt_feature] == true
+        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)
+      else
+        scenario_output = URBANopt::Scenario::ScenarioCSV.new(name, @root_dir, run_dir, feature_file, mapper_files_dir, csv_file, num_header_rows)
+      end
       scenario_output
     end
 
@@ -165,25 +214,24 @@ 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(@user_input[:feature])), symbolize_names: true)
+      feature_file_json = JSON.parse(File.read(File.absolute_path(@opthash.subopts[:scenario_file])), symbolize_names: true)
       Dir["#{@feature_path}/mappers/*.rb"].each do |mapper_file|
-        mapper_path, mapper_name = File.split(mapper_file)
-        mapper_name = mapper_name.split('.')[0]
+        mapper_name = File.basename(mapper_file, File.extname(mapper_file))
         scenario_file_name = if feature_id == 'SKIP'
                                "#{mapper_name.downcase}_scenario.csv"
                              else
                                "#{mapper_name.downcase}_scenario-#{feature_id}.csv"
                              end
         CSV.open(File.join(@feature_path, scenario_file_name), 'wb', write_headers: true,
-                                                                     headers: ['Feature Id', 'Feature Name', 'Mapper Class', 'REopt Assumptions']) do |csv|
+                                                                     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'
-                csv << [feature[:properties][:id], feature[:properties][:name], "URBANopt::Scenario::#{mapper_name}Mapper", 'base_assumptions.json']
-                end
-            elsif feature_id == feature[:properties][:id].to_i
-              csv << [feature[:properties][:id], feature[:properties][:name], "URBANopt::Scenario::#{mapper_name}Mapper", 'base_assumptions.json']
+                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) }
@@ -195,24 +243,38 @@ module URBANopt
       end
     end
 
+    # Write new ScenarioFile with REopt column
+    # 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))
+      table = CSV.read(existing_scenario_file, headers: true, col_sep: ',')
+      # Add another column, row by row:
+      table.each do |row|
+        row['REopt Assumptions'] = 'multiPV_assumptions.json'
+      end
+      # write new file
+      CSV.open(File.join(existing_path, 'REopt_scenario.csv'), 'w') do |f|
+        f << table.headers
+        table.each { |row| f << row }
+      end
+    end
+
     # Create project folder
     # params\
     # +dir_name+:: _string_ Name of new project folder
     #
-    # Folder gets created in the current working directory
-    # Includes weather for UO's example location, a base workflow file, and mapper files to show a baseline and a high-efficiency option.
+    # Includes weather for example location, a base workflow file, and mapper files to show a baseline and a high-efficiency option.
     def self.create_project_folder(dir_name, empty_folder = false, overwrite_project = false)
       if overwrite_project == true
         if Dir.exist?(dir_name)
           FileUtils.rm_rf(dir_name)
-          puts "Overwriting project directory: #{dir_name}\n"
         end
       elsif overwrite_project == false
         if Dir.exist?(dir_name)
           abort("\nERROR:  there is already a directory here named #{dir_name}... aborting\n---\n\n")
         end
       end
-      puts "CREATING NEW URBANopt project directory: #{dir_name}\n"
       Dir.mkdir dir_name
       Dir.mkdir File.join(dir_name, 'mappers')
       Dir.mkdir File.join(dir_name, 'weather')
@@ -253,13 +315,13 @@ module URBANopt
 
       # Download mapper files to user's local machine
       remote_mapper_files.each do |mapper_file|
-        mapper_path, mapper_name = File.split(mapper_file)
+        mapper_name = File.basename(mapper_file)
         mapper_download = open(mapper_file, ssl_verify_mode: OpenSSL::SSL::VERIFY_NONE)
         IO.copy_stream(mapper_download, File.join(mappers_dir_abs_path, mapper_name))
       end
 
       # Download gemfile to user's local machine
-      gem_path, gem_name = File.split(example_gem_file)
+      gem_name = File.basename(example_gem_file)
       example_gem_download = open(example_gem_file, ssl_verify_mode: OpenSSL::SSL::VERIFY_NONE)
       IO.copy_stream(example_gem_download, File.join(dir_name, gem_name))
 
@@ -274,153 +336,135 @@ module URBANopt
         end
 
         # Download config file to user's local machine
-        config_path, config_name = File.split(config_file)
+        config_name = File.basename(config_file)
         config_download = open(config_file, ssl_verify_mode: OpenSSL::SSL::VERIFY_NONE)
         IO.copy_stream(config_download, File.join(dir_name, config_name))
 
         # Download weather file to user's local machine
         remote_weather_files.each do |weather_file|
-          weather_path, weather_name = File.split(weather_file)
+          weather_name = File.basename(weather_file)
           weather_download = open(weather_file, ssl_verify_mode: OpenSSL::SSL::VERIFY_NONE)
           IO.copy_stream(weather_download, File.join(weather_dir_abs_path, weather_name))
         end
 
         # Download osm files to user's local machine
         osm_files.each do |osm_file|
-          osm_path, osm_name = File.split(osm_file)
+          osm_name = File.basename(osm_file)
           osm_download = open(osm_file, ssl_verify_mode: OpenSSL::SSL::VERIFY_NONE)
           IO.copy_stream(osm_download, File.join(osm_dir_abs_path, osm_name))
         end
 
         # Download feature file to user's local machine
-        feature_path, feature_name = File.split(example_feature_file)
+        feature_name = File.basename(example_feature_file)
         example_feature_download = open(example_feature_file, ssl_verify_mode: OpenSSL::SSL::VERIFY_NONE)
         IO.copy_stream(example_feature_download, File.join(dir_name, feature_name))
       end
     end
 
     # Perform CLI actions
-    if @user_input[:project_folder] && @user_input[:empty_project_folder].nil?
-      if @user_input[:overwrite_project_folder]
-        create_project_folder(@user_input[:project_folder], empty_folder = false, overwrite_project = true)
-        puts "\nOverwriting exiting project folder #{@user_input[:project_folder]}."
-        puts "Creating a new project folder.\n"
-      elsif @user_input[:overwrite_project_folder].nil?
-        create_project_folder(@user_input[:project_folder], empty_folder = false, overwrite_project = false)
+
+    # Create new project folder
+    if @opthash.command == 'create' && @opthash.subopts[:project_folder] && @opthash.subopts[:empty] == false
+      if @opthash.subopts[:overwrite] == true
+        puts "\nOverwriting existing project folder: #{@opthash.subopts[:project_folder]}...\n\n"
+        create_project_folder(@opthash.subopts[:project_folder], empty_folder = false, overwrite_project = true)
+      elsif @opthash.subopts[:overwrite] == false
+        puts "\nCreating a new project folder...\n"
+        create_project_folder(@opthash.subopts[:project_folder], empty_folder = false, overwrite_project = false)
       end
       puts "\nAn example FeatureFile is included: 'example_project.json'. You may place your own FeatureFile alongside the example."
       puts 'Weather data is provided for the example FeatureFile. Additional weather data files may be downloaded from energyplus.net/weather for free'
       puts "If you use additional weather files, ensure they are added to the 'weather' directory. You will need to configure your mapper file and your osw file to use the desired weather file"
-      puts "Next, move inside your new folder ('cd <FolderYouJustCreated>') and create ScenarioFiles using this CLI call: 'uo -m -f <FFP>'\n"
-    elsif @user_input[:project_folder] && @user_input[:empty_project_folder]
-      if @user_input[:overwrite_project_folder]
-        create_project_folder(@user_input[:project_folder], empty_folder = true, overwrite_project = true)
-        puts "\nOverwriting exiting project folder #{@user_input[:project_folder]}."
-        puts "Creating a new project folder.\n"
-      elsif @user_input[:overwrite_project].nil?
-        create_project_folder(@user_input[:project_folder], empty_folder = true, overwrite_project = false)
+      puts "We recommend using absolute paths for all commands, for cleaner output\n"
+    elsif @opthash.command == 'create' && @opthash.subopts[:project_folder] && @opthash.subopts[:empty] == true
+      if @opthash.subopts[:overwrite] == true
+        puts "\nOverwriting existing project folder: #{@opthash.subopts[:project_folder]} with an empty folder...\n\n"
+        create_project_folder(@opthash.subopts[:project_folder], empty_folder = true, overwrite_project = true)
+      elsif @opthash.subopts[:overwrite] == false
+        puts "\nCreating a new empty project folder...\n"
+        create_project_folder(@opthash.subopts[:project_folder], empty_folder = true, overwrite_project = false)
       end
-      puts 'Add your FeatureFile in the Project directory you just created.'
+      puts "\nAdd your FeatureFile in the Project directory you just created."
       puts 'Add your weather data files in the Weather folder. They may be downloaded from energyplus.net/weather for free'
       puts 'Add your OpenStudio models for Features in your Feature file, if any in the osm_building folder'
-      puts "Next, move inside your new folder ('cd <FolderYouJustCreated>') and create ScenarioFiles using this CLI call: 'uo -m -f <FFP>'\n"
+      puts "We recommend using absolute paths for all commands, for cleaner output\n"
     end
 
-    if @user_input[:make_scenario_from]
-      if @user_input[:feature].nil?
-        abort("\nYou must provide the '-f' flag and a valid path to a FeatureFile!\n---\n\n")
-      end
-
-      if @user_input[:feature_id]
-        puts "\nBuilding sample ScenarioFiles, assigning mapper classes to Feature ID #{@user_input[:feature_id]}..."
-        create_scenario_csv_file(@user_input[:feature_id])
+    # Create ScenarioFile from FeatureFile
+    if @opthash.command == 'create' && @opthash.subopts[:scenario_file]
+      if @opthash.subopts[:single_feature]
+        puts "\nBuilding sample ScenarioFiles, assigning mapper classes to Feature ID #{@opthash.subopts[:single_feature]}"
+        create_scenario_csv_file(@opthash.subopts[:single_feature])
         puts "\nDone\n"
       else
-        puts "\nBuilding sample ScenarioFiles, assigning mapper classes to each feature from #{@feature_name}..."
+        puts "\nBuilding sample ScenarioFiles, assigning mapper classes to each feature from #{@feature_name}"
         # Skip Feature ID argument if not present
         create_scenario_csv_file('SKIP')
         puts "\nDone\n"
       end
     end
 
-    if @user_input[:run_scenario]
-      if @user_input[:scenario].nil?
-        abort("\nYou must provide '-s' flag and a valid path to a ScenarioFile!\n---\n\n")
-      end
-      if @user_input[:feature].nil?
-        abort("\nYou must provide '-f' flag and a valid path to a FeatureFile!\n---\n\n")
-      end
-      if @user_input[:scenario].to_s.include? '-'
-        @scenario_folder = scenario_file_name.split(/\W+/)[0].capitalize.to_s
+    # Create REopt ScenarioFile from existing
+    if @opthash.command == 'create' && @opthash.subopts[:reopt_scenario_file]
+      puts "\nCreating ScenarioFile with REopt functionality, extending from #{@opthash.subopts[:reopt_scenario_file]}..."
+      create_reopt_scenario_file(@opthash.subopts[:reopt_scenario_file])
+      puts "\nDone"
+    end
+
+    # 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 '#{@user_input[:scenario]}'...\n\n"
+      puts "\nSimulating features of '#{@feature_name}' as directed by '#{@scenario_file_name}'...\n\n"
       scenario_runner = URBANopt::Scenario::ScenarioRunnerOSW.new
       scenario_runner.run(run_func)
       puts "\nDone\n"
     end
 
-    if @user_input[:gather]
-      if @user_input[:scenario].nil?
-        abort("\nYou must provide '-s' flag and a valid path to a ScenarioFile!\n---\n\n")
-      end
-      if @user_input[:feature].nil?
-        abort("\nYou must provide '-f' flag and a valid path to a FeatureFile!\n---\n\n")
-      end
-      if @user_input[:type].nil?
-        abort("\nYou must provide '-t' flag and a valid Gather type!\n" \
-            "Valid types include: 'default', 'reopt-scenario', 'reopt-feature', or 'opendss'\n---\n\n")
+    # Post-process the scenario
+    if @opthash.command == 'process'
+      if @opthash.subopts[:default] == false && @opthash.subopts[:opendss] == false && @opthash.subopts[:reopt_scenario] == false && @opthash.subopts[:reopt_feature] == false
+        abort("\nERROR: No valid process type entered. Must enter a valid process type\n")
       end
       @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
-      # FIXME: Remove this feature_reports block once urbanopt/urbanopt-scenario-gem#104 works as expected.
-      # save feature reports
-      scenario_report.feature_reports.each(&:save_feature_report)
-
-      if @user_input[:type].to_s.casecmp('default').zero?
+      if @opthash.subopts[:default] == true
+        puts 'Post-processing URBANopt results'
         puts "\nDone\n"
-      elsif @user_input[:type].to_s.casecmp('opendss').zero?
+      elsif @opthash.subopts[:opendss] == true
         puts "\nPost-processing OpenDSS results\n"
-        opendss_folder = File.join(@root_dir, 'run', @scenario_name.split('.')[0], 'opendss')
+        opendss_folder = File.join(@root_dir, 'run', @scenario_file_name.split('.')[0], 'opendss')
         if File.directory?(opendss_folder)
-          opendss_folder_path, opendss_folder_name = File.split(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)
           opendss_post_processor.run
           puts "\nDone\n"
         else
           abort("\nNo OpenDSS results available in folder '#{opendss_folder}'\n")
         end
-      elsif @user_input[:type].to_s.downcase.include?('reopt')
+      elsif @opthash.subopts.to_s.include?('reopt')
         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)
-
-        # Optimize REopt outputs for the whole Scenario
-        if @user_input[:type].to_s.casecmp('reopt-scenario').zero?
-          puts "\nOptimizing renewable energy for the scenario\n"
+        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')
           puts "\nDone\n"
-        # Optimize REopt outputs for each feature individually
-        elsif @user_input[:type].to_s.casecmp('reopt-feature').zero?
-          puts "\nOptimizing renewable energy for each feature\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')
           puts "\nDone\n"
-        else
-          abort("\nError: did not use type 'reopt-scenario', 'reopt-feature'. Aborting...\n---\n\n")
         end
-      else
-        abort("\nError: did not use type 'default', 'reopt-scenario', 'reopt-feature', or 'opendss'. Aborting...\n---\n\n")
       end
     end
 
-    if @user_input[:delete_scenario]
-      if @user_input[:scenario].nil?
-        abort("\nYou must provide '-s' flag and a valid path to a ScenarioFile!\n---\n\n")
-      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)
@@ -428,9 +472,5 @@ module URBANopt
       FileUtils.rm_rf(scenario_results_dir)
       puts "\nDone\n"
     end
-
-    if @user_input[:version_request]
-      puts "\nURBANopt CLI version: #{@user_input[:version_request]}\n---\n\n"
-    end
   end
 end