openstudio-analysis 0.4.5 → 1.0.0.pat1

data/lib/openstudio/analysis/server_api.rb

@@ -9,7 +9,7 @@ module OpenStudio
       BATCH_RUN_METHODS = %w(lhs preflight single_run repeat_run doe diag baseline_perturbation batch_datapoints)
 
       def initialize(options = {})
-        defaults = { hostname: 'http://localhost:8080' }
+        defaults = {hostname: 'http://localhost:8080'}
         options = defaults.merge(options)
         @logger = ::Logger.new('faraday.log')
 
@@ -82,12 +82,12 @@ module OpenStudio
       end
 
       def new_project(options = {})
-        defaults = { project_name: "Project #{::Time.now.strftime('%Y-%m-%d %H:%M:%S')}" }
+        defaults = {project_name: "Project #{::Time.now.strftime('%Y-%m-%d %H:%M:%S')}"}
         options = defaults.merge(options)
         project_id = nil
 
         # TODO: make this a display name and a machine name
-        project_hash = { project: { name: "#{options[:project_name]}" } }
+        project_hash = {project: {name: "#{options[:project_name]}"}}
 
         response = @conn.post do |req|
           req.url '/projects.json'
@@ -195,8 +195,8 @@ module OpenStudio
         begin
           resp = @conn.get do |req|
             req.url 'status.json'
-            req.options.timeout = 10
-            req.options.open_timeout = 10
+            req.options.timeout = 120
+            req.options.open_timeout = 120
           end
 
           if resp.status == 200
@@ -405,7 +405,11 @@ module OpenStudio
       end
 
       def new_analysis(project_id, options)
-        defaults = { analysis_name: nil, reset_uuids: false }
+        defaults = {
+            analysis_name: nil,
+            reset_uuids: false,
+            push_to_dencity: false
+        }
         options = defaults.merge(options)
 
         fail 'No project id passed' if project_id.nil?
@@ -445,7 +449,7 @@ module OpenStudio
           formulation_json[:analysis][:name] = "#{options[:analysis_name]}" unless options[:analysis_name].nil?
         else
           formulation_json = {
-            analysis: options
+              analysis: options
           }
           puts formulation_json
           analysis_id = SecureRandom.uuid
@@ -460,13 +464,15 @@ module OpenStudio
           req.url "projects/#{project_id}/analyses.json"
           req.headers['Content-Type'] = 'application/json'
           req.body = formulation_json.to_json
+          req.options[:timeout] = 600 # seconds
         end
 
         if response.status == 201
           puts "asked to create analysis with #{analysis_id}"
           # puts resp.inspect
           analysis_id = JSON.parse(response.body)['_id']
-
+          puts "options[:push_to_dencity] = #{options[:push_to_dencity]}"
+          upload_to_dencity(analysis_id, formulation_json) if options[:push_to_dencity]
           puts "new analysis created with ID: #{analysis_id}"
         else
           fail 'Could not create new analysis'
@@ -476,7 +482,7 @@ module OpenStudio
         if options[:upload_file]
           fail "upload file does not exist #{options[:upload_file]}" unless File.exist?(options[:upload_file])
 
-          payload = { file: Faraday::UploadIO.new(options[:upload_file], 'application/zip') }
+          payload = {file: Faraday::UploadIO.new(options[:upload_file], 'application/zip')}
           response = @conn_multipart.post "analyses/#{analysis_id}/upload.json", payload do |req|
             req.options[:timeout] = 1800 # seconds
           end
@@ -491,8 +497,72 @@ module OpenStudio
         analysis_id
       end
 
