openstudio-analysis 0.4.4 → 0.4.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e28750e00afea6e55e5852a8629ddf0e7cec2760
-  data.tar.gz: 8fdc2d023f6c151220fda7b06e5f01930cb4b379
+  metadata.gz: a460438de48ec2ba07da54a58e5c2b4df31495b0
+  data.tar.gz: 710522dfd0cb39a17a6f41dff61a11caf250776e
 SHA512:
-  metadata.gz: 00526e6a206c1721906344469701b526dd1cfa0d0693c3be8f79a5240239321f6339a010a149de13bf3edb673a07e4188afdff31e3dbbc3b27a0c35b8e63e624
-  data.tar.gz: 834f5922be6edb2f5cbf550c1e0d0bb6daa0ed3109538d440ebec09195efc753892238ba80cd9707d7790330760da42385516d0836c385eba0059cc6259087da
+  metadata.gz: 97237d9a0fdb49cc9b6e5cb400eaf7dd51b503de37bb457689b38ccbe7e2f977ac9cd8ed969bc8df5ce059bc2ba156ceb3f98b9846ead7002881ba5ab20e0959
+  data.tar.gz: f7a7cc8e3191c816cc41ed3b1fdfd3f8739eef45d4828c6f43b0ba62ea097214da807024bf249b77e48e4825e39b349b7467e1b6855551212d7186f2ab401e6d

data/.travis.yml

@@ -1,6 +1,4 @@
 language: ruby
 rvm:
-  - 2.0.0 
-  - 1.9.3
-  - jruby-19mode
-
+  - 2.0.0-p451
+  - 2.1

data/CHANGELOG.md

@@ -1,6 +1,13 @@
 OpenStudio Analysis Gem Change Log
 ==================================
 
+Version Unreleased 
+------------------
+* Add diag analysis type to server_api run method
+* Remove support for Rubies < 2.0.
+* Add json extension to formulation name upon save if none exists
+* Add zip extension to formulation zip upon save if none exists
+
 Version 0.4.4
 ------------------
 * Increment objective function count only if they are true

data/Gemfile

@@ -2,9 +2,12 @@ source 'http://rubygems.org'
 
 gemspec
 
+gem 'openstudio-aws', github: 'NREL/OpenStudio-aws-gem', branch: 'develop'
+gem 'colored', '~> 1.2'
+
 group :test do
   gem 'coveralls', require: false
-  gem 'rspec', '~> 3.3.0'
+  gem 'rspec', '~> 3.4'
   gem 'ci_reporter_rspec'
   gem 'rubocop', '~> 0.31'
   gem 'rubocop-checkstyle_formatter', '~> 0.2'

data/README.md

@@ -19,35 +19,52 @@ There are two ways to create an OpenStudio Analysis description:
 * Programmatically
 
 ```
-analysis = OpenStudio::Analysis.create
-analysis.seed_model = "local/dir/seed.osm"
-analysis.name = "Analysis Name"
+analysis = OpenStudio::Analysis.create('Analysis Name')
+analysis.seed_model = 'local/dir/seed.osm'
+analysis.weather_file = 'local/dir/USA_CO_Golden-NREL.724666_TMY3.epw'
 
 # override existing workflow from a file by
 analysis.workflow = OpenStudio::Analysis::Workflow.load_from_file(...)
 
 # add measures to the workflow
 wf = analysis.workflow
-wf.add_measure_from_path("path_to_measure")
-wf.add_measure_from_path("path_to_measure_2")
-
-# or allow the system to search for the measure based on default_measure_paths
-OpenStudio::Analysis.measure_paths = ['measures', '../project_specific_measures']
-wf.add_measure_by_name('measure_name')
+def add_measure_from_path(instance_name, instance_display_name, local_path_to_measure)
+wf.add_measure_from_path('instance_name', 'Display name', 'path_to_measure')
+wf.add_measure_from_path('instance_name_2', 'Display name two', 'path_to_measure_2')
 
 # make a measure's argument a variable
-m = wf.add_measure("path_to_measure_3")
+m = wf.add_measure_from_path('instance_name_3', 'Display name three', 'path_to_measure_3')
 m.make_variable('variable_argument_name', 'discrete')
 
-m = wf.add_measure('path_to_measure_4')
+m = wf.add_measure_from_path('instance_name_4', 'Display name four', 'path_to_measure_4')
 m.make_variable('variable_argument_name', 'pivot')
-m.argument_static_value('variable_argument_name', value)
+m.argument_value('variable_argument_name', value)
 
+# Save off the analysis files and a static data point
+run_dir = 'local/run'
+analysis.save("#{run_dir}/analysis.json")
+analysis.save_zip("#{run_dir}/analysis.zip")
+analysis.save_static_data_point("#{run_dir}/data_point.zip")
 ```
 
