openstudio-analysis 0.4.2 → 0.4.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 40fd5c10c4ff7f0c700a21e8863f9289810c529e
-  data.tar.gz: 9a923d85c9f7bac6f9a90f904b9ab81295c59460
+  metadata.gz: 0e2234bf02d68d5c389ae087659a5ccf9a3151f6
+  data.tar.gz: c2a06a1e663d5875bc4bd0cf47c9b3f440b1e41d
 SHA512:
-  metadata.gz: 028780fc203beed4de73fd266b872d9b0a22d0eddd5cbeb5fd9119fe773a069b8dee881b28d4dd8cd75faad9bfab3cc747b5216c7808b9b7247ad79ed20f32d6
-  data.tar.gz: a6b386728b1c3454cfaa1f84f27eac33ed24e1587bbead6514ba34196e4fda5d9777312f3b1a45a7de3c5c10bcda247d448bcff036fe403daa8950407d44a1df
+  metadata.gz: 00fcc700426dec77ff30ba768b5dff7adf1037a8aab9ec2e079c80b47a7dd86c7532dfe45d0c3736a5a4adafa0208b69a7ae43b52021a5ce03f4e9da9a4dce93
+  data.tar.gz: 12cd3030a23bd2fdc2ac0970bf6b253729b925538f5d99a427cb890823bc08f5110b135971c25a11bf3bca6dd7d26a55a51e2ecf40480c2761124f0a2fecffbc

data/CHANGELOG.md

@@ -1,6 +1,19 @@
 OpenStudio Analysis Gem Change Log
 ==================================
 
+Version 0.4.3
+------------------
+* Add defaults to the OpenStudio::Analysis::ServerApi .run method.
+* Bug fix for path to the measure if there was more than one depth of the directory.
+* Add measure_definition_directory_local to store the path to the original measure.
+* run_analysis will be deprecated in 0.5.0. Use start_analysis instead of run_analysis.
+* Less stringent check on column names in Excel which caused errors at times.
+* Do not error out when a measure argument is a String or Choice and does not contain Enumerations.
+* New data point status API helper to list all the data points across all the analyses if desired.
+* If the user sets a std dev or delta x on a uniform or discrete variable, allow it to persist. This allows certain algorithms (e.g. rgenoud) to use the data.
+* New class OpenStudio::Weather::Epw to handle pulling data out of weather files.
+* Deprecate the old ERB templates for creating the analysis.json via the Excel translator
+
 Version 0.4.2
 -------------
 * Bug fix when adding measure from path, this now sets the correct argument name.

data/README.md

@@ -53,15 +53,20 @@ This gem used RSpec for testing.  To test simply run `rspec` at the command line
 
 # Todos
 
-In the programmatic interface there are still several items that need to be checked
+In the programmatic interface there are still several items that would be nice to have.
 
 * verify that the measure.xml file exists
 * Check the type of measure being added and make sure that it is in the right workflow (e.g. no energyplus measures before rubymeasures)
 * add reverse translator from existing analysis.jsons
 * more explicit run workflows. For example, add workflow steps for running energyplus, openstudio translator, radiance, etc
 * more explicit assignment of the analyses that can run. This would be nice:
+
     ```
     a = OpenStudio::Analysis.create("new analysis")
     a.analysis_type('single_run')
     ```
 
+* adding mulitple seed models
+* adding multiple weather files
+* 
+

data/lib/openstudio-analysis.rb

@@ -3,6 +3,7 @@ require 'json'
 require 'securerandom'
 require 'logger'
 require 'pathname'
+require 'csv'
 
 # gems to always include
 require 'faraday'
@@ -32,3 +33,6 @@ require 'openstudio/analysis/translator/excel'
 # helpers / core_ext
 require 'openstudio/helpers/string'
 require 'openstudio/helpers/hash'
+
+# weather file parsing
+require 'openstudio/weather/epw'

data/lib/openstudio/analysis.rb

@@ -1,8 +1,24 @@
 # OpenStudio::Analysis Module instantiates versions of formulations
 module OpenStudio
   module Analysis
+    # Create a new analysis
     def self.create(display_name)
       OpenStudio::Analysis::Formulation.new(display_name)
     end
+
+    # Load the analysis json or from a file. If this is a json then it must have
+    # symbolized keys
+    def self.load(h)
+      h = MultiJson.load(h, symbolize_keys: true) unless h.is_a? Hash
+      OpenStudio::Analysis::Formulation.from_hash h
+    end
+
+    # Load an analysis from excel. This will create an array of analyses because
+    # excel can create more than one analyses
+    def self.from_excel(filename)
+      excel = OpenStudio::Analysis::Translator::Excel.new(filename)
+      excel.process
+      excel.analyses
+    end
   end
 end