+      def upload_to_dencity(analysis_uuid, analysis)
+        require 'dencity'
+        puts "Attempting to connect to DEnCity server using settings at '~/.dencity/config.yml'"
+        conn = Dencity.connect
+        fail "Could not connect to DEnCity server at #{hostname}." unless conn.connected?
+        begin
+          r = conn.login
+        rescue Faraday::ParsingError => user_id_failure
+          fail "Error in user_id field: #{user_id_failure.message}"
+        rescue MultiJson::ParseError => authentication_failure
+          fail "Error in attempted authentication: #{authentication_failure.message}"
+        end
+        user_uuid = r.id
+
+        # Find the analysis.json file that SHOULD BE IN THE FOLDER THAT THIS SCRIPT IS IN (or change the below)
+        # Check that the analysis has not yet been registered with the DEnCity instance.
+        # TODO This should be simplified with a retrieve_analysis_by_user_defined_id' method in the future
+        user_analyses = []
+        r = conn.dencity_get 'analyses'
+        runner.registerError('Unable to retrieve analyses from DEnCity server') unless r['status'] == 200
+        r['data'].each do |dencity_analysis|
+          user_analyses << dencity_analysis['id'] if dencity_analysis['user_id'] == user_uuid
+        end
+        found_analysis_uuid = false
+        user_analyses.each do |dencity_analysis_id|
+          dencity_analysis = conn.retrieve_analysis_by_id(dencity_analysis_id)
+          if dencity_analysis['user_defined_id'] == analysis_uuid
+            found_analysis_uuid = true
+            break
+          end
+        end
+        fail "Analysis with user_defined_id of #{analysis_uuid} found on DEnCity." if found_analysis_uuid
+        dencity_hash = OpenStudio::Analysis.to_dencity_analysis(analysis, analysis_uuid)
+
+        # Write the analysis DEnCity hash to dencity_analysis.json
+        f = File.new('dencity_analysis.json', 'wb')
+        f.write(JSON.pretty_generate(dencity_hash))
+        f.close
+
+        # Upload the processed analysis json.
+        upload = conn.load_analysis 'dencity_analysis.json'
+        begin
+          upload_response = upload.push
+        rescue => e
+          runner.registerError("Upload failure: #{e.message} in #{e.backtrace.join('/n')}")
+        else
+          if NoMethodError == upload_response.class
+            fail "ERROR: Server responded with a NoMethodError: #{upload_response}"
+          end
+          if upload_response.status.to_s[0] == '2'
+            puts 'Successfully uploaded processed analysis json file to the DEnCity server.'
+          else
+            puts 'ERROR: Server returned a non-20x status. Response below.'
+            puts upload_response
+            fail
+          end
+        end
+      end
+
+      # Upload a single datapoint
+      # @param analysis [String] Analysis ID to attach datapoint
+      # @param options [Hash] Options
+      # @option options [String] :datapoint_file Path to datapoint JSON to upload
+      # @option options [Boolean] :reset_uuids Flag on whether or not to reset the UUID in the datapoint JSON to a new random value.
       def upload_datapoint(analysis_id, options)
-        defaults = { reset_uuids: false }
+        defaults = {reset_uuids: false}
         options = defaults.merge(options)
 
         fail 'No analysis id passed' if analysis_id.nil?
@@ -501,8 +571,12 @@ module OpenStudio
 
         dp_hash = JSON.parse(File.open(options[:datapoint_file]).read, symbolize_names: true)
 
+        # There are two instances of the analysis ID. There is one in the file,
+        # and the other is in the POST url. Ideally remove the version in the
+        # file and support only the URL based analysis_id
+        dp_hash[:analysis_uuid] = analysis_id
+
         if options[:reset_uuids]
-          dp_hash[:analysis_uuid] = analysis_id
           dp_hash[:uuid] = SecureRandom.uuid
         end
 
@@ -515,11 +589,14 @@ module OpenStudio
 
         if response.status == 201
           puts "new datapoints created for analysis #{analysis_id}"
+          return JSON.parse(response.body, symbolize_names: true)
         else
           fail "could not create new datapoints #{response.body}"
         end
       end
 
+      # Upload multiple data points to the server.
+      # @param analysis [String] Analysis ID to attach datapoint
       def upload_datapoints(analysis_id, options)
         defaults = {}
         options = defaults.merge(options)
@@ -544,10 +621,8 @@ module OpenStudio
         end
       end
 
-      # TODO: this should be called 'start analysis'
-      def run_analysis(analysis_id, options)
-        warn 'In 0.5.0, OpenStudio::Analysis::ServerApi run_analysis will be renamed to start_analysis. Use start_analysis.'
-        defaults = { analysis_action: 'start', without_delay: false }
+      def start_analysis(analysis_id, options)
+        defaults = {analysis_action: 'start', without_delay: false}
         options = defaults.merge(options)
 
         puts "Run analysis is configured with #{options.to_json}"
@@ -559,16 +634,16 @@ module OpenStudio
         end
 
         if response.status == 200
-          puts "Recieved request to run analysis #{analysis_id}"
+          puts "Received request to run analysis #{analysis_id}"
         else
           fail 'Could not start the analysis'
         end
       end
 