+If you would like to run the data point, then you can use the OpenStudio-workflow gem.
 
-## Testing
+```
+require 'openstudio-workflow'
+
+run_dir = 'local/run'
+OpenStudio::Workflow.extract_archive("#{run_dir}/analysis.zip", run_dir)
+
+options = {
+    problem_filename: 'analysis.json',
+    datapoint_filename: 'data_point.json',
+    analysis_root_path: run_dir
+}
+k = OpenStudio::Workflow.load 'Local', run_dir, options
+k.run
+```
 
+## Testing
 
 This gem used RSpec for testing.  To test simply run `rspec` at the command line.
 

data/lib/openstudio-analysis.rb

@@ -29,6 +29,7 @@ require 'openstudio/analysis/algorithm_attributes'
 
 # translators
 require 'openstudio/analysis/translator/excel'
+require 'openstudio/analysis/translator/datapoints'
 
 # helpers / core_ext
 require 'openstudio/helpers/string'

data/lib/openstudio/analysis.rb

@@ -20,5 +20,39 @@ module OpenStudio
       excel.process
       excel.analyses
     end
+
+    # Load an set of batch datapoints from a csv. This will create a analysis
+    # of type 'batch_datapoints' which requires 'batch_run'
+    def self.from_csv(filename)
+      csv = OpenStudio::Analysis::Translator::Datapoints.new(filename)
+      csv.process
+      csv.analysis
+    end
+
+    # Retrieve aws instance options from a project. This will return a hash
+    def self.aws_instance_options(filename)
+      if File.extname(filename) == '.xlsx'
+        excel = OpenStudio::Analysis::Translator::Excel.new(filename)
+        excel.process
+        options = {
+          os_server_version: excel.settings['openstudio_server_version'],
+          server_instance_type: excel.settings['server_instance_type'],
+          worker_instance_type: excel.settings['worker_instance_type'],
+          worker_node_number: excel.settings['worker_nodes'].to_i,
+          user_id: excel.settings['user_id'],
+          aws_tags: excel.aws_tags,
+          analysis_type: excel.analyses.first.analysis_type,
+          cluster_name: excel.cluster_name
+        }
+      elsif File.extname(filename) == '.csv'
+        csv = OpenStudio::Analysis::Translator::Datapoints.new(filename)
+        csv.process
+        options = csv.settings
+      else
+        fail 'Invalid file extension'
+      end
+
+      return options
+    end
   end
 end

data/lib/openstudio/analysis/formulation.rb

@@ -153,7 +153,7 @@ module OpenStudio
 
           if @seed_model[:file]
             h[:analysis][:seed] = {
-              file_type: File.extname(@seed_model[:file]).gsub('.', '').upcase,
+              file_type: File.extname(@seed_model[:file]).delete('.').upcase,
               path: "./seed/#{File.basename(@seed_model[:file])}"
             }
           else
@@ -171,7 +171,7 @@ module OpenStudio
 
           if wf
             h[:analysis][:weather_file] = {
-              file_type: File.extname(wf[:file]).gsub('.', '').upcase,
+              file_type: File.extname(wf[:file]).delete('.').upcase,
               path: "./weather/#{File.basename(wf[:file])}"
             }
           else
