openstudio-analysis 0.4.2 → 0.4.3

data/lib/openstudio/analysis/version.rb

@@ -1,5 +1,5 @@
 module OpenStudio
   module Analysis
-    VERSION = '0.4.2'
+    VERSION = '0.4.3'
   end
 end

data/lib/openstudio/analysis/workflow.rb

@@ -21,36 +21,37 @@ module OpenStudio
       # Add a measure to the workflow from a path. Inside the path it is expecting to have a measure.json file
       # if not, the BCL gem is used to create the measure.json file.
       #
-      # @params instance_name [String] The name of the instance. This allows for multiple measures to be added to the worklow with unique names
-      # @params instance_display_name [String] The display name of the instance. This allows for multiple measures to be added to the worklow with unique names
-      # @param path_to_measure [String] This is the local path to the measure directory, relative or absolute. It is used when zipping up all the measures.
+      # @params instance_name [String] The name of the instance. This allows for multiple measures to be added to the workflow with uni que names
+      # @params instance_display_name [String] The display name of the instance. This allows for multiple measures to be added to the workflow with unique names
+      # @param local_path_to_measure [String] This is the local path to the measure directory, relative or absolute. It is used when zipping up all the measures.
       # @return [Object] Returns the measure that was added as an OpenStudio::AnalysisWorkflowStep object
-      def add_measure_from_path(instance_name, instance_display_name, path_to_measure)
+      def add_measure_from_path(instance_name, instance_display_name, local_path_to_measure)
         measure_filename = 'measure.rb'
-        if File.exist?(path_to_measure) && File.file?(path_to_measure)
-          measure_filename = File.basename(path_to_measure)
-          path_to_measure = File.dirname(path_to_measure)
+
+        if File.exist?(local_path_to_measure) && File.file?(local_path_to_measure)
+          measure_filename = File.basename(local_path_to_measure)
+          local_path_to_measure = File.dirname(local_path_to_measure)
         end
 
-        if Dir.exist?(path_to_measure) && File.directory?(path_to_measure)
+        if Dir.exist?(local_path_to_measure) && File.directory?(local_path_to_measure)
           # Watch out for namespace conflicts (use ::BCL)
           b = ::BCL::ComponentMethods.new
           measure_hash = nil
-          unless File.exist?(File.join(path_to_measure, 'measure.json'))
-            measure_hash = b.parse_measure_file(nil, File.join(path_to_measure, measure_filename))
-            File.open(File.join(path_to_measure, 'measure.json'), 'w') { |f| f << JSON.pretty_generate(measure_hash) }
-            warn("measure.json not found in #{path_to_measure}, will parse measure file using BCL gem")
+          unless File.exist?(File.join(local_path_to_measure, 'measure.json'))
+            measure_hash = b.parse_measure_file(nil, File.join(local_path_to_measure, measure_filename))
+            File.open(File.join(local_path_to_measure, 'measure.json'), 'w') { |f| f << JSON.pretty_generate(measure_hash) }
+            warn("measure.json not found in #{local_path_to_measure}, will parse measure file using BCL gem")
           end
 
-          if measure_hash.nil? && File.exist?(File.join(path_to_measure, 'measure.json'))
-            measure_hash = JSON.parse(File.read(File.join(path_to_measure, 'measure.json')), symbolize_names: true)
+          if measure_hash.nil? && File.exist?(File.join(local_path_to_measure, 'measure.json'))
+            measure_hash = JSON.parse(File.read(File.join(local_path_to_measure, 'measure.json')), symbolize_names: true)
           elsif measure_hash.nil?
             fail 'measure.json was not found and was not automatically created'
           end
 
-          add_measure(instance_name, instance_display_name, path_to_measure, measure_hash)
+          add_measure(instance_name, instance_display_name, local_path_to_measure, measure_hash)
         else
-          fail "could not find measure to add to workflow #{path_to_measure}"
+          fail "could not find measure to add to workflow #{local_path_to_measure}"
         end
 
         @items.last
@@ -58,13 +59,26 @@ module OpenStudio
 
       # Add a measure from the custom hash format without reading the measure.rb or measure.json file
       #