-      alias_method :start_analysis, :run_analysis
-
+      # Kill the analysis
+      # @param analysis [String] Analysis ID to stop
       def kill_analysis(analysis_id)
-        analysis_action = { analysis_action: 'stop' }
+        analysis_action = {analysis_action: 'stop'}
 
         response = @conn.post do |req|
           req.url "analyses/#{analysis_id}/action.json"
@@ -649,8 +724,6 @@ module OpenStudio
         data_point
       end
 
-      ## here are a bunch of runs that really don't belong here.
-
       # Submit a generic analysis. This will use the options that are configured in the JSON file including
       # the analysis type and options. Note that this may not work for all cases were multiple analyses need to run
       # (e.g. single_run, queue_model, lhs)
@@ -665,218 +738,54 @@ module OpenStudio
         run(formulation_filename, analysis_zip_filename, analysis_type)
       end
 
-      # create a new analysis and run a single model
-      def run_single_model(formulation_filename, analysis_zip_filename, run_data_point_filename = 'run_openstudio_workflow_monthly.rb')
-        project_options = {}
-        project_id = new_project(project_options)
-
-        analysis_options = {
-          formulation_file: formulation_filename,
-          upload_file: analysis_zip_filename,
-          reset_uuids: true
-        }
-        analysis_id = new_analysis(project_id, analysis_options)
-
-        # Force this to run in the foreground for now until we can deal with checing the 'analysis state of various anlaysis'
-        run_options = {
-          analysis_action: 'start',
-          without_delay: true, # run this in the foreground
-          analysis_type: 'single_run',
-          allow_multiple_jobs: true,
-          use_server_as_worker: true,
-          simulate_data_point_filename: 'simulate_data_point.rb',
-          run_data_point_filename: run_data_point_filename
-        }
-        start_analysis(analysis_id, run_options)
-
-        run_options = {
-          analysis_action: 'start',
-          without_delay: false, # run in background
-          analysis_type: 'batch_run',
-          allow_multiple_jobs: true,
-          use_server_as_worker: true,
-          simulate_data_point_filename: 'simulate_data_point.rb',
-          run_data_point_filename: run_data_point_filename
-        }
-        start_analysis(analysis_id, run_options)
-
-        analysis_id
-      end
-
-      # creates a new analysis and runs rgenoud optimization - number of generations isn't used right now
-      def run_rgenoud(formulation_filename, analysis_zip_filename)
-        project_options = {}
-        project_id = new_project(project_options)
-
-        analysis_options = {
-          formulation_file: formulation_filename,
-          upload_file: analysis_zip_filename,
-          reset_uuids: true
-        }
-        analysis_id = new_analysis(project_id, analysis_options)
-
-        run_options = {
-          analysis_action: 'start',
-          without_delay: false,
-          analysis_type: 'rgenoud',
-          allow_multiple_jobs: true,
-          use_server_as_worker: true,
-          simulate_data_point_filename: 'simulate_data_point.rb',
-          run_data_point_filename: 'run_openstudio_workflow_monthly.rb'
-        }
-        start_analysis(analysis_id, run_options)
-
-        analysis_id
-      end
-
-      def run_lhs(formulation_filename, analysis_zip_filename)
-        project_options = {}
-        project_id = new_project(project_options)
-
-        analysis_options = {
-          formulation_file: formulation_filename,
-          upload_file: analysis_zip_filename,
-          reset_uuids: true
-        }
-        analysis_id = new_analysis(project_id, analysis_options)
-
-        run_options = {
-          analysis_action: 'start',
-          without_delay: false,
-          analysis_type: 'lhs',
-          allow_multiple_jobs: true,
-          use_server_as_worker: true,
-          simulate_data_point_filename: 'simulate_data_point.rb',
-          run_data_point_filename: 'run_openstudio_workflow_monthly.rb'
-        }
-        start_analysis(analysis_id, run_options)
-
-        run_options = {
-          analysis_action: 'start',
-          without_delay: false, # run in background
-          analysis_type: 'batch_run',
-          allow_multiple_jobs: true,
-          use_server_as_worker: true,
-          simulate_data_point_filename: 'simulate_data_point.rb',
-          run_data_point_filename: 'run_openstudio_workflow_monthly.rb'
-        }
-        start_analysis(analysis_id, run_options)
-
-        analysis_id
-      end
-
-      def run_baseline_perturbation(formulation_filename, analysis_zip_filename)
-        project_options = {}
-        project_id = new_project(project_options)
-
-        analysis_options = {
-          formulation_file: formulation_filename,
-          upload_file: analysis_zip_filename,
-          reset_uuids: true
-        }
-        analysis_id = new_analysis(project_id, analysis_options)
-
-        run_options = {
-          analysis_action: 'start',
-          without_delay: false,
-          analysis_type: 'baseline_perturbation',
-          allow_multiple_jobs: true,
-          use_server_as_worker: true,
-          simulate_data_point_filename: 'simulate_data_point.rb',
-          run_data_point_filename: 'run_openstudio_workflow_monthly.rb'
-        }
-        start_analysis(analysis_id, run_options)
-
-        run_options = {
-          analysis_action: 'start',
-          without_delay: false, # run in background
-          analysis_type: 'batch_run',
-          allow_multiple_jobs: true,
-          use_server_as_worker: true,
-          simulate_data_point_filename: 'simulate_data_point.rb',
-          run_data_point_filename: 'run_openstudio_workflow_monthly.rb'
-        }
-        start_analysis(analysis_id, run_options)
-
-        analysis_id
-      end
-
-      def run_batch_datapoints(formulation_filename, analysis_zip_filename)
-        project_options = {}
-        project_id = new_project(project_options)
-
-        puts 'In run_batch_datapoints'
-
-        analysis_options = {
-          formulation_file: formulation_filename,
-          upload_file: analysis_zip_filename,
-          reset_uuids: true
-        }
-        analysis_id = new_analysis(project_id, analysis_options)
-
-        run_options = {
-          analysis_action: 'start',
-          without_delay: false,
-          analysis_type: 'batch_datapoints',
-          allow_multiple_jobs: true,
-          use_server_as_worker: true,
-          simulate_data_point_filename: 'simulate_data_point.rb',
-          run_data_point_filename: 'run_openstudio_workflow_monthly.rb'
-        }
-        start_analysis(analysis_id, run_options)
-
-        run_options = {
-          analysis_action: 'start',
-          without_delay: false, # run in background
-          analysis_type: 'batch_run',
-          allow_multiple_jobs: true,
-          use_server_as_worker: true,
-          simulate_data_point_filename: 'simulate_data_point.rb',
-          run_data_point_filename: 'run_openstudio_workflow_monthly.rb'
+      # Submit the analysis for running via the API
+      #
+      # @param formulation_filename [String] Name of the analysis.json file
+      # @param analysis_zip_filename [String] Name of the analysis.zip file
+      # @param analysis_type [String] Type of analysis to run
+      # @param options [Hash] Hash of options
+      # @option options [String] :run_data_point_filename Name of ruby file that the server runs -- will be deprecated
+      # @option options [String] :push_to_dencity Whether or not to push to DEnCity
+      # @option options [String] :batch_run_method Which batch run method to use (batch_run or batch_run_local [no R])
+      def run(formulation_filename, analysis_zip_filename, analysis_type,
+              options = {})
+        defaults = {
+            run_data_point_filename: 'run_openstudio_workflow_monthly.rb',
+            push_to_dencity: false,
+            batch_run_method: 'batch_run'
         }
-        start_analysis(analysis_id, run_options)
-
-        analysis_id
-      end
+        options = defaults.merge(options)
 
-      def run_analysis_detailed(formulation_filename, analysis_zip_filename, analysis_type,
-                                allow_multiple_jobs = true, server_as_worker = true,
-                                run_data_point_filename = 'run_openstudio_workflow_monthly.rb')
-        warn 'run_analysis_detailed will be deprecated in 0.5.0. Use run(...)'
         project_options = {}
         project_id = new_project(project_options)
 
         analysis_options = {
-          formulation_file: formulation_filename,
-          upload_file: analysis_zip_filename,
-          reset_uuids: true
+            formulation_file: formulation_filename,
+            upload_file: analysis_zip_filename,
+            reset_uuids: true,
+            push_to_dencity: options[:push_to_dencity]
         }
 
         analysis_id = new_analysis(project_id, analysis_options)
 
-        server_as_worker = true if analysis_type == 'optim' || analysis_type == 'rgenoud'
         run_options = {
-          analysis_action: 'start',
-          without_delay: false,
-          analysis_type: analysis_type,
-          allow_multiple_jobs: allow_multiple_jobs,
-          use_server_as_worker: server_as_worker,
-          simulate_data_point_filename: 'simulate_data_point.rb',
-          run_data_point_filename: run_data_point_filename
+            analysis_action: 'start',
+            without_delay: false,
+            analysis_type: analysis_type,
+            simulate_data_point_filename: 'simulate_data_point.rb', # TODO: remove these from server?
+            run_data_point_filename: options[:run_data_point_filename]
         }
         start_analysis(analysis_id, run_options)
 
-        # If the analysis is a staged analysis, then go ahead and run batch run because there is
-        # no explicit way to tell the system to do it
+        # If the analysis is a staged analysis, then go ahead and run batch run
+        # because there is no explicit way to tell the system to do it
         if BATCH_RUN_METHODS.include? analysis_type
           run_options = {
-            analysis_action: 'start',
-            without_delay: false,
-            analysis_type: 'batch_run',
-            allow_multiple_jobs: allow_multiple_jobs,
-            use_server_as_worker: server_as_worker,
-            simulate_data_point_filename: 'simulate_data_point.rb',
-            run_data_point_filename: run_data_point_filename
+              analysis_action: 'start',
+              without_delay: false,
+              analysis_type: options[:batch_run_method],
+              simulate_data_point_filename: 'simulate_data_point.rb',
+              run_data_point_filename: options[:run_data_point_filename]
           }
           start_analysis(analysis_id, run_options)
         end
@@ -884,59 +793,47 @@ module OpenStudio
         analysis_id
       end
 
-      alias_method :run, :run_analysis_detailed
-
       def queue_single_run(formulation_filename, analysis_zip_filename, analysis_type,
-                           allow_multiple_jobs = true, server_as_worker = true,
                            run_data_point_filename = 'run_openstudio_workflow_monthly.rb')
         project_options = {}
         project_id = new_project(project_options)
 
         analysis_options = {
-          formulation_file: formulation_filename,
-          upload_file: analysis_zip_filename,
-          reset_uuids: true
+            formulation_file: formulation_filename,
+            upload_file: analysis_zip_filename,
+            reset_uuids: true
         }
         analysis_id = new_analysis(project_id, analysis_options)
 
-        server_as_worker = true if analysis_type == 'optim' || analysis_type == 'rgenoud'
         run_options = {
-          analysis_action: 'start',
-          without_delay: false,
-          analysis_type: analysis_type,
-          allow_multiple_jobs: allow_multiple_jobs,
-          use_server_as_worker: server_as_worker,
-          simulate_data_point_filename: 'simulate_data_point.rb',
-          run_data_point_filename: run_data_point_filename
+            analysis_action: 'start',
+            without_delay: false,
+            analysis_type: analysis_type,
+            simulate_data_point_filename: 'simulate_data_point.rb',
+            run_data_point_filename: run_data_point_filename
         }
         start_analysis(analysis_id, run_options)
 
         analysis_id
       end
 
-      # TODO: this should take no arguments
-      def run_batch_run_across_analyses(formulation_filename, analysis_zip_filename,
-                                        allow_multiple_jobs = true, server_as_worker = true,
-                                        run_data_point_filename = 'run_openstudio_workflow_monthly.rb')
+      def run_batch_run_across_analyses
         project_options = {}
         project_id = new_project(project_options)
 
         analysis_options = {
-          formulation_file: nil,
-          upload_file: nil,
-          reset_uuids: true,
-          # { analysis: { name: 'something', display_name: 'something else' }}
+            formulation_file: nil,
+            upload_file: nil,
+            reset_uuids: true,
         }
         analysis_id = new_analysis(project_id, analysis_options)
 
         run_options = {
-          analysis_action: 'start',
-          without_delay: false,
-          analysis_type: 'batch_run_analyses',
-          allow_multiple_jobs: allow_multiple_jobs,
-          use_server_as_worker: server_as_worker,
-          simulate_data_point_filename: 'simulate_data_point.rb',
-          run_data_point_filename: run_data_point_filename
+            analysis_action: 'start',
+            without_delay: false,
+            analysis_type: 'batch_run_analyses',
+            simulate_data_point_filename: 'simulate_data_point.rb',
+            run_data_point_filename: 'run_openstudio_workflow_monthly.rb'
         }
         start_analysis(analysis_id, run_options)
 

data/lib/openstudio/analysis/translator/datapoints.rb

@@ -165,6 +165,7 @@ module OpenStudio
           display_name = append_model_name ? @name + ' ' + seed_model[:display_name] : @name
 
           a = OpenStudio::Analysis.create(display_name)
+          a
 
           @variables.each do |measure|
             @measure_paths.each do |measure_path|
@@ -247,7 +248,7 @@ module OpenStudio
           end
 
           fail 'Required setting not found: weather_paths' unless config_hash[:weather_paths]
-          config_hash[:weather_paths] = eval("#{config_hash[:weather_paths]}")
+          config_hash[:weather_paths] = config_hash[:weather_paths].split(',')
           config_hash[:weather_paths].each do |path|
             if (Pathname.new path).absolute?
               @weather_paths << path
@@ -294,8 +295,12 @@ module OpenStudio
             @other_files << { lib_zip_name: library_name, path: config_hash[:library_path] }
           end
 
-          @run_setup[:allow_multiple_jobs] = config_hash[:allow_multiple_jobs].to_s.to_bool if config_hash[:allow_multiple_jobs]
-          @run_setup[:use_server_as_worker] = config_hash[:use_server_as_worker].to_s.to_bool if config_hash[:use_server_as_worker]
+          if config_hash[:allow_multiple_jobs]
+            fail "allow_multiple_jobs is no longer a valid option in the CSV, please delete and rerun"
+          end
+          if config_hash[:use_server_as_worker]
+            fail "use_server_as_worker is no longer a valid option in the CSV, please delete and rerun"
+          end
 
           # Assign AWS settings
           @settings[:proxy_port] = config_hash[:proxy_port] if config_hash[:proxy_port]

data/lib/openstudio/analysis/translator/excel.rb

@@ -22,6 +22,7 @@ module OpenStudio
 
         # remove these once we have classes to construct the JSON file
         attr_accessor :name
+        attr_accessor :cluster_name
         attr_reader :analysis_name
 
         # methods to override instance variables
@@ -44,7 +45,6 @@ module OpenStudio
           @analyses = [] # Array o OpenStudio::Analysis. Use method to access
           @name = nil
           @analysis_name = nil
-          @cluster_name = nil
           @settings = {}
           @weather_files = [] # remove this from excel!
           @weather_paths = []
@@ -195,6 +195,7 @@ module OpenStudio
         end
 
         # convert the data in excel's parsed data into an OpenStudio Analysis Object
+        #
         # @seed_model [Hash] Seed model to set the new analysis to
         # @append_model_name [Boolean] Append the name of the seed model to the display name
         # @return [Object] An OpenStudio::Analysis
@@ -275,6 +276,11 @@ module OpenStudio
           as
         end
 
+        # Method to return the cluster name for backwards compatibility
+        def cluster_name
+          @settings['cluster_name']
+        end
+
         # save_analysis will iterate over each model that is defined in the spreadsheet and save the
         # zip and json file.
         def save_analysis
@@ -411,7 +417,9 @@ module OpenStudio
             if b_settings
               @version = row[1].chomp if row[0] == 'Spreadsheet Version'
               @settings["#{row[0].snake_case}"] = row[1] if row[0]
-              @cluster_name = @settings['cluster_name'].snake_case if @settings['cluster_name']
+              if @settings['cluster_name']
+                @settings['cluster_name'] = @settings['cluster_name'].snake_case
+              end
 
               if row[0] == 'AWS Tag'
                 @aws_tags << row[1].strip
@@ -448,8 +456,12 @@ module OpenStudio
               @run_setup["#{row[0].snake_case}"] = row[1] if row[0]
 
               # type cast
-              @run_setup['allow_multiple_jobs'] = @run_setup['allow_multiple_jobs'].to_s.to_bool if @run_setup['allow_multiple_jobs']
-              @run_setup['use_server_as_worker'] = @run_setup['use_server_as_worker'].to_s.to_bool if @run_setup['use_server_as_worker']
+              if @run_setup['allow_multiple_jobs']
+                fail "allow_multiple_jobs is no longer a valid option in the Excel file, please delete the row and rerun"
+              end
+              if @run_setup['use_server_as_worker']
+                fail "use_server_as_worker is no longer a valid option in the Excel file, please delete the row and rerun"
+              end
             elsif b_problem_setup
               if row[0]
                 v = row[1]