@@ -249,10 +249,12 @@ module OpenStudio
 
       # save the file to JSON. Will overwrite the file if it already exists
       #
-      # @param filename [String] Name of file to create. It will create the directory and override the file if it exists.
+      # @param filename [String] Name of file to create. It will create the directory and override the file if it exists. If no file extension is given, then it will use .json.
       # @param version [Integer] Version of the format to return
       # @return [Boolean]
       def save(filename, version = 1)
+        filename += '.json' if File.extname(filename) == ''
+
         FileUtils.mkdir_p File.dirname(filename) unless Dir.exist? File.dirname(filename)
         File.open(filename, 'w') { |f| f << JSON.pretty_generate(to_hash(version)) }
 
@@ -261,9 +263,13 @@ module OpenStudio
 
       # save the data point JSON with the variables set to the static values. Will overwrite the file if it already exists
       #
+      # @param filename [String] Name of file to create. It will create the directory and override the file if it exists. If no file extension is given, then it will use .json.
       # @param version [Integer] Version of the format to return
       # @return [Boolean]
       def save_static_data_point(filename, version = 1)
+        filename += '.json' if File.extname(filename) == ''
+
+        FileUtils.mkdir_p File.dirname(filename) unless Dir.exist? File.dirname(filename)
         File.open(filename, 'w') { |f| f << JSON.pretty_generate(to_static_data_point_hash(version)) }
 
         true
@@ -271,9 +277,11 @@ module OpenStudio
 
       # save the analysis zip file which contains the measures, seed model, weather file, and init/final scripts
       #
-      # @param filename [String] Name of file to create. It will create the directory and override the file if it exists.
+      # @param filename [String] Name of file to create. It will create the directory and override the file if it exists. If no file extension is given, then it will use .json.
       # @return [Boolean]
       def save_zip(filename)
+        filename += '.zip' if File.extname(filename) == ''
+
         FileUtils.mkdir_p File.dirname(filename) unless Dir.exist? File.dirname(filename)
 
         save_analysis_zip(filename)

data/lib/openstudio/analysis/server_api.rb

@@ -5,6 +5,9 @@ module OpenStudio
     class ServerApi
       attr_reader :hostname
 
+      # Define set of anlaysis methods require batch_run to be queued after them
+      BATCH_RUN_METHODS = %w(lhs preflight single_run repeat_run doe diag baseline_perturbation batch_datapoints)
+
       def initialize(options = {})
         defaults = { hostname: 'http://localhost:8080' }
         options = defaults.merge(options)
@@ -762,6 +765,80 @@ module OpenStudio
         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'
+        }
+        start_analysis(analysis_id, run_options)
+
+        analysis_id
+      end
+
       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')
@@ -774,6 +851,7 @@ module OpenStudio
           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'
@@ -790,7 +868,7 @@ module OpenStudio
 
         # 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 %w(lhs preflight single_run repeat_run doe).include? analysis_type
