openstudio-analysis 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 900f442cddeeeaec5d3c46f05979c8e61c94df06
+  data.tar.gz: e4aa3cfea70f6b1a31730d5bd02b44e72ea7c254
+SHA512:
+  metadata.gz: 957702d15cac0c9c264c4b375e1387cc15d1f228420e7eccdf18a28fcb525f5edb11dcf70995679d6a13d0e2f55683528c82501fd655b638b6da2eeba8030149
+  data.tar.gz: 1b02cd2c8560babad1d18a8d4c9653f32c40b755c9e4c3639da010eb8006829cfdc744078edcebaaa6f8f611847d4926351784191bb43f3c1a7db3c1eac26187

data/README.md

@@ -0,0 +1,20 @@
+OpenStudio Analysis Gem
+=======================
+
+The OpenStudio Analysis Gem is used to communicate files to the OpenStudio Distributed Analysis.
+
+The purpose of this gem is to generate the analysis.json file, analysis.zip, and communicate with the server to upload 
+the simulations.
+
+The gem does not create the cluster (not launch it). Currently the only supported Cloud platform is
+Amazon AWS using either [OpenStudio's PAT](https://openstudio.nrel.gov) the [openstudio-aws gem](https://rubygems.org/gems/openstudio-aws) or using [vagrant](http://www.vagrantup.com/).
+
+Instructions
+------------
+
+Testing
+-------
+
+This gem used RSpec for testing.  To test simple run `rspec` at the command line.
+
+

data/Rakefile

@@ -0,0 +1,51 @@
+require "bundler"
+Bundler.setup
+
+require "rake"
+require "rspec/core/rake_task"
+
+$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
+require "openstudio/analysis/version"
+
+task :gem => :build
+task :build do
+  system "gem build openstudio-analysis.gemspec"
+end
+
+desc "build and install gem locally"
+task :install => :build do
+  system "gem install openstudio-analysis-#{OpenStudio::Analysis::VERSION}.gem --no-ri --no-rdoc"
+end
+
+task :release => :build do
+  system "git tag -a v#{OpenStudio::Analysis::VERSION} -m 'Tagging #{OpenStudio::Analysis::VERSION}'"
+  system "git push --tags"
+  system "gem push openstudio-analysis-#{OpenStudio::Analysis::VERSION}.gem"
+  system "rm openstudio-analysis-#{OpenStudio::Analysis::VERSION}.gem"
+end
+
+RSpec::Core::RakeTask.new("spec") do |spec|
+  spec.pattern = "spec/**/*_spec.rb"
+end
+
+RSpec::Core::RakeTask.new('spec:progress') do |spec|
+  spec.rspec_opts = %w(--format progress)
+  spec.pattern = "spec/**/*_spec.rb"
+end
+
+task :default => :spec
+
+desc "import files from other repos"
+task :import_files do
+  # tbd
+end
+
+desc "uninstall all openstudio-analysis gems"
+task :uninstall do
+
+  system "gem uninstall openstudio-analysis -a"
+end
+
+desc "reinstall the gem (uninstall, build, and reinstall"
+task :reinstall => [:uninstall, :install]
+

data/lib/openstudio-analysis.rb

@@ -0,0 +1,16 @@
+require 'json'
+require 'faraday'
+require 'uuid'
+require 'roo'
+require 'erb'
+require 'zip'
+
+# core
+require 'openstudio/analysis/server_api'
+require 'openstudio/analysis/version'
+
+# translators
+require 'openstudio/analysis/translator/excel'
+
+# helpers
+require 'openstudio/helpers/string'

data/lib/openstudio/analysis/server_api.rb

@@ -0,0 +1,302 @@
+# Class manages the communication with the server.  
+# Presently, this class is simple and stores all information in hashs
+module OpenStudio
+  module Analysis
+    class ServerApi
+      attr_reader :hostname
+
+      def initialize(options = {})
+        defaults = {:hostname => "http://localhost:8080"}
+        options = defaults.merge(options)
+        
+        @hostname = options[:hostname]
+
+        raise "no host defined for server api class" if @hostname.nil?
+
+        # create connection with basic capabilities
+        @conn = Faraday.new(:url => @hostname) do |faraday|
+          faraday.request :url_encoded # form-encode POST params
+          faraday.response :logger # log requests to STDOUT
+          faraday.adapter Faraday.default_adapter # make requests with Net::HTTP
+        end
+
+        # create connection to server api with multipart capabilities
+        @conn_multipart = Faraday.new(:url => @hostname) do |faraday|
+          faraday.request :multipart
+          faraday.request :url_encoded # form-encode POST params
+          faraday.response :logger # log requests to STDOUT
+          faraday.adapter Faraday.default_adapter # make requests with Net::HTTP
+        end
+      end
+
+      def get_projects()
+        response = @conn.get '/projects.json'
+
+        projects_json = nil
+        if response.status == 200
+          projects_json = JSON.parse(response.body, :symbolize_names => true, :max_nesting => false)
+        else
+          raise "did not receive a 200 in get_projects"
+        end
+
+        projects_json
+      end
+
+      def get_project_ids()
+        ids = get_projects()
+        ids.map { |project| project[:uuid] }
+      end
+
+      def delete_all()
+        ids = get_project_ids()
+        puts "Deleting Projects #{ids}"
+        ids.each do |id|
+          response = @conn.delete "/projects/#{id}.json"
+          if response.status == 200
+            puts "Successfully deleted project #{id}"
+          else
+            puts "ERROR deleting project #{id}"
+          end
+        end
+      end
+
+      def new_project(options = {})
+        defaults = {project_name: "project #{(rand()*1000).round}"}
+        options = defaults.merge(options)
+        project_id = nil
+
+        project_hash = {project: {name: "#{options[:project_name]}"}}
+
+        response = @conn.post do |req|
+          req.url "/projects.json"
+          req.headers['Content-Type'] = 'application/json'
+          req.body = project_hash.to_json
+        end
+
+        if response.status == 201
+          project_id = JSON.parse(response.body)["_id"]
+
+          puts "new project created with ID: #{project_id}"
+          #grab the project id
+        elsif response.code == 500
+          puts "500 Error"
+          puts response.inspect
+        end
+
+        project_id
+      end
+
+      def get_analyses(project_id)
+        analysis_ids = []
+        response = @conn.get "/projects/#{project_id}.json"
+        if response.status == 200
+          puts "received the list of analyses for the project"
+
+          analyses = JSON.parse(response.body, :symbolize_names => true, :max_nesting => false)
+          if analyses[:analyses]
+            analyses[:analyses].each do |analysis|
+              analysis_ids << analysis[:_id]
+            end
+          end
+        end
+
+        analysis_ids
+      end
+
+      def new_analysis(project_id, options)
+        defaults = {analysis_name: nil, reset_uuids: false}
+        options = defaults.merge(options)
+
+        raise "No project id passed" if project_id.nil?
+        raise "no formulation passed to new_analysis" if !options[:formulation_file]
+        raise "No formation exists #{options[:formulation_file]}" if !File.exists?(options[:formulation_file])
+
+        formulation_json = JSON.parse(File.read(options[:formulation_file]), :symbolize_names => true)
+
+        # read in the analysis id from the analysis.json file
+        analysis_id = nil
+        if options[:reset_uuids]
+          analysis_id = UUID.new.generate
+          formulation_json[:analysis][:uuid] = analysis_id
+
+          formulation_json[:analysis][:problem][:workflow].each do |wf|
+            wf[:uuid] = UUID.new.generate
+            if wf[:arguments]
+              wf[:arguments].each do |arg|
+                arg[:uuid] = UUID.new.generate
+              end
+            end
+            if wf[:variables]
+              wf[:variables].each do |var|
+                var[:uuid] = UUID.new.generate
+                if var[:argument]
+                  var[:argument][:uuid] = UUID.new.generate
+                end
+              end
+            end
+          end
+        else
+          analysis_id = formulation_json[:analysis][:uuid]
+        end
+        raise "No analysis id defined in analyis.json #{options[:formulation_file]}" if analysis_id.nil?
+
+        # set the analysis name
+        formulation_json[:analysis][:name] = "#{options[:analysis_name]}" unless options[:analysis_name].nil?
+
+        # save out this file to compare
+        #File.open('formulation_merge.json', 'w') { |f| f << JSON.pretty_generate(formulation_json) }
+
+        response = @conn.post do |req|
+          req.url "projects/#{project_id}/analyses.json"
+          req.headers['Content-Type'] = 'application/json'
+          req.body = formulation_json.to_json
+        end
+
+        if response.status == 201
+          puts "asked to create analysis with #{analysis_id}"
+          #puts resp.inspect
+          analysis_id = JSON.parse(response.body)["_id"]
+
+          puts "new analysis created with ID: #{analysis_id}"
+        else
+          raise "Could not create new analysis"
+        end
+
+        # check if we need to upload the analysis zip file
+        if options[:upload_file]
+          raise "upload file does not exist #{options[:upload_file]}" if !File.exists?(options[:upload_file])
+
+          payload = {:file => Faraday::UploadIO.new(options[:upload_file], 'application/zip')}
+          response = @conn_multipart.post "analyses/#{analysis_id}/upload.json", payload
+
+          if response.status == 201
+            puts "Successfully uploaded ZIP file"
+          else
+            raise response.inspect
+          end
+        end
+
+        analysis_id
+      end
+
+      def upload_datapoint(analysis_id, options)
+        defaults = {reset_uuids: false}
+        options = defaults.merge(options)
+
+        raise "No analysis id passed" if analysis_id.nil?
+        raise "No datapoints file passed to new_analysis" if !options[:datapoint_file]
+        raise "No datapoints_file exists #{options[:datapoint_file]}" if !File.exists?(options[:datapoint_file])
+
+        dp_hash = JSON.parse(File.open(options[:datapoint_file]).read, :symbolize_names => true)
+
+        if options[:reset_uuids]
+          dp_hash[:analysis_uuid] = analysis_id
+          dp_hash[:uuid] = UUID.new.generate
+        end
+
+        # merge in the analysis_id as it has to be what is in the database
+        response = @conn.post do |req|
+          req.url "analyses/#{analysis_id}/data_points.json"
+          req.headers['Content-Type'] = 'application/json'
+          req.body = dp_hash.to_json
+        end
+
+        if response.status == 201
+          puts "new datapoints created for analysis #{analysis_id}"
+        else
+          raise "could not create new datapoints #{response.body}"
+        end
+      end
+
+      def upload_datapoints(analysis_id, options)
+        defaults = {}
+        options = defaults.merge(options)
+
+        raise "No analysis id passed" if analysis_id.nil?
+        raise "No datapoints file passed to new_analysis" if !options[:datapoints_file]
+        raise "No datapoints_file exists #{options[:datapoints_file]}" if !File.exists?(options[:datapoints_file])
+
+        dp_hash = JSON.parse(File.open(options[:datapoints_file]).read, :symbolize_names => true)
+
+        # merge in the analysis_id as it has to be what is in the database
+        response = @conn.post do |req|
+          req.url "analyses/#{analysis_id}/data_points/batch_upload.json"
+          req.headers['Content-Type'] = 'application/json'
+          req.body = dp_hash.to_json
+        end
+
+        if response.status == 201
+          puts "new datapoints created for analysis #{analysis_id}"
+        else
+          raise "could not create new datapoints #{response.body}"
+        end
+      end
+
+      def run_analysis(analysis_id, options)
+        defaults = {analysis_action: "start", without_delay: false}
+        options = defaults.merge(options)
+
+        puts "Run analysis is configured with #{options.to_json}"
+        response = @conn.post do |req|
+          req.url "analyses/#{analysis_id}/action.json"
+          req.headers['Content-Type'] = 'application/json'
+          req.body = options.to_json
+          req.options[:timeout] = 1800 #seconds
+        end
+
+        if response.status == 200
+          puts "Recieved request to run analysis #{analysis_id}"
+        else
+          raise "Could not start the analysis"
+        end
+      end
+
+      def kill_analysis(analysis_id)
+        analysis_action = {analysis_action: "stop"}
+
+        response = @conn.post do |req|
+          req.url "analyses/#{analysis_id}/action.json"
+          req.headers['Content-Type'] = 'application/json'
+          req.body = analysis_action.to_json
+        end
+
+        if response.status == 200
+          puts "Killed analysis #{analysis_id}"
+        else
+          #raise "Could not kill the analysis with response of #{response.inspect}"
+        end
+
+      end
+
+      def kill_all_analyses
+        project_ids = get_project_ids
+        puts "List of projects ids are: #{project_ids}"
+
+        project_ids.each do |project_id|
+          analysis_ids = get_analyses(project_id)
+          puts analysis_ids
+          analysis_ids.each do |analysis_id|
+            puts "Trying to kill #{analysis_id}"
+            kill_analysis(analysis_id)
+          end
+        end
+      end
+
+
+      def get_datapoint_status(analysis_id, filter = nil)
+        # get the status of all the entire analysis
+        if !analysis_id.nil?
+          if filter.nil? || filter == ""
+            resp = @conn.get "analyses/#{analysis_id}/status.json"
+            puts "Data points (all): #{resp}"
+          else
+            resp = @conn.get "#{@hostname}/analyses/#{analysis_id}/status.json", {jobs: filter}
+            puts "Data points (#{filter}): #{resp}"
+          end
+        end
+      end
+
+    end
+  end
+
+end

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

@@ -0,0 +1,366 @@
+module OpenStudio
+  module Analysis
+    module Translator
+      class Excel
+        attr_reader :variables
+        attr_reader :models
+        attr_reader :weather_files
+
+        # remove these once we have classes to construct the JSON file
+        attr_reader :name
+        attr_reader :number_of_samples
+
+        # pass in the filename to read
+        def initialize(xls_filename)
+          @root_path = File.expand_path(File.dirname(xls_filename))
+
+          @xls = nil
+          # try to read the spreadsheet as a roo object
+          if File.exists?(xls_filename)
+            @xls = Roo::Spreadsheet.open(xls_filename)
+          else
+            raise "File #{xls_filename} does not exist"
+          end
+
+          # Initialize some other instance variables
+          @weather_files = []
+          @models = []
+          @other_files = []
+          @export_path = "./export"
+          @measure_path = "./measures"
+          @number_of_samples = 0
+
+          @setup = parse_setup()
+          @variables = parse_variables()
+
+          # call validate to make sure everything that is needed exists (i.e. directories)          
+          validate_analysis()
+        end
+
+        # Save off the legacy format of the JSON file
+        def save_variable_json(filename)
+          FileUtils.rm_f(filename) if File.exists?(filename)
+          File.open(filename, 'w') { |f| f << JSON.pretty_generate(@variables) }
+        end
+
+
+        def validate_analysis
+          # Setup the paths and do some error checking
+          raise "Measures directory '#{@measure_path}' does not exist" unless Dir.exists?(@measure_path)
+
+          @models.uniq!
+          raise "No seed models defined in spreadsheet" if @models.empty?
+
+          @models.each do |model|
+            raise "Seed model does not exist: #{model[:path]}" unless File.exists?(model[:path])
+          end
+
+          @weather_files.uniq!
+          raise "No weather files found based on what is in the spreadsheet" if @weather_files.empty?
+
+          @weather_files.each do |wf|
+            raise "Weather file does not exist: #{wf}" unless File.exists?(wf)
+          end
+
+          # This can be a directory as well
+          @other_files.each do |of|
+            raise "Other files do not exist for: #{of[:path]}" unless File.exists?(of[:path])
+          end
+
+          FileUtils.mkdir_p(@export_path)
+        end
+
+        def save_analysis
+          # save the format in the OpenStudio analysis json format
+          new_json = translate_to_analysis_json()
+
+          # iterate over each model and save the zip and json
+          @models.each do |model|
+            save_analysis_zip(model)
+            save_analysis_json(new_json, model)
+          end
+        end
+
+        protected
+
+        # helper method for ERB
+        def get_binding
+          binding
+        end
+        
+        # TODO: move this into a new class that helps construct this file
+        def translate_to_analysis_json
+          # Load in the templates for constructing the JSON file
+          template_root = File.join(File.dirname(__FILE__), "../../templates")
+          analysis_template = ERB.new(File.open("#{template_root}/analysis.json.erb", 'r').read)
+          workflow_template = ERB.new(File.open("#{template_root}/workflow_item.json.erb", 'r').read)
+          uncertain_variable_template = ERB.new(File.open("#{template_root}/uncertain_variable.json.erb", 'r').read)
+          discrete_uncertain_variable_template = ERB.new(File.open("#{template_root}/discrete_uncertain_variable.json.erb", 'r').read)
+          static_variable_template = ERB.new(File.open("#{template_root}/static_variable.json.erb", 'r').read)
+          pivot_variable_template = ERB.new(File.open("#{template_root}/pivot_variable.json.erb", 'r').read)
+          argument_template = ERB.new(File.open("#{template_root}/argument.json.erb", 'r').read)
+
+          # Templated analysis json file (this is what is returned)
+          puts "Analysis name is #{@name}"
+          openstudio_analysis_json = JSON.parse(analysis_template.result(get_binding))
+
+          @measure_index = -1
+          @variables['data'].each do |measure|
+            # With OpenStudio server we need to create the workflow with all the measure instances
+            if measure['enabled'] && measure['name'] != 'baseline'
+              @measure_index += 1
+
+              puts "  Adding measure item '#{measure['name']}'"
+              @measure = measure
+              @measure['measure_file_name_dir'] = @measure['measure_file_name'].underscore
+
+              # Grab the measure json file out of the right directory
+              wf = JSON.parse(workflow_template.result(get_binding))
+
+              # add in the variables
+              measure['variables'].each do |variable|
+                @variable = variable
+
+                # Determine if row is suppose to be an argument or a variable to be perturbed.
+                if @variable['variable_type'] == 'argument'
+                  ag = nil
+                  if @variable['method'] == 'static'
+                    # add this as an argument
+                    ag = JSON.parse(argument_template.result(get_binding))
+                  elsif raise "can not have an argument without having a static value defined in which to set the argument"
+                  end
+                  wf['arguments'] << ag
+                else
+                  vr = nil
+                  if @variable['method'] == 'static'
+                    # add this as an argument
+                    vr = JSON.parse(static_variable_template.result(get_binding))
+                  elsif @variable['method'] == 'lhs'
+                    if @variable['type'] == 'enum'
+                      @values_and_weights = @variable['distribution']['enumerations'].map { |v| {value: v} }.to_json
+                      vr =JSON.parse(discrete_uncertain_variable_template.result(get_binding))
+                    else
+                      vr = JSON.parse(uncertain_variable_template.result(get_binding))
+                    end
+                  elsif @variable['method'] == 'pivot'
+                    @values_and_weights = @variable['distribution']['enumerations'].map { |v| {value: v} }.to_json
+                    vr =JSON.parse(pivot_variable_template.result(get_binding))
+                  end
+                  wf['variables'] << vr
+                end
+              end
+
+              openstudio_analysis_json['analysis']['problem']['workflow'] << wf
+            end
+          end
+
+          openstudio_analysis_json
+        end
+
+        # Package up the seed, weather files, and measures
+        def save_analysis_zip(model)
+          zipfile_name = "#{@export_path}/#{model[:name]}.zip"
+          FileUtils.rm_f(zipfile_name) if File.exists?(zipfile_name)
+
+          Zip::File.open(zipfile_name, Zip::File::CREATE) do |zipfile|
+            @weather_files.each do |filename|
+              puts "  Adding #{filename}"
+              zipfile.add("./weather/#{File.basename(filename)}", filename)
+            end
+
+            Dir.glob("#{@measure_path}/**/*.rb").each do |measure|
+              next if measure.include?("spec") # don't include the spec folders nor files
+              measure_name = measure.split(File::SEPARATOR).last(2).first
+              puts "  Adding ./measures/#{measure_name}/#{File.basename(measure)}"
+              zipfile.add("./measures/#{measure_name}/#{File.basename(measure)}", measure)
+            end
+
+            puts "Adding #{model[:path]}"
+            zipfile.add("./seed/#{File.basename(model[:path])}", model[:path])
+
+            puts "Adding in other files #{@other_files.inspect}"
+            @other_files.each do |others|
+              Dir[File.join(others[:path], '**', '**')].each do |file|
+                zipfile.add(file.sub(others[:path], "./lib/#{others[:lib_zip_name]}/"), file)
+              end
+            end
+          end
+        end
+
+        def save_analysis_json(analysis_json, model)
+          # Set the seed model in the analysis_json
+          analysis_json['analysis']['seed']['file_type'] = model[:type]
+          # This is the path that will be seen on the server when this runs
+          analysis_json['analysis']['seed']['path'] = "./seed/#{File.basename(model[:path])}"
+
+          # Set the weather file as the first in the list -- this is optional
+          # TODO: check if epw or if zip file
+          analysis_json['analysis']['weather_file']['file_type'] = 'EPW'
+          analysis_json['analysis']['weather_file']['path'] = "./weather/#{File.basename(@weather_files.first, '.zip')}.epw"
+
+          json_file_name = "#{@export_path}/#{model[:name]}.json"
+          FileUtils.rm_f(json_file_name) if File.exists?(json_file_name)
+
+          File.open("#{@export_path}/#{model[:name]}.json", "w") { |f| f << JSON.pretty_generate(analysis_json) }
+        end
+
+
+        # parse_setup will pull out the data on the "setup" tab and store it in memory for later use
+        def parse_setup()
+          rows = @xls.sheet('Setup').parse()
+          b_run_setup = false
+          b_problem_setup = false
+          b_weather_files = false
+          b_models = false
+          b_other_libs = false
+
+          rows.each do |row|
+            if row[0] == "Running Setup"
+              b_run_setup = true
+              b_problem_setup = false
+              b_weather_files = false
+              b_models = false
+              b_other_libs = false
+              next
+            elsif row[0] == "Problem Definition"
+              b_run_setup = false
+              b_problem_setup = true
+              b_weather_files = false
+              b_models = false
+              b_other_libs = false
+              next
+            elsif row[0] == "Weather Files"
+              b_run_setup = false
+              b_problem_setup = false
+              b_weather_files = true
+              b_models = false
+              b_other_libs = false
+              next
+            elsif row[0] == "Models"
+              b_run_setup = false
+              b_problem_setup = false
+              b_weather_files = false
+              b_models = true
+              b_other_libs = false
+              next
+            elsif row[0] == "Other Library Files"
+              b_run_setup = false
+              b_problem_setup = false
+              b_weather_files = false
+              b_models = false
+              b_other_libs = true
+              next
+            end
+
+            next if row[0].nil?
+
+            if b_run_setup
+              @name = row[1].chomp if row[0] == "Analysis Name"
+              @export_path = File.expand_path(File.join(@root_path, row[1])) if row[0] == "Export Directory"
+              @measure_path = File.expand_path(File.join(@root_path, row[1])) if row[0] == "Measure Directory"
+            elsif b_problem_setup
+              @number_of_samples = row[1].to_i if row[0] == "Number of Samples"
+            elsif b_weather_files
+              if row[0] == "Weather File"
+                @weather_files += Dir.glob(File.expand_path(File.join(@root_path, row[1])))
+              end
+            elsif b_models
+              @models << {name: row[1], type: row[2], path: File.expand_path(File.join(@root_path, row[3]))}
+            elsif b_other_libs
+              @other_files << {lib_zip_name: row[1], path: row[2]}
+            end
+          end
+        end
+
+
+        # parse_variables will parse the XLS spreadsheet and save the data into
+        # a higher level JSON file.  The JSON file is historic and it should really 
+        # be omitted as an intermediate step
+        def parse_variables()
+          rows = @xls.sheet('Sensitivity').parse()
+          data = {}
+          data['data'] = []
+
+          icnt = 0
+          measure_index = -1
+          variable_index = -1
+          measure_name = nil
+          rows.each do |row|
+            icnt += 1
+            # puts "Parsing line: #{icnt}"
+            next if icnt <= 3 # skip the first 3 lines of the file
+
+            # check if we are a measure
+            if row[0].nil?
+              unless measure_name.nil?
+                variable_index += 1
+
+                var = {}
+                var['variable_type'] = row[1]
+                var['display_name'] = row[2].strip
+                var['machine_name'] = var['display_name'].downcase.strip.gsub("-", "_").gsub(" ", "_").strip
+                var['name'] = row[3].strip
+                var['index'] = variable_index #order of the variable (eventually use to force order of applying measures)
+
+                var['method'] = row[4]
+                var['type'] = row[5]
+                var['units'] = row[6]
+
+                var['distribution'] = {}
+
+                #parse the enums
+                if var['type'] == 'enum'
+                  var['distribution']['enumerations'] = row[8].gsub("|", "").split(",").map { |v| v.strip }
+                elsif var['type'] == 'bool' #TODO: i think this has been deprecated
+                  var['distribution']['enumerations'] = []
+                  var['distribution']['enumerations'] << 'true'
+                  var['distribution']['enumerations'] << 'false'
+                end
+
+                if var['method'] == 'lhs'
+                  var['distribution']['min'] = row[9]
+                  var['distribution']['max'] = row[10]
+                  var['distribution']['mean'] = row[11]
+                  var['distribution']['stddev'] = row[12]
+                  var['distribution']['type'] = row[13]
+                  var['distribution']['source'] = row[14]
+                elsif var['method'] == 'static'
+                  var['distribution']['static_value'] = row[7]
+                  #var['distribution']['apply_method'] = row[14]
+                  var['distribution']['source'] = row[14]
+                end
+
+                var['notes'] = row[15]
+                var['relation_to_eui'] = row[16]
+
+                data['data'][measure_index]['apply_method'] ||= row[14]
+                data['data'][measure_index]['variables'] << var
+              end
+            else
+              measure_index += 1
+              variable_index = 0
+              data['data'][measure_index] = {}
+
+              #generate name id
+              puts "Parsing measure #{row[1]}"
+              display_name = row[1].chomp.strip
+              measure_name = display_name.downcase.strip.gsub("-", "_").gsub(" ", "_")
+              data['data'][measure_index]['display_name'] = display_name
+              data['data'][measure_index]['name'] = measure_name
+              data['data'][measure_index]['enabled'] = row[0] == "TRUE" ? true : false
+              data['data'][measure_index]['measure_file_name'] = row[2]
+              data['data'][measure_index]['measure_file_name_directory'] = row[2].underscore
+              data['data'][measure_index]['version'] = @version_id
+
+              data['data'][measure_index]['variables'] = []
+
+            end
+          end
+
+          data
+        end
+
+      end
+    end
+  end
+end

data/lib/openstudio/analysis/version.rb

@@ -0,0 +1,6 @@
+module OpenStudio
+  module Analysis
+    VERSION = "0.1"
+    OPENSTUDIO_VERSION = "1.1.2"
+  end
+end

data/lib/openstudio/helpers/string.rb

@@ -0,0 +1,12 @@
+# add the underscore from rails for snake_casing strings
+
+class String
+  def underscore
+    self.gsub(/::/, '/').
+        gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').
+        gsub(/([a-z\d])([A-Z])/, '\1_\2').
+        tr("-", "_").
+        downcase
+  end
+end
+                     

data/lib/openstudio/templates/analysis.json.erb

@@ -0,0 +1,26 @@
+{
+    "analysis": {
+        "display_name":  "<%= @name %>",
+        "name": "<%= @name.downcase.gsub(" ", "_") %>",
+        "algorithm": {
+            "sample_method": "lhs",
+            "sensitivity_method": "single_measure",
+            "number_of_samples": <%= @number_of_samples %>
+        },
+        "parameter_space": [],
+        "problem": {
+            "number_of_samples_KEEP_HERE_UNTIL_ALGO_IS_IMPLEMENTED": <%= @number_of_samples %>,
+            "number_of_samples": <%= @number_of_samples %>,
+            "name": "Problem",
+            "workflow": []
+        },
+        "seed": {
+            "file_type": "xml",
+            "path": "unknown"
+        },
+        "weather_file": {
+            "file_type": "EPW",
+            "path": "unknown"
+        }
+    }
+}

data/lib/openstudio/templates/argument.json.erb

@@ -0,0 +1,10 @@
+{
+    "display_name": "<%= @variable['display_name'] %>",
+    "machine_name": "<%= @variable['machine_name'] %>",
+    "name": "<%= @variable['name'] %>",
+    "value": "<%= @variable['distribution']['static_value'] %>",
+    "uuid_DELETEME": "<%= UUID.new.generate %>",
+    "uuid": "<%= UUID.new.generate %>",
+    "version_uuid_DELETEME": "<%= UUID.new.generate %>",
+    "version_uuid": "<%= UUID.new.generate %>"
+}

data/lib/openstudio/templates/discrete_uncertain_variable.json.erb

@@ -0,0 +1,32 @@
+{
+    "argument": {
+        "display_name": "<%= @variable['display_name'] %>",
+        "machine_name": "<%= @variable['machine_name'] %>",
+        "name": "<%= @variable['name'] %>",
+        "required": false,
+        "uuid": "a0618d15-bb0b-4494-a72f-8ad628693a7e",
+        "version_uuid": "b33cf6b0-f1aa-4706-afab-9470e6bd1912"
+    },
+    "display_name": "<%= @variable['display_name'] %>",
+    "machine_name": "<%= @variable['machine_name'] %>",
+    "name": "<%= @variable['machine_name'] %>",
+    "units": "<%= @variable['units'] %>",
+    "variable": true,
+    "variable_ADDME": true,
+    "relation_to_output": "<%= @variable['relation_to_eui'] %>",
+    "uncertainty_description": {
+        "attributes": [
+            {
+                "name": "discrete",
+                "values_and_weights":
+                    <%= @values_and_weights %>
+            }
+        ],
+        "type": "discrete_uncertain"
+    },
+    "uuid": "d157d709-b83e-42bd-bd30-1bc3a7979672",
+    "variable_type": "RubyContinuousVariable",
+    "version_uuid": "26e7d8de-83e3-4a53-938b-45d3e0f29953"
+}
+
+

data/lib/openstudio/templates/pivot_variable.json.erb

@@ -0,0 +1,31 @@
+{
+    "argument": {
+        "display_name": "<%= @variable['display_name'] %>",
+        "name": "<%= @variable['name'] %>",
+        "required": false,
+        "uuid": "a0618d15-bb0b-4494-a72f-8ad628693a7e",
+        "version_uuid": "b33cf6b0-f1aa-4706-afab-9470e6bd1912"
+    },
+    "display_name": "<%= @variable['display_name'] %>",
+    "machine_name": "<%= @variable['machine_name'] %>",
+    "name": "<%= @variable['machine_name'] %>",
+    "units": "<%= @variable['units'] %>",
+    "pivot": true,
+    "pivot_ADDME": true,
+    "relation_to_output": null,
+    "uncertainty_description": {
+        "attributes": [
+            {
+                "name": "discrete",
+                "values_and_weights":
+                  <%= @values_and_weights %>
+            }
+        ],
+        "type": "discrete_uncertain"
+    },
+    "uuid": "d157d709-b83e-42bd-bd30-1bc3a7979672",
+    "variable_type": "RubyContinuousVariable",
+    "version_uuid": "26e7d8de-83e3-4a53-938b-45d3e0f29953"
+}
+
+

data/lib/openstudio/templates/static_variable.json.erb

@@ -0,0 +1,22 @@
+{
+    "argument": {
+        "display_name": "<%= @variable['display_name'] %>",
+        "machine_name": "<%= @variable['machine_name'] %>",
+        "name": "<%= @variable['name'] %>",
+        "uuid": "<%= UUID.new.generate %>",
+        "version_uuid": "b33cf6b0-f1aa-4706-afab-9470e6bd1912"
+    },
+    "display_name": "<%= @variable['display_name'] %>",
+    "machine_name": "<%= @variable['machine_name'] %>",
+    "name": "<%= @variable['machine_name'] %>",
+    "units": "<%= @variable['units'] %>",
+    "static": true,
+    "static_ADDME": true,
+    "relation_to_output": "<%= @variable['relation_to_eui'] %>",
+    "relation_to_output_ADDME": "<%= @variable['relation_to_eui'] %>",
+    "static_value": <%= @variable['distribution']['static_value'].inspect %>,
+    "static_value_ADDME": <%= @variable['distribution']['static_value'].inspect %>,
+    "uuid": "d157d709-b83e-42bd-bd30-1bc3a7979672",
+    "variable_type": "RubyContinuousVariable",
+    "version_uuid": "26e7d8de-83e3-4a53-938b-45d3e0f29953"
+}

data/lib/openstudio/templates/uncertain_variable.json.erb

@@ -0,0 +1,42 @@
+{
+    "argument": {
+        "display_name": "<%= @variable['display_name'] %>",
+        "machine_name": "<%= @variable['machine_name'] %>",
+        "name": "<%= @variable['name'] %>",
+        "uuid": "a0618d15-bb0b-4494-a72f-8ad628693a7e",
+        "version_uuid": "b33cf6b0-f1aa-4706-afab-9470e6bd1912"
+    },
+    "display_name": "<%= @variable['display_name'] %>",
+    "machine_name": "<%= @variable['machine_name'] %>",
+    "name": "<%= @variable['machine_name'] %>",
+    "minimum": <%= @variable['distribution']['min'].inspect %>,
+    "maximum": <%= @variable['distribution']['max'].inspect %>,
+    "units": "<%= @variable['units'] %>",
+    "variable": true,
+    "variable_ADDME": true,
+    "relation_to_output": "<%= @variable['relation_to_eui'] %>",
+    "uncertainty_description": {
+        "attributes": [
+            {
+                "name": "modes",
+                "value": <%= @variable['distribution']['mean'] %>
+            },
+            {
+                "name": "lower_bounds",
+                "value": <%= @variable['distribution']['min'] %>
+            },
+            {
+                "name": "upper_bounds",
+                "value": <%= @variable['distribution']['max'] %>
+            },
+            {
+                "name": "stddev",
+                "value": <%= @variable['distribution']['stddev'] %>
+            }
+        ],
+        "type": <%= @variable['distribution']['type'].inspect %>
+    },
+    "uuid": "d157d709-b83e-42bd-bd30-1bc3a7979672",
+    "variable_type": "RubyContinuousVariable",
+    "version_uuid": "26e7d8de-83e3-4a53-938b-45d3e0f29953"
+}

data/lib/openstudio/templates/workflow_item.json.erb

@@ -0,0 +1,19 @@
+{
+    "arguments": [],
+    "bcl_measure_directory": "./measures/<%= @measure['measure_file_name_directory'] %>",
+    "measure_definition_directory_CHANGE_TO_ME": "./measures/<%= @measure['measure_file_name_directory'] %>",
+    "bcl_measure_class_name_ADDME": "<%= @measure['measure_file_name'] %>",
+    "measure_definition_class_name_CHANGE_TO_ME": "<%= @measure['measure_file_name'] %>",
+    "bcl_measure_uuid": "<%= UUID.new.generate %>",
+    "measure_definition_uuid_CHANGE_TO_ME": "<%= UUID.new.generate %>",
+    "bcl_measure_version_uuid": "<%= UUID.new.generate %>",
+    "measure_definition_version_uuid_CHANGE_TO_ME": "<%= UUID.new.generate %>",
+    "measure_type": "XmlMeasure",
+    "name": "<%= @measure['name'] %>",
+    "display_name": "<%= @measure['display_name'] %>",
+    "uuid": "<%= UUID.new.generate %>",
+    "variables": [],
+    "version_uuid": "<%= UUID.new.generate %>",
+    "workflow_index": <%= @measure_index %>,
+    "workflow_step_type": "Measure"
+}

data/spec/openstudio-analysis/server_api_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe OpenStudio::Analysis::ServerApi do
+  context "create a new localhost instance" do
+    before(:all) do
+      @api = OpenStudio::Analysis::ServerApi.new
+    end
+
+    it "should set the default host to localhost" do
+      @api.hostname.should eq("http://localhost:8080")
+    end
+  end
+
+  context "test not localhost" do
+    it "should have a not localhost URL" do
+      options = {hostname: "http://abc.def.ghi"}
+      api = OpenStudio::Analysis::ServerApi.new(options)
+      api.hostname.should eq(options[:hostname])
+      
+    end
+  end
+
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+
+require 'rspec'
+require 'openstudio-analysis'
+
+
+

metadata

@@ -0,0 +1,133 @@
+--- !ruby/object:Gem::Specification
+name: openstudio-analysis
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: ruby
+authors:
+- Nicholas Long
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: uuid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: roo
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.12.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.12.2
+- !ruby/object:Gem::Dependency
+  name: rubyzip
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+description: Basic classes for generating the files needed for OpenStudio-Server
+email:
+- Nicholas.Long@nrel.gov
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/openstudio/analysis/server_api.rb
+- lib/openstudio/analysis/translator/excel.rb
+- lib/openstudio/analysis/version.rb
+- lib/openstudio/helpers/string.rb
+- lib/openstudio/templates/analysis.json.erb
+- lib/openstudio/templates/argument.json.erb
+- lib/openstudio/templates/discrete_uncertain_variable.json.erb
+- lib/openstudio/templates/pivot_variable.json.erb
+- lib/openstudio/templates/static_variable.json.erb
+- lib/openstudio/templates/uncertain_variable.json.erb
+- lib/openstudio/templates/workflow_item.json.erb
+- lib/openstudio-analysis.rb
+- README.md
+- Rakefile
+- spec/openstudio-analysis/server_api_spec.rb
+- spec/spec_helper.rb
+homepage: http://openstudio.nrel.gov
+licenses:
+- LGPL
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '2.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.2
+signing_key: 
+specification_version: 4
+summary: Create JSON, ZIP to communicate with OpenStudio Distributed Analysis in the
+  Cloud
+test_files:
+- spec/openstudio-analysis/server_api_spec.rb
+- spec/spec_helper.rb