urbanopt-cli 0.5.1 → 0.5.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/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.
@@ -53,7 +63,10 @@ module URBANopt
         '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'
+        '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,14 +90,17 @@ 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" \
@@ -135,35 +151,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', 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', 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
@@ -192,9 +206,8 @@ module URBANopt
 
       # 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"
 
@@ -212,17 +225,16 @@ module URBANopt
           opt :reopt_scenario_assumptions_file, "\nPath to the scenario REopt assumptions JSON file you want to use. Use with the --reopt-scenario post-processor. " \
           "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 +255,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?
@@ -312,7 +375,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 +394,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
@@ -740,7 +817,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
@@ -931,6 +1008,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)