-      # @params instance_name [String] The name of the instance. This allows for multiple measures to be added to the worklow with unique names
-      # @params instance_display_name [String] The display name of the instance. This allows for multiple measures to be added to the worklow with unique names
-      # @param path_to_measure [String] This is the local path to the measure directory, relative or absolute. It is used when zipping up all the measures.
+      # @params instance_name [String] The name of the instance. This allows for multiple measures to be added to the workflow with unique names
+      # @params instance_display_name [String] The display name of the instance. This allows for multiple measures to be added to the workflow with unique names
+      # @param local_path_to_measure [String] This is the local path to the measure directory, relative or absolute. It is used when zipping up all the measures.
       # @param measure_metadata [Hash] Format of the measure.json
       # @return [Object] Returns the measure that was added as an OpenStudio::AnalysisWorkflowStep object
-      def add_measure(instance_name, instance_display_name, path_to_measure, measure_metadata)
-        @items << OpenStudio::Analysis::WorkflowStep.from_measure_hash(instance_name, instance_display_name, path_to_measure, measure_metadata)
+      def add_measure(instance_name, instance_display_name, local_path_to_measure, measure_metadata)
+        @items << OpenStudio::Analysis::WorkflowStep.from_measure_hash(instance_name, instance_display_name, local_path_to_measure, measure_metadata)
+
+        @items.last
+      end
+
+      # Add a measure from the analysis hash format
+      #
+      # @params instance_name [String] The name of the instance. This allows for multiple measures to be added to the workflow with unique names
+      # @params instance_display_name [String] The display name of the instance. This allows for multiple measures to be added to the workflow with unique names
+      # @param local_path_to_measure [String] This is the local path to the measure directory, relative or absolute. It is used when zipping up all the measures.
+      # @param measure_metadata [Hash] Format of the measure.json
+      # @return [Object] Returns the measure that was added as an OpenStudio::AnalysisWorkflowStep object
+      def add_measure_from_analysis_hash(instance_name, instance_display_name, local_path_to_measure, measure_metadata)
+        @items << OpenStudio::Analysis::WorkflowStep.from_analysis_hash(instance_name, instance_display_name, local_path_to_measure, measure_metadata)
 
         @items.last
       end
@@ -83,8 +97,10 @@ module OpenStudio
         hash[:uid] = measure['uid'] ? measure['uid'] : SecureRandom.uuid
         hash[:version_id] = measure['version_id'] ? measure['version_id'] : SecureRandom.uuid
 
-        # map the arguments - this can be a variable or argument, add them all as arguments first
+        # map the arguments - this can be a variable or argument, add them all as arguments first,
+        # the make_variable will remove from arg and place into variables
         args = []