data/lib/openstudio/analysis/algorithm_attributes.rb

@@ -14,6 +14,10 @@ module OpenStudio
         @attributes[attribute_name] = attribute_value
       end
 
+      def [](name)
+        @attributes[name]
+      end
+
       def to_hash(_version = 1)
         @attributes
       end

data/lib/openstudio/analysis/formulation.rb

@@ -4,10 +4,22 @@ module OpenStudio
     SeedModel = Struct.new(:file)
     WeatherFile = Struct.new(:file)
 
+    @@measure_paths = ['./measures']
+    # List of paths to look for measures when adding them. This currently only is used when loading an
+    # analysis hash file. It looks in the order of the measure_paths. As soon as it finds one, it stops.
+    def self.measure_paths
+      @@measure_paths
+    end
+
+    def self.measure_paths=(new_array)
+      @@measure_paths = new_array
+    end
+
     class Formulation
       attr_reader :seed_model
       attr_reader :weather_file
       attr_reader :analysis_type
+      attr_reader :outputs
       attr_accessor :display_name
       attr_accessor :workflow
       attr_accessor :algorithm
@@ -39,7 +51,7 @@ module OpenStudio
         @worker_inits = SupportFiles.new
         @worker_finalizes = SupportFiles.new
         @libraries = SupportFiles.new
-        #@initialization_scripts = SupportFiles.new
+        # @initialization_scripts = SupportFiles.new
       end
 
       # Initialize or return the current workflow object
@@ -57,16 +69,16 @@ module OpenStudio
       # Path to the seed model
       #
       # @param path [String] Path to the seed model. This should be relative.
-      def seed_model(file)
-        @seed_model = SeedModel.new(file)
+      def seed_model=(file)
+        @seed_model[:file] = file
       end
 
       # Path to the weather file (or folder). If it is a folder, then the measures will look for the weather file
       # by name in that folder.
       #
       # @param path [String] Path to the weather file or folder.
-      def weather_file(file)
-        @weather_file = WeatherFile.new(file)
+      def weather_file=(file)
+        @weather_file[:file] = file
       end
 
       # Add an output of interest to the problem formulation
@@ -87,12 +99,12 @@ module OpenStudio
       # @option output_hash [Integer] :objective_function_group If grouping objective functions, then group ID. Default: nil
       def add_output(output_hash)
         output_hash = {
-            units: '',
-            objective_function: false,
-            objective_function_index: nil,
-            objective_function_target: nil,
-            objective_function_group: nil,
-            scaling_factor: nil
+          units: '',
+          objective_function: false,
+          objective_function_index: nil,
+          objective_function_target: nil,
+          objective_function_group: nil,
+          scaling_factor: nil
         }.merge(output_hash)
 
         # if the objective_function index is nil and the variable is an objective function, then increment and
@@ -105,6 +117,11 @@ module OpenStudio
         @outputs << output_hash
       end
 
+      # return the machine name of the analysis
+      def name
+        @display_name.snake_case
+      end
+
       # return a hash.
       #
       # @param version [Integer] Version of the format to return