+        if BATCH_RUN_METHODS.include? analysis_type
           run_options = {
             analysis_action: 'start',
             without_delay: false,

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

@@ -0,0 +1,409 @@
+module OpenStudio
+  module Analysis
+    module Translator
+      class Datapoints
+        attr_reader :version
+        attr_reader :settings
+        attr_reader :variables
+        attr_reader :outputs
+        attr_reader :models
+        attr_reader :measure_paths
+        attr_reader :weather_paths
+        attr_reader :worker_inits
+        attr_reader :worker_finals
+        attr_reader :export_path
+        attr_reader :cluster_name
+        attr_reader :variables
+        attr_reader :algorithm
+        attr_reader :problem
+        attr_reader :run_setup
+        attr_reader :aws_tags
+
+        # remove these once we have classes to construct the JSON file
+        attr_accessor :name
+        attr_reader :analysis_name
+
+        # Methods to override instance variables
+
+        # Pass in the filename to read
+        def initialize(csv_filename)
+          @csv_filename = csv_filename
+          @root_path = File.expand_path(File.dirname(@csv_filename))
+
+          @csv = nil
+          # Try to read the spreadsheet as a roo object
+          if File.exist?(@csv_filename)
+            @csv = CSV.read(@csv_filename)
+          else
+            fail "File #{@csv_filename} does not exist"
+          end
+
+          # Remove nil rows and check row length
+          @csv.delete_if { |row| row.uniq.length == 1 && row.uniq[0].nil? }
+
+          # Initialize some other instance variables
+          @version = '0.0.1'
+          @analyses = [] # Array o OpenStudio::Analysis. Use method to access
+          @name = nil
+          @analysis_name = nil
+          @cluster_name = nil
+          @settings = {}
+          @weather_paths = []
+          @models = []
+          @other_files = []
+          @worker_inits = []
+          @worker_finals = []
+          @export_path = './export'
+          @measure_paths = []
+          @problem = {}
+          @algorithm = {}
+          @outputs = {}
+          @run_setup = {}
+          @aws_tags = []
+        end
+
+        def process
+          # Seperate CSV into meta and measure groups
+          measure_tag_index = nil
+          @csv.each_with_index { |row, index| measure_tag_index = index if row[0] == 'BEGIN-MEASURES' }
+          fail "ERROR: No 'BEGIN-MEASURES' tag found in input csv file." unless measure_tag_index
+          meta_rows = []
+          measure_rows = []
+          @csv.each_with_index do |_, index|
+            meta_rows << @csv[index] if index < measure_tag_index
+            measure_rows << @csv[index] if index > measure_tag_index
+          end
+
+          @setup = parse_csv_meta(meta_rows)
+
+          @version = Semantic::Version.new @version
+          fail "CSV interface version #{@version} is no longer supported.  Please upgrade your csv interface to at least 0.0.1" if @version < '0.0.0'
+
+          @variables = parse_csv_measures(measure_rows)
+
+          # call validate to make sure everything that is needed exists (i.e. directories)
+          validate_analysis
+        end
+
+        # Helper methods to remove models and add new ones programatically. Note that these should
+        # be moved into a general analysis class
+        def delete_models
+          @models = []
+        end
+
+        def add_model(name, display_name, type, path)
+          @models << {
+            name: name,
+            display_name: display_name,
+            type: type,
+            path: path
+          }
+        end
+
+        def validate_analysis
+          # Setup the paths and do some error checking
+          @measure_paths.each do |mp|
+            fail "Measures directory '#{mp}' does not exist" unless Dir.exist?(mp)
+          end
+
+          @models.uniq!
+          fail 'No seed models defined in spreadsheet' if @models.empty?
+
+          @models.each do |model|
+            fail "Seed model does not exist: #{model[:path]}" unless File.exist?(model[:path])
+          end
+
+          @weather_paths.uniq!
+          fail 'No weather files found based on what is in the spreadsheet' if @weather_paths.empty?
+
+          @weather_paths.each do |wf|
+            fail "Weather file does not exist: #{wf}" unless File.exist?(wf)
+          end
+
+          # This can be a directory as well
+          @other_files.each do |f|
+            fail "Other files do not exist for: #{f[:path]}" unless File.exist?(f[:path])
+          end
+
+          @worker_inits.each do |f|
+            fail "Worker initialization file does not exist for: #{f[:path]}" unless File.exist?(f[:path])
+          end
+
+          @worker_finals.each do |f|
+            fail "Worker finalization file does not exist for: #{f[:path]}" unless File.exist?(f[:path])
+          end
+
+          FileUtils.mkdir_p(@export_path)
+
+          # verify that the measure display names are unique
+          # puts @variables.inspect
+          measure_display_names = @variables.map { |m| m[:measure_data][:display_name] }.compact
+          measure_display_names_mult = measure_display_names.select { |m| measure_display_names.count(m) > 1 }.uniq
+          if measure_display_names_mult && !measure_display_names_mult.empty?
+            fail "Measure Display Names are not unique for '#{measure_display_names_mult.join('\', \'')}'"
+          end
+
+          variable_names = @variables.map { |v| v[:vars].map { |hash| hash[:display_name] } }.flatten
+          dupes = variable_names.select { |e| variable_names.count(e) > 1 }.uniq
+          if dupes.count > 0
+            fail "duplicate variable names found in list #{dupes.inspect}"
+          end
+        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
+        def analysis(seed_model = nil, append_model_name = false)
+          fail 'There are no seed models defined in the excel file. Please add one.' if @models.size == 0
+          fail 'There are more than one seed models defined in the excel file. This is not supported by the CSV Translator.' if @models.size > 1 && seed_model.nil?
+
+          seed_model = @models.first if seed_model.nil?
+
+          # Use the programmatic interface to make the analysis
+          # append the model name to the analysis name if requested (normally if there are more than 1 models in the spreadsheet)
+          display_name = append_model_name ? @name + ' ' + seed_model[:display_name] : @name
+
+          a = OpenStudio::Analysis.create(display_name)
+
+          @variables.each do |measure|
+            @measure_paths.each do |measure_path|
+              measure_dir_to_add = "#{measure_path}/#{measure[:measure_data][:classname]}"
+              if Dir.exist? measure_dir_to_add
+                if File.exist? "#{measure_dir_to_add}/measure.rb"
+                  measure[:measure_data][:local_path_to_measure] = "#{measure_dir_to_add}/measure.rb"
+                  break
+                else
+                  fail "Measure in directory '#{measure_dir_to_add}' did not contain a measure.rb file"
+                end
+              end
+            end
+
+            fail "Could not find measure '#{measure['name']}' in directory named '#{measure['measure_file_name_directory']}' in the measure paths '#{@measure_paths.join(', ')}'" unless measure[:measure_data][:local_path_to_measure]
+
+            a.workflow.add_measure_from_csv(measure)
+          end
+
+          @other_files.each do |library|
+            a.libraries.add(library[:path], library_name: library[:lib_zip_name])
+          end
+
+          @worker_inits.each do |w|
+            a.worker_inits.add(w[:path], args: w[:args])
+          end
+
+          @worker_finals.each do |w|
+            a.worker_finalizes.add(w[:path], args: w[:args])
+          end
+
+          # Add in the outputs
+          @outputs.each do |o|
+            o = Hash[o.map { |k, v| [k.to_sym, v] }]
+            a.add_output(o)
+          end
+
+          a.analysis_type = @problem['analysis_type']
+
+          # clear out the seed files before adding new ones
+          a.seed_model = seed_model[:path]
+
+          # clear out the weather files before adding new ones
+          a.weather_files.clear
+          @weather_paths.each do |wp|
+            a.weather_files.add_files(wp)
+          end
+
+          a
+        end
+
+        protected
+
+        def parse_csv_meta(meta_rows)
+          # Convert to hash
+          config_hash = {}
+          meta_rows.each do |row|
+            config_hash[row[0].to_sym] = row[1]
+          end
+
+          # Assign required attributes
+          fail 'Require setting not found: version' unless config_hash[:version]
+          @version = config_hash[:version]
+
+          if config_hash[:analysis_name]
+            @name = config_hash[:analysis_name]
+          else
+            @name = SecureRandom.uuid
+          end
+          @analysis_name = @name.snake_case
+
+          fail 'Require setting not found: measure_path' unless config_hash[:measure_paths]
+          config_hash[:measure_paths] = [config_hash[:measure_paths]] unless config_hash[:measure_paths].respond_to?(:each)
+          config_hash[:measure_paths].each do |path|
+            if (Pathname.new path).absolute?
+              @measure_paths << path
+            else
+              @measure_paths << File.expand_path(File.join(@root_path, path))
+            end
+          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].each do |path|
+            if (Pathname.new path).absolute?
+              @weather_paths << path
+            else
+              @weather_paths << File.expand_path(File.join(@root_path, path))
+            end
+          end
+
+          fail 'Required setting not found: models' unless config_hash[:models]
+          config_hash[:models] = [config_hash[:models]] unless config_hash[:models].respond_to?(:each)
+          config_hash[:models].each do |path|
+            model_name = File.basename(path).split('.')[0]
+            model_name = SecureRandom.uuid if model_name == ''
+            type = File.basename(path).split('.')[1].upcase
+            unless (Pathname.new path).absolute?
+              path = File.expand_path(File.join(@root_path, path))
+            end
+            @models << { name: model_name.snake_case, display_name: model_name, type: type, path: path }
+          end
+
+          # Assign optional attributes
+          if config_hash[:output]
+            path = File.expand_path(File.join(@root_path, config_hash[:output].to_s))
+            if File.exist? path
+              @outputs = MultiJson.load(File.read(path))
+            else
+              fail "Could not find output json: #{config_hash[:output]}"
+            end
+          end
+
+          if config_hash[:export_path]
+            if (Pathname.new config_hash[:export_path]).absolute?
+              @export_path = config_hash[:export_path]
+            else
+              @export_path = File.expand_path(File.join(@root_path, config_hash[:export_path]))
+            end
+          end
+
+          if config_hash[:library_path]
+            library_name = File.basename(config_hash[:library_path]).split('.')[0]
+            unless (Pathname.new config_hash[:library_path]).absolute?
+              config_hash[:library_path] = File.expand_path(File.join(@root_path, config_hash[:library_path]))
+            end
+            @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]
+
+          # Assign AWS settings
+          @settings[:proxy_port] = config_hash[:proxy_port] if config_hash[:proxy_port]
+          @settings[:cluster_name] = config_hash[:cluster_name] if config_hash[:cluster_name]
+          @settings[:user_id] = config_hash[:user_id] if config_hash[:user_id]
+          @settings[:os_server_version] = config_hash[:os_server_version] if config_hash[:os_server_version]
+          @settings[:server_instance_type] = config_hash[:server_instance_type] if config_hash[:server_instance_type]
+          @settings[:worker_instance_type] = config_hash[:worker_instance_type] if config_hash[:worker_instance_type]
+          @settings[:worker_node_number] = config_hash[:worker_node_number].to_i if config_hash[:worker_node_number]
+          @settings[:aws_tags] = config_hash[:aws_tags] if config_hash[:aws_tags]
+          @settings[:analysis_type] = 'batch_datapoints'
+        end
+
+        def parse_csv_measures(measure_rows)
+          # Build metadata required for parsing
+          measures = measure_rows[0].uniq.select { |measure| !measure.nil? }.map(&:to_sym)
+          measure_map = {}
+          measure_var_list = []
+          measures.each do |measure|
+            measure_map[measure] = {}
+            col_ind = (0..(measure_rows[0].length - 1)).to_a.select { |i| measure_rows[0][i] == measure.to_s }
+            col_ind.each do |var_ind|
+              tuple = measure.to_s + measure_rows[1][var_ind]
+              fail "Multiple measure_variable tuples found for '#{measure}_#{measure_rows[1][var_ind]}'. These tuples must be unique." if measure_var_list.include? tuple
+              measure_var_list << tuple
+              measure_map[measure][measure_rows[1][var_ind].to_sym] = var_ind
+            end
+          end
+
+          # For each measure load measure json and parse out critical variable requirements
+          data = []
+          measures.each_with_index do |measure, measure_index|
+            data[measure_index] = {}
+            measure_json = ''
+            for i in 0..(@measure_paths.length - 1)
+              if File.exist? File.join(@measure_paths[i], measure.to_s, 'measure.json')
+                measure_json = MultiJson.load(File.read(File.join(@measure_paths[i], measure.to_s, 'measure.json')))
+                break
+              end
+            end
+            fail "Could not find measure json #{measure}.json in measure_paths: '#{@measure_paths.join("\n")}'" if measure_json == ''
+            measure_data = {}
+            measure_data[:classname] = measure_json['classname']
+            measure_data[:name] = measure_json['name']
+            measure_data[:display_name] = measure_json['display_name']
+            measure_data[:measure_type] = measure_json['measure_type']
+            measure_data[:uid] = measure_json['uid']
+            measure_data[:version_id] = measure_json['version_id']
+            data[measure_index][:measure_data] = measure_data
+            data[measure_index][:vars] = []
+            vars = measure_map[measure]
+            vars.each do |var|
+              var = var[0]
+              var_hash = {}
+              var_json = measure_json['arguments'].select { |hash| hash['local_variable'] == var.to_s }[0]
+              fail "measure.json for measure #{measure} does not have an argument with local_variable == #{var}" if var_json.nil?
+              var_hash[:variable_type] = 'variable'
+              var_hash[:display_name] = measure_rows[2][measure_map[measure][var]]
+              var_hash[:display_name_short] = var_hash[:display_name]
+              var_hash[:name] = var_json['local_variable']
+              var_hash[:type] = var_json['variable_type'].downcase
+              var_hash[:units] = var_json['units']
+              var_hash[:distribution] = {}
+              case var_hash[:type].downcase
+                when 'bool', 'boolean' # is 'boolean' necessary? it's not in the enum catch
+                  var_hash[:distribution][:values] = (3..(measure_rows.length - 1)).map { |value| measure_rows[value.to_i][measure_map[measure][var]].to_s == 'true' }
+                  var_hash[:distribution][:maximum] = true
+                  var_hash[:distribution][:minimum] = false
+                  var_hash[:distribution][:mode] = var_hash[:distribution][:values].group_by { |i| i }.max { |x, y| x[1].length <=> y[1].length }[0]
+                when 'choice', 'string'
+                  var_hash[:distribution][:values] = (3..(measure_rows.length) - 1).map { |value| measure_rows[value.to_i][measure_map[measure][var]].to_s }
+                  var_hash[:distribution][:minimum] = var_hash[:distribution][:values].min
+                  var_hash[:distribution][:maximum] = var_hash[:distribution][:values].max
+                  var_hash[:distribution][:mode] = var_hash[:distribution][:values].group_by { |i| i }.max { |x, y| x[1].length <=> y[1].length }[0]
+                else
+                  var_hash[:distribution][:values] = (3..(measure_rows.length - 1)).map { |value| eval(measure_rows[value.to_i][measure_map[measure][var]]) }
+                  var_hash[:distribution][:minimum] = var_hash[:distribution][:values].map(&:to_i).min
+                  var_hash[:distribution][:maximum] = var_hash[:distribution][:values].map(&:to_i).max
+                  var_hash[:distribution][:mode] = var_hash[:distribution][:values].group_by { |i| i }.max { |x, y| x[1].length <=> y[1].length }[0]
+              end
+              var_hash[:distribution][:weights] = eval('[' + "#{1.0 / (measure_rows.length - 3)}," * (measure_rows.length - 3) + ']')
+              var_hash[:distribution][:type] = 'discrete'
+              var_hash[:distribution][:units] = var_hash[:units]
+              if var_hash[:type] == 'choice'
+                var_hash[:distribution][:enumerations] = var_json['choices']
+              elsif var_hash[:type] == 'bool'
+                var_hash[:distribution][:enumerations] = []
+                var_hash[:distribution][:enumerations] << 'true' # TODO: should this be a real bool?
+                var_hash[:distribution][:enumerations] << 'false'
+              end
+              data[measure_index][:vars] << var_hash
+            end
+            data[measure_index][:args] = []
+            measure_json['arguments'].each do |arg_json|
+              arg = {}
+              arg[:value_type] = arg_json['variable_type'].downcase
+              arg[:name] = arg_json['name']
+              arg[:display_name] = arg_json['display_name']
+              arg[:display_name_short] = arg_json['display_name']
+              arg[:default_value] = arg_json['default_value']
+              arg[:value] = arg_json['default_value']
+              data[measure_index][:args] << arg
+            end
+          end
+
+          data
+        end
+      end
+    end
+  end
+end