+
         measure['variables'].each do |variable|
           args << {
             local_variable: variable['name'],
@@ -99,10 +115,10 @@ module OpenStudio
         end
         hash[:arguments] = args
 
-        m = add_measure(measure['name'], measure['display_name'], measure['measure_file_name_directory'], hash)
+        m = add_measure(measure['name'], measure['display_name'], measure['local_path_to_measure'], hash)
 
         measure['variables'].each do |variable|
-          next unless variable['variable_type'] == 'variable'
+          next unless %w(variable pivot).include? variable['variable_type']
 
           dist = {
             type: variable['distribution']['type'],
@@ -120,7 +136,7 @@ module OpenStudio
             static_value: variable['distribution']['static_value']
           }
 
-          m.make_variable(variable['name'], variable['display_name'], dist)
+          m.make_variable(variable['name'], variable['display_name'], dist, opt)
         end
       end
 
@@ -175,25 +191,55 @@ module OpenStudio
         end
       end
 
+      # Load from a from a hash
+      #
+      # @param h [Hash or String] Path to file or hash
+      def self.load(h)
+        # get the version of the file
+        file_format_version = h[:file_format_version] ? h[:file_format_version] : 1
+        puts "Parsing file version #{file_format_version}"
+
+        o = OpenStudio::Analysis::Workflow.new
+
+        h[:workflow].each do |wf|
+          puts "Adding measure #{wf[:name]}"
+
+          # Go though the defined measure paths and try and find the local measure
+          local_measure_dir = nil
+          if wf[:measure_definition_directory_local] && Dir.exist?(wf[:measure_definition_directory_local])
+            local_measure_dir = wf[:measure_definition_directory_local]
+          else
+            # search in the measure paths for the measure
+            OpenStudio::Analysis.measure_paths.each do |p|
+              test_dir = File.join(p, File.basename(wf[:measure_definition_directory]))
+              if Dir.exist?(test_dir)
+                local_measure_dir = test_dir
+                break
+              end
+            end
+          end
+
+          fail "Could not find local measure when loading workflow for #{wf[:measure_definition_class_name]} in #{File.basename(wf[:measure_definition_directory])}. You may have to add measure paths to OpenStudio::Analysis.measure_paths" unless local_measure_dir
+
+          o.add_measure_from_analysis_hash(wf[:name], wf[:display_name], local_measure_dir, wf)
+        end
+
+        o
+      end
+
       # Read the Workflow description from a persisted file. The format at the moment is the current analysis.json
       #
       # @params filename [String] Path to file with the analysis.json to load
       # @return [Object] Return an instance of the workflow object
       def self.from_file(filename)
+        o = nil
         if File.exist? filename
           j = JSON.parse(File.read(filename), symbolize_names: true)
-
-          # get the version of the file
-          file_format_version = j[:file_format_version] ? j[:file_format_version] : 1
-
-          puts "Parsing file version #{file_format_version}"
-
+          o = OpenStudio::Analysis::Workflow.load(j)
         else
           fail "Could not find workflow file #{filename}"
         end
 
-        o = OpenStudio::Analysis::Workflow.new
-        # put the JSON into the right format
         o
       end
     end

data/lib/openstudio/analysis/workflow_step.rb

@@ -9,6 +9,7 @@ module OpenStudio
 
       attr_accessor :measure_definition_class_name
       attr_accessor :measure_definition_directory
+      attr_accessor :measure_definition_directory_local
       attr_accessor :measure_definition_display_name
       attr_accessor :measure_definition_name
       attr_accessor :measure_definition_name_xml
@@ -29,6 +30,7 @@ module OpenStudio
 
         @measure_definition_class_name = nil
         @measure_definition_directory = nil
+        @measure_definition_directory_local = nil
         @measure_definition_display_name = nil
         @measure_definition_name = nil
         @measure_definition_name_xml = nil
@@ -63,6 +65,17 @@ module OpenStudio
 
         a[:value] == value
       end
+
+      # Return a variable by its name.
+      #
+      # @param name [String] Name of the arugment that makes the variable.
+      # @return [Object] The variable object
+      def find_variable_by_name(name)
+        v = @variables.find { |v| v[:argument][:name] == name }
+
+        v
+      end
+
       # Tag a measure's argument as a variable.
       #
       # @param argument_name [String] The instance_name of the measure argument that is to be tagged. This is the same name as the argument's variable in the measure.rb file.
@@ -83,12 +96,13 @@ module OpenStudio
       # @param options [Hash] Values that define the variable.
       # @option options [String] :variable_type The type of variable, `variable` or `pivot`. By default this is a variable.
       # @option options [String] :variable_display_name_short The short display name of the variable. Will be defaulted to the variable_display_name if not passed
-      # @option options [String] :static_value Static/Default value of the variable. If not defined it will use the default value for the argument. This can be set later as well using the `argument_value` method.
       # @return [Boolean] True / False if it was able to tag the measure argument
       def make_variable(argument_name, variable_display_name, distribution, options = {})
         options = { variable_type: 'variable' }.merge(options)
         distribution[:mode] = distribution[:mean] if distribution.key? :mean
 
+        fail "Set the static value in the options 'options[:static_value]', not the distribution" if distribution[:static_value]
+
         a = @arguments.find_all { |a| a[:name] == argument_name }
         fail "could not find argument_name of #{argument_name} in measure #{name}. Valid argument names are #{argument_names}." if a.empty?
         fail "more than one argument with the same name of #{argument_name} in measure #{name}" if a.size > 1
@@ -102,6 +116,7 @@ module OpenStudio
           v[:argument] = a
           v[:display_name] = variable_display_name
           v[:display_name_short] = options[:variable_display_name_short] ? options[:variable_display_name_short] : variable_display_name
+          v[:variable_type] = options[:variable_type]
 
           v[:type] = distribution[:type]
           v[:units] = distribution[:units] ? distribution[:units] : nil
@@ -109,27 +124,22 @@ module OpenStudio
           v[:maximum] = distribution[:maximum]
           v[:relation_to_output] = distribution[:relation_to_output] ? distribution[:relation_to_output] : nil
           v[:mode] = distribution[:mode]
-          v[:static_value] = distribution[:static_value] if distribution[:static_value]
+          v[:static_value] = options[:static_value] if options[:static_value]
           # TODO: Static value should be named default value or just value
 
-          if distribution[:type] =~ /discrete/
-            v[:weights] = distribution[:weights]
-            v[:values] = distribution[:values]
-          elsif distribution[:type] =~ /uniform/
-            # all the data should be present
-          elsif distribution[:type] =~ /triangle/
-            v[:step_size] = distribution[:step_size] ? distribution[:step_size] : nil
-            # stddev is not saves when triangular
-          elsif distribution[:type] =~ /normal/
-            v[:step_size] = distribution[:step_size] ? distribution[:step_size] : nil
-            v[:standard_deviation] = distribution[:standard_deviation]
-          end
+          # Always look for these attributes even if the distribution does not need them
+          v[:weights] = distribution[:weights] if distribution[:weights]
+          v[:values] = distribution[:values] if distribution[:values]
+          v[:standard_deviation] = distribution[:standard_deviation] if distribution[:standard_deviation]
+          v[:step_size] = distribution[:step_size] ? distribution[:step_size] : nil
+          v[:step_size] = distribution[:step_size] ? distribution[:step_size] : nil
 
           # assign uuid and version id to the variable
           v[:uuid] = SecureRandom.uuid
           v[:version_uuid] = SecureRandom.uuid
           @variables << v
         end
+
         true
       end
 
@@ -158,7 +168,6 @@ module OpenStudio
               hash[var.to_s.delete('@')] = instance_variable_get(var)
             end
 
-            # TODO: warn that we are no longer writing out "variable_type": "RubyContinuousVariable",
             # TODO: iterate over the variables and create UUIDs, or not?
           end
 
@@ -168,39 +177,31 @@ module OpenStudio
           # Clean up the variables to match the legacy format
           hash[:variables].each_with_index do |v, index|
             v[:variable_type] == 'pivot' ? v[:pivot] = true : v[:variable] = true
-            v[:variable] = true
             v[:static_value] = v[:argument][:default_value] unless v[:static_value]
 
             v[:uncertainty_description] = {}
             v[:uncertainty_description][:type] = v[:type] =~ /uncertain/ ? "#{v[:type]}" : "#{v[:type]}_uncertain"
             warn "Deprecation Warning. In Version 0.5 the _uncertain text will be removed from distribution types: #{v[:uncertainty_description][:type]}"
-            warn 'Deprecation Warning. RubyContinuousVariable (OpenStudio called this the variable_type) is no longer persisted'
 
             # This is not neatly coded. This should be a new object that knows how to write itself out.
             v[:uncertainty_description][:attributes] = []
             if v[:type] =~ /discrete/
               new_h = {}
               new_h[:name] = 'discrete'
+
+              # check the weights
               new_h[:values_and_weights] = v.delete(:values).zip(v.delete(:weights)).map { |w| { value: w[0], weight: w[1] } }
               v[:uncertainty_description][:attributes] << new_h
-
-              v[:uncertainty_description][:attributes] << { name: 'lower_bounds', value: v[:minimum] }
-              v[:uncertainty_description][:attributes] << { name: 'upper_bounds', value: v[:maximum] }
-              v[:uncertainty_description][:attributes] << { name: 'modes', value: v[:mode] }
-            elsif v[:type] =~ /uniform/
-              v[:uncertainty_description][:attributes] << { name: 'lower_bounds', value: v[:minimum] }
-              v[:uncertainty_description][:attributes] << { name: 'upper_bounds', value: v[:maximum] }
-              v[:uncertainty_description][:attributes] << { name: 'modes', value: v[:mode] }
-            else
-              v[:uncertainty_description][:attributes] << { name: 'lower_bounds', value: v[:minimum] }
-              v[:uncertainty_description][:attributes] << { name: 'upper_bounds', value: v[:maximum] }
-              v[:uncertainty_description][:attributes] << { name: 'modes', value: v[:mode] }
-              v[:uncertainty_description][:attributes] << { name: 'delta_x', value: v[:step_size] ? v[:step_size] : nil }
-              v[:uncertainty_description][:attributes] << { name: 'stddev', value: v[:standard_deviation] ? v[:standard_deviation] : nil }
             end
 
+            # always write out these attributes
+            v[:uncertainty_description][:attributes] << { name: 'lower_bounds', value: v[:minimum] }
+            v[:uncertainty_description][:attributes] << { name: 'upper_bounds', value: v[:maximum] }
+            v[:uncertainty_description][:attributes] << { name: 'modes', value: v[:mode] }
+            v[:uncertainty_description][:attributes] << { name: 'delta_x', value: v[:step_size] ? v[:step_size] : nil }
+            v[:uncertainty_description][:attributes] << { name: 'stddev', value: v[:standard_deviation] ? v[:standard_deviation] : nil }
+
             v[:workflow_index] = index
-            warn 'Deprecation Warning. workflow_step_type is no longer persisted'
 
             # remove some remaining items
             v.delete(:type)
@@ -222,17 +223,28 @@ module OpenStudio
       # @param instance_display_name [String] Display name of the instance
       # @param path_to_measure [String] This is the local path to the measure directroy, relative or absolute. It is used when zipping up all the measures.
       # @param hash [Hash] Measure hash in the format of the measure.json (from the Analysis Spreadsheet project)
-
+      # @param options [Hash] Optional arguments
+      # @option options [Boolean] :ignore_not_found Do not raise an exception if the measure could not be found on the machine
       # @return [Object] Returns the OpenStudio::Analysis::WorkflowStep
-      def self.from_measure_hash(instance_name, instance_display_name, path_to_measure, hash)
+      def self.from_measure_hash(instance_name, instance_display_name, path_to_measure, hash, options = {})
         # TODO: Validate the hash
         # TODO: validate that the measure exists?
 
-        # verify that the path to the measure is a path and not a file.
+        if File.directory? path_to_measure
+          path_to_measure = File.join(path_to_measure, 'measure.rb')
+        end
+
+        # verify that the path to the measure is a path and not a file. If it is make it a path
         if File.exist?(path_to_measure) && File.file?(path_to_measure)
           path_to_measure = File.dirname(path_to_measure)
+        else
+          fail "Could not find measure '#{instance_name}' in '#{path_to_measure}'" unless options[:ignore_not_found]
         end
 
+        # Extract the directo
+        path_to_measure_local = path_to_measure
+        path_to_measure = "./measures/#{File.basename(path_to_measure)}"
+
         # map the BCL hash format into the OpenStudio WorkflowStep format
         s = OpenStudio::Analysis::WorkflowStep.new
 
@@ -243,6 +255,7 @@ module OpenStudio
         # definition of the measure
         s.measure_definition_class_name = hash[:classname]
         s.measure_definition_directory = path_to_measure
+        s.measure_definition_directory_local = path_to_measure_local
         s.measure_definition_display_name = hash[:display_name]
         s.measure_definition_name = hash[:name]
         # name_xml is not used right now but eventually should be used to compare the hash[:name] and the hash[:name_xml]
@@ -255,7 +268,9 @@ module OpenStudio
         s.type = hash[:measure_type] # this is actually the measure type
         if hash[:arguments]
           hash[:arguments].each do |arg|
-            var_type = arg[:variable_type].downcase
+            # warn the user to we need to deprecate variable_type and use value_type (which is what os server uses)
+            var_type = arg[:variable_type] ? arg[:variable_type].downcase : arg[:value_type]
+
             if var_type == 'choice'
               # WARN the user that the measure had a "choice data type"
               var_type = 'string'
@@ -263,7 +278,7 @@ module OpenStudio
 
             s.arguments << {
               display_name: arg[:display_name],
-              display_name_short: arg[:display_name],
+              display_name_short: arg[:display_name_short],
               name: arg[:name],
               value_type: var_type,
               default_value: arg[:default_value],
@@ -272,6 +287,118 @@ module OpenStudio
           end
         end
 
+        # Load the arguments of variables, but do not make them variables. This format is more about arugments, than variables
+        if hash[:variables]
+          hash[:variables].each do |variable|
+            # add the arguments first
+            s.arguments << {
+              display_name: variable[:argument][:display_name],
+              display_name_short: variable[:argument][:display_name_short],
+              name: variable[:argument][:name],
+              value_type: variable[:argument][:value_type],
+              default_value: variable[:argument][:default_value],
+              value: variable[:argument][:default_value]
+            }
+          end
+        end
+
+        s
+      end
+
+      # Read the workflow item from a analysis hash. Can we combine measure hash and analysis hash?
+      #
+      # @param instance_name [String] Machine name of the instance
+      # @param instance_display_name [String] Display name of the instance
+      # @param path_to_measure [String] This is the local path to the measure directroy, relative or absolute. It is used when zipping up all the measures.
+      # @param hash [Hash] Measure hash in the format of the measure.json (from the Analysis Spreadsheet project)
+      # @param options [Hash] Optional arguments
+      # @option options [Boolean] :ignore_not_found Do not raise an exception if the measure could not be found on the machine
+      # @return [Object] Returns the OpenStudio::Analysis::WorkflowStep
+      def self.from_analysis_hash(instance_name, instance_display_name, path_to_measure, hash, options = {})
+        # TODO: Validate the hash
+        # TODO: validate that the measure exists?
+
+        if File.directory? path_to_measure
+          path_to_measure = File.join(path_to_measure, 'measure.rb')
+        end
+
+        # verify that the path to the measure is a path and not a file. If it is make it a path
+        if File.exist?(path_to_measure) && File.file?(path_to_measure)
+          path_to_measure = File.dirname(path_to_measure)
+        else
+          fail "Could not find measure '#{instance_name}' in '#{path_to_measure}'" unless options[:ignore_not_found]
+        end
+
+        # Extract the directo
+        path_to_measure_local = path_to_measure
+        path_to_measure = "./measures/#{File.basename(path_to_measure)}"
+
+        # map the BCL hash format into the OpenStudio WorkflowStep format
+        s = OpenStudio::Analysis::WorkflowStep.new
+
+        # add the instance and display name
+        s.name = instance_name
+        s.display_name = instance_display_name
+
+        # definition of the measure
+        s.measure_definition_class_name = hash[:measure_definition_class_name]
+        s.measure_definition_directory = path_to_measure
+        s.measure_definition_directory_local = path_to_measure_local
+        s.measure_definition_display_name = hash[:measure_definition_display_name]
+        s.measure_definition_name = hash[:measure_definition_name]
+        # name_xml is not used right now but eventually should be used to compare the hash[:name] and the hash[:name_xml]
+        s.measure_definition_name_xml = hash[:measure_definition_name_xml]
+        s.measure_definition_uuid = hash[:measure_definition_uuid]
+        s.measure_definition_version_uuid = hash[:measure_definition_version_uuid]
+
+        s.type = hash[:measure_type] # this is actually the measure type
+        if hash[:arguments]
+          hash[:arguments].each do |arg|
+            # warn the user to we need to deprecate variable_type and use value_type (which is what os server uses)
+            var_type = arg[:value_type]
+
+            if var_type == 'choice'
+              # WARN the user that the measure had a "choice data type"
+              var_type = 'string'
+            end
+
+            s.arguments << {
+              display_name: arg[:display_name],
+              display_name_short: arg[:display_name_short],
+              name: arg[:name],
+              value_type: var_type,
+              default_value: arg[:default_value],
+              value: arg[:value]
+            }
+          end
+        end
+
+        if hash[:variables]
+          hash[:variables].each do |variable|
+            # add the arguments first
+            s.arguments << {
+              display_name: variable[:argument][:display_name],
+              display_name_short: variable[:argument][:display_name_short],
+              name: variable[:argument][:name],
+              value_type: variable[:argument][:value_type],
+              default_value: variable[:argument][:default_value],
+              value: variable[:argument][:default_value]
+            }
+
+            var_options = {}
+            var_options[:variable_type] = variable[:variable_type]
+            var_options[:variable_display_name_short] = variable[:display_name_short]
+            var_options[:static_value] = variable[:static_value]
+            distribution =  variable[:uncertainty_description]
+            distribution[:minimum] = variable[:minimum]
+            distribution[:mean] = distribution[:attributes].find { |a| a[:name] == 'modes' }[:value]
+            distribution[:maximum] = variable[:maximum]
+            distribution[:standard_deviation] = distribution[:attributes].find { |a| a[:name] == 'stddev' }[:value]
+            distribution[:step_size] = distribution[:attributes].find { |a| a[:name] == 'delta_x' }[:value]
+            s.make_variable(variable[:argument][:name], variable[:display_name], distribution, var_options)
+          end
+        end
+
         s
       end
 
@@ -286,7 +413,7 @@ module OpenStudio
         fail 'No mean/mode defined for variable' unless d.key? :mode
 
         if d[:type] =~ /uniform/
-          # Do we need to tell the user that we don't really need the mean/mode for uniform?
+          # Do we need to tell the user that we don't really need the mean/mode for uniform ?
         elsif d[:type] =~ /discrete/
           # require min, max, mode
           fail 'No values passed for discrete distribution' unless d[:values] || d[:values].empty?
@@ -299,7 +426,6 @@ module OpenStudio
           end
         elsif d[:type] =~ /triangle/
           # requires min, max, mode
-
         elsif d[:type] =~ /normal/ # both normal and lognormal
           # require min, max, mode, stddev
           fail 'No standard deviation for variable' unless d[:standard_deviation]