@@ -113,21 +130,48 @@ module OpenStudio
         # fail 'Must define an analysis type' unless @analysis_type
         if version == 1
           h = {
-              analysis: {
-                  display_name: @display_name,
-                  name: @display_name.snake_case,
-                  output_variables: @outputs,
-                  problem: {
-                      analysis_type: @analysis_type,
-                      algorithm: algorithm.to_hash(version),
-                      workflow: workflow.to_hash(version)
-                  },
-                  seed: @seed_model[:file],
-                  weather_file: @weather_file[:file],
-                  file_format_version: version
+            analysis: {
+              display_name: @display_name,
+              name: name,
+              output_variables: @outputs,
+              problem: {
+                analysis_type: @analysis_type,
+                algorithm: algorithm.to_hash(version),
+                workflow: workflow.to_hash(version)
               }
+            }
           }
 
+          if @seed_model[:file]
+            h[:analysis][:seed] = {
+              file_type: File.extname(@seed_model[:file]).gsub('.', '').upcase,
+              path: "./seed/#{File.basename(@seed_model[:file])}"
+            }
+          else
+            h[:analysis][:seed] = nil
+          end
+
+          # silly catch for if weather_file is not set
+          wf = nil
+          if @weather_file[:file]
+            wf = @weather_file
+          elsif @weather_files.size > 0
+            # get the first EPW file (not the first file)
+            wf = @weather_files.find { |w| File.extname(w[:file]).downcase == '.epw' }
+          end
+
+          if wf
+            h[:analysis][:weather_file] = {
+              file_type: File.extname(wf[:file]).gsub('.', '').upcase,
+              path: "./weather/#{File.basename(wf[:file])}"
+            }
+          else
+            # log: could not find weather file
+            warn 'Could not resolve a valid weather file. Check paths to weather files'
+          end
+
+          h[:analysis][:file_format_version] = version
+
           # This is a hack right now, but after the initial hash is created go back and add in the objective functions
           # to the the algorithm as defined in the output_variables list
           ofs = @outputs.map { |i| i[:name] if i[:objective_function] }.compact
@@ -141,6 +185,36 @@ module OpenStudio
         end
       end
 
+      # Load the analysis JSON from a hash (with symbolized keys)
+      def self.from_hash(h, seed_dir = nil, weather_dir = nil)
+        o = OpenStudio::Analysis::Formulation.new(h[:analysis][:display_name])
+
+        version = 1
+        if version == 1
+          h[:analysis][:output_variables].each do |ov|
+            o.add_output(ov)
+          end
+
+          o.workflow = OpenStudio::Analysis::Workflow.load(workflow: h[:analysis][:problem][:workflow])
+
+          if weather_dir
+            o.weather_file "#{weather_path}/#{File.basename(h[:analysis][:weather_file][:path])}"
+          else
+            o.weather_file = h[:analysis][:weather_file][:path]
+          end
+
+          if seed_dir
+            o.seed_model "#{weather_path}/#{File.basename(h[:analysis][:seed][:path])}"
+          else
+            o.seed_model = h[:analysis][:seed][:path]
+          end
+        else
+          fail "Version #{version} not defined for #{self.class} and #{__method__}"
+        end
+
+        o
+      end
+
       # return a hash of the data point with the static variables set
       #
       # @param version [Integer] Version of the format to return
@@ -154,11 +228,11 @@ module OpenStudio
           end
 
           h = {
-              data_point: {
-                  set_variable_values: static_hash,
-                  status: 'na',
-                  uuid: SecureRandom.uuid
-              }
+            data_point: {
+              set_variable_values: static_hash,
+              status: 'na',
+              uuid: SecureRandom.uuid
+            }
           }
           h
         end
@@ -212,13 +286,12 @@ module OpenStudio
         FileUtils.rm_f(filename) if File.exist?(filename)
 
         Zip::File.open(filename, Zip::File::CREATE) do |zf|
-
           ## Weather files
           # TODO: eventually remove the @weather_file attribute and grab the weather file out
           # of the @weather_files
-          puts "Adding Support Files: Weather"
+          puts 'Adding Support Files: Weather'
           if @weather_file[:file] && !@weather_files.files.find { |f| @weather_file[:file] == f[:file] }
-            #manually add the weather file
+            # manually add the weather file
             puts "  Adding #{@weather_file[:file]}"
             zf.add("./weather/#{File.basename(@weather_file[:file])}", @weather_file[:file])
           end
@@ -228,9 +301,9 @@ module OpenStudio
           end
 
           ## Seed files
-          puts "Adding Support Files: Seed Models"
+          puts 'Adding Support Files: Seed Models'
           if @seed_model[:file] && !@seed_models.files.find { |f| @seed_model[:file] == f[:file] }
-            #manually add the weather file
+            # manually add the weather file
             puts "  Adding #{@seed_model[:file]}"
             zf.add("./seed/#{File.basename(@seed_model[:file])}", @seed_model[:file])
           end
@@ -239,7 +312,7 @@ module OpenStudio
             zf.add("./seed/#{File.basename(f[:file])}", f[:file])
           end
 
-          puts "Adding Support Files: Libraries"
+          puts 'Adding Support Files: Libraries'
           @libraries.each do |lib|
             fail "Libraries must specify their 'library_name' as metadata which becomes the directory upon zip" unless lib[:metadata][:library_name]
 
@@ -255,9 +328,8 @@ module OpenStudio
             end
           end
 
-          puts "Adding Support Files: Worker Initialization Scripts"
-          index = 0
-          @worker_inits.each do |f|
+          puts 'Adding Support Files: Worker Initialization Scripts'
+          @worker_inits.each_with_index do |f, index|
             ordered_file_name = "#{index.to_s.rjust(2, '0')}_#{File.basename(f[:file])}"
             puts "  Adding #{f[:file]} as #{ordered_file_name}"
             zf.add(f[:file].sub(f[:file], "./lib/worker_initialize/#{ordered_file_name}"), f[:file])
@@ -269,13 +341,10 @@ module OpenStudio
               zf.add("./lib/worker_initialize/#{arg_file}", file)
               file.close
             end
-
-            index += 1
           end
 
-          puts "Adding Support Files: Worker Finalization Scripts"
-          index = 0
-          @worker_finalizes.each do |f|
+          puts 'Adding Support Files: Worker Finalization Scripts'
+          @worker_finalizes.each_with_index do |f, index|
             ordered_file_name = "#{index.to_s.rjust(2, '0')}_#{File.basename(f[:file])}"
             puts "  Adding #{f[:file]} as #{ordered_file_name}"
             zf.add(f[:file].sub(f[:file], "./lib/worker_finalize/#{ordered_file_name}"), f[:file])
@@ -287,16 +356,14 @@ module OpenStudio
               zf.add("./lib/worker_finalize/#{arg_file}", file)
               file.close
             end
-
-            index += 1
           end
 
           ## Measures
-          puts "Adding Measures"
+          puts 'Adding Measures'
           added_measures = []
           # The list of the measures should always be there, but make sure they are uniq
           @workflow.each do |measure|
-            measure_dir_to_add = measure.measure_definition_directory
+            measure_dir_to_add = measure.measure_definition_directory_local
 
             next if added_measures.include? measure_dir_to_add
 
@@ -304,14 +371,13 @@ module OpenStudio
             Dir[File.join(measure_dir_to_add, '**')].each do |file|
               if File.directory?(file)
                 if File.basename(file) == 'resources' || File.basename(file) == 'lib'
-                  add_directory_to_zip(zf, file, "./measures/#{measure.name}/#{File.basename(file)}")
+                  add_directory_to_zip(zf, file, "#{measure.measure_definition_directory}/#{File.basename(file)}")
                 else
                   # puts "Skipping Directory #{File.basename(file)}"
                 end
               else
                 # puts "Adding File #{file}"
-                # added_measures << measure_dir unless added_measures.include? measure_dir
-                zf.add(file.sub(measure_dir_to_add, "./measures/#{measure.name}/"), file)
+                zf.add(file.sub(measure_dir_to_add, "#{measure.measure_definition_directory}/"), file)
               end
             end
 

data/lib/openstudio/analysis/server_api.rb

@@ -172,6 +172,44 @@ module OpenStudio
         status
       end
 
+      # Check if the machine is alive
+      #
+      # return [Boolean] True if the machine has an awake value set
+      def alive?
+        m = machine_status
+
+        m = !m[:status][:awake].nil? if m
+
+        m
+      end
+
+      # Retrieve the machine status
+      #
+      # return [Hash]
+      def machine_status
+        status = nil
+
+        begin
+          resp = @conn.get do |req|
+            req.url 'status.json'
+            req.options.timeout = 10
+            req.options.open_timeout = 10
+          end
+
+          if resp.status == 200
+            j = JSON.parse resp.body, symbolize_names: true
+            status = j if j
+          end
+
+        rescue Faraday::ConnectionFailed
+
+        rescue Net::ReadTimeout
+
+        end
+
+        status
+      end
+
       def get_analysis_status_and_json(analysis_id, analysis_type)
         status = nil
         j = nil
@@ -410,7 +448,7 @@ module OpenStudio
           analysis_id = SecureRandom.uuid
           formulation_json[:analysis][:uuid] = analysis_id
         end
-        fail "No analysis id defined in analyis.json #{options[:formulation_file]}" if analysis_id.nil?
+        fail "No analysis id defined in analysis.json #{options[:formulation_file]}" if analysis_id.nil?
 
         # save out this file to compare
         # File.open('formulation_merge.json', 'w') { |f| f << JSON.pretty_generate(formulation_json) }
@@ -503,7 +541,9 @@ 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 }
         options = defaults.merge(options)
 
@@ -522,6 +562,8 @@ module OpenStudio
         end
       end
 
+      alias_method :start_analysis, :run_analysis
+
       def kill_analysis(analysis_id)
         analysis_action = { analysis_action: 'stop' }
 
@@ -552,6 +594,28 @@ module OpenStudio
         end
       end
 
+      # Get a list of analyses and the data points
+      #
+      # @param analysis_id [String] An analysis ID
+      def data_point_status(analysis_id = nil)
+        data_points = nil
+        call_string = nil
+        if analysis_id
+          call_string = "analyses/#{analysis_id}/status.json"
+        else
+          call_string = 'analyses/status.json'
+        end
+
+        resp = @conn.get call_string, version: 2
+        if resp.status == 200
+          data_points = JSON.parse(resp.body, symbolize_names: true)[:analyses]
+        end
+
+        data_points
+      end
+
+      # This is the former version of get data point status. The new version is preferred and allows for
+      # checking data points across all analyses.
       def get_datapoint_status(analysis_id, filter = nil)
         data_points = nil
         # get the status of all the entire analysis
@@ -562,7 +626,7 @@ module OpenStudio
               data_points = JSON.parse(resp.body, symbolize_names: true)[:data_points]
             end
           else
-            resp = @conn.get "#{@hostname}/analyses/#{analysis_id}/status.json", jobs: filter
+            resp = @conn.get "analyses/#{analysis_id}/status.json", jobs: filter
             if resp.status == 200
               data_points = JSON.parse(resp.body, symbolize_names: true)[:data_points]
             end
@@ -586,6 +650,20 @@ module OpenStudio
 
       ## 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)
+      #
+      # @params formaluation_filename [String] FQP to the formulation file
+      # @params analysis_zip_filename [String] FQP to the zip file with the supporting files
+      def run_file(formulation_filename, analysis_zip_filename)
+        # parse the JSON file to grab the analysis type
+        j = JSON.parse(formulation_filename, symbolize_names: true)
+        analysis_type = j[:analysis][:problem][:analysis_type]
+
+        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 = {}
@@ -608,7 +686,7 @@ module OpenStudio
           simulate_data_point_filename: 'simulate_data_point.rb',
           run_data_point_filename: run_data_point_filename
         }
-        run_analysis(analysis_id, run_options)
+        start_analysis(analysis_id, run_options)
 
         run_options = {
           analysis_action: 'start',
@@ -619,7 +697,7 @@ module OpenStudio
           simulate_data_point_filename: 'simulate_data_point.rb',
           run_data_point_filename: run_data_point_filename
         }
-        run_analysis(analysis_id, run_options)
+        start_analysis(analysis_id, run_options)
 
         analysis_id
       end
@@ -645,7 +723,7 @@ module OpenStudio
           simulate_data_point_filename: 'simulate_data_point.rb',
           run_data_point_filename: 'run_openstudio_workflow_monthly.rb'
         }
-        run_analysis(analysis_id, run_options)
+        start_analysis(analysis_id, run_options)
 
         analysis_id
       end
@@ -670,7 +748,7 @@ module OpenStudio
           simulate_data_point_filename: 'simulate_data_point.rb',
           run_data_point_filename: 'run_openstudio_workflow_monthly.rb'
         }
-        run_analysis(analysis_id, run_options)
+        start_analysis(analysis_id, run_options)
 
         run_options = {
           analysis_action: 'start',
@@ -681,13 +759,15 @@ module OpenStudio
           simulate_data_point_filename: 'simulate_data_point.rb',
           run_data_point_filename: 'run_openstudio_workflow_monthly.rb'
         }
-        run_analysis(analysis_id, run_options)
+        start_analysis(analysis_id, run_options)
 
         analysis_id
       end
 
-      def run_analysis_detailed(formulation_filename, analysis_zip_filename,
-                                analysis_type, allow_multiple_jobs, server_as_worker, run_data_point_filename)
+      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)
 
@@ -708,11 +788,11 @@ module OpenStudio
           simulate_data_point_filename: 'simulate_data_point.rb',
           run_data_point_filename: run_data_point_filename
         }
-        run_analysis(analysis_id, run_options)
+        start_analysis(analysis_id, run_options)
 
         # If the analysis is LHS, then go ahead and run batch run because there is
         # no explicit way to tell the system to do it
-        if analysis_type == 'lhs' || analysis_type == 'preflight' || analysis_type == 'single_run'
+        if analysis_type == 'lhs' || analysis_type == 'preflight' || analysis_type == 'single_run' || analysis_type == 'doe'
           run_options = {
             analysis_action: 'start',
             without_delay: false,
@@ -722,11 +802,70 @@ module OpenStudio
             simulate_data_point_filename: 'simulate_data_point.rb',
             run_data_point_filename: run_data_point_filename
           }
-          run_analysis(analysis_id, run_options)
+          start_analysis(analysis_id, run_options)
         end
 
         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
+        }
+        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
+        }
+        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')
+        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' }}
+        }
+        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
+        }
+        start_analysis(analysis_id, run_options)
+
+        analysis_id
+      end
     end
   end
 end