openstudio-analysis 0.4.2 → 0.4.3

data/lib/openstudio/analysis/support_files.rb

@@ -4,7 +4,6 @@
 module OpenStudio
   module Analysis
     class SupportFiles
-
       attr_reader :files
 
       # Create a new instance of the support file class
@@ -24,7 +23,7 @@ module OpenStudio
 
         # only add if it isn't allready in the list
         if @files.find_all { |f| f[:file] == path_or_filename }.empty?
-          @files << {file: path_or_filename, metadata: metadata}
+          @files << { file: path_or_filename, metadata: metadata }
         end
 
         true
@@ -33,7 +32,7 @@ module OpenStudio
       # Add a glob path with the same metadata for all the items
       #
       # @param pattern [String] Pattern to glob. example: /home/user1/files/**/*.rb
-      # @return [Boolean] Returns false if the file does not exist
+      # @return [Boolean] Always returns true
       def add_files(pattern, metadata = {})
         Dir[pattern].each do |f|
           add(f, metadata)
@@ -42,6 +41,16 @@ module OpenStudio
         true
       end
 
+      # Return the first
+      def first
+        @files.first
+      end
+
+      # Return the last
+      def last
+        @files.last
+      end
+
       # Access a file by an index
       def [](index)
         @files[index]
@@ -66,11 +75,20 @@ module OpenStudio
         @files.each { |i| yield i }
       end
 
+      # Iterate over the files with index
+      def each_with_index
+        @files.each_with_index { |d, index| yield d, index }
+      end
+
       # remove all the items
       def clear
         @files.clear
       end
 
+      # find the first object. There has to be a better way to do this. Can I just inherit an array?
+      def find
+        @files.find { |i| yield i }
+      end
     end
   end
 end

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

@@ -9,6 +9,7 @@ module OpenStudio
         attr_reader :models
         attr_reader :weather_files
         attr_reader :measure_paths
+        attr_reader :weather_paths
         attr_reader :worker_inits
         attr_reader :worker_finals
         attr_reader :export_path
@@ -22,7 +23,6 @@ module OpenStudio
         # remove these once we have classes to construct the JSON file
         attr_accessor :name
         attr_reader :analysis_name
-        attr_reader :template_json
 
         # methods to override instance variables
 
@@ -41,11 +41,13 @@ module OpenStudio
 
           # 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_files = []
+          @weather_files = [] # remove this from excel!
+          @weather_paths = []
           @models = []
           @other_files = []
           @worker_inits = []
@@ -55,7 +57,6 @@ module OpenStudio
           @number_of_samples = 0 # todo: remove this
           @problem = {}
           @algorithm = {}
-          @template_json = nil
           @outputs = {}
           @run_setup = {}
           @aws_tags = []
@@ -90,12 +91,6 @@ module OpenStudio
           }
         end
 
-        # Save off the legacy format of the JSON file
-        def save_variable_json(filename)
-          FileUtils.rm_f(filename) if File.exist?(filename)
-          File.open(filename, 'w') { |f| f << JSON.pretty_generate(@variables) }
-        end
-
         def validate_analysis
           # Setup the paths and do some error checking
           @measure_paths.each do |mp|
@@ -199,309 +194,103 @@ module OpenStudio
           true
         end
 
-        def create_analysis_hash
-          # save the format in the OpenStudio analysis json format template without
-          # the correct weather files or models
-          @template_json = translate_to_analysis_json_template
-
-          # save the other format for now
-          translate_to_analysis
-
-          @template_json
-        end
-
-        # save_analysis will iterate over each model that is defined in the spreadsheet and save the
-        # zip and json file.
-        def save_analysis
-          @template_json = create_analysis_hash
+        # 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. Call 'analyses' to return the array" if @models.size > 1 && seed_model.nil?
 
-          # validate_template_json
+          seed_model = @models.first if seed_model.nil?
 
-          # iterate over each model and save the zip and json
-          @models.each do |model|
-            puts "Creating JSON and ZIP file for #{@name}:#{model[:display_name]}"
-            save_analysis_zip(model)
-            analysis_json = create_analysis_json(@template_json, model, @models.count > 1)
-          end
-        end
+          # 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
 
-        # New method that uses the objects to hold the analysis
-        def translate_to_analysis
-          # Use the programmatic interface to make the analysis json now
-          analysis = OpenStudio::Analysis.create(@analysis_name)
+          a = OpenStudio::Analysis.create(display_name)
 
           @variables['data'].each do |measure|
             next unless measure['enabled']
 
-            # TODO: make this read the measure.rb file, then override any of the differences. That is call workflow.add_from_measure_path
-            analysis.workflow.add_measure_from_excel(measure)
-          end
-
-          # Add in the outputs
-
-          @outputs['output_variables'].each do |o|
-            o = Hash[o.map { |k, v| [k.to_sym, v] }]
-            analysis.add_output(o)
-          end
-
-          # Temp save of the json file
-          # analysis.save("#{analysis.display_name}_api.json")
-
-          analysis
-        end
-
-        def translate_to_analysis_json_template
-          # 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)
-          pivot_variable_template = ERB.new(File.open("#{template_root}/pivot_variable.json.erb", 'r').read)
-          argument_template = ERB.new(File.read("#{template_root}/argument.json.erb"))
-
-          # Templated analysis json file (this is what is returned)
-          openstudio_analysis_json = JSON.parse(analysis_template.result(get_binding))
-
-          openstudio_analysis_json['analysis']['problem'].merge!(@problem)
-          openstudio_analysis_json['analysis']['problem']['algorithm'].merge!(@algorithm)
-          openstudio_analysis_json['analysis'].merge!(@outputs)
-
-          @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_index += 1
-
-              # puts "  Adding measure item '#{measure['name']}' to analysis.json"
-              @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['distribution']['static_value'].nil? || @variable['distribution']['static_value'] == 'null'
-                    puts "    Warning: '#{measure['name']}:#{@variable['name']}' static value was empty or null, assuming optional and skipping"
-                    next
-                  end
-
-                  # add this as an argument
-                  case @variable['type'].downcase
-                    when 'string', 'choice'
-                      @static_value = @variable['distribution']['static_value'].inspect
-                    else
-                      @static_value = @variable['distribution']['static_value']
-                  end
-                  ag = JSON.parse(argument_template.result(get_binding))
-                  fail "Argument '#{@variable['name']}' did not process.  Most likely it did not have all parameters defined." if ag.nil?
-                  wf['arguments'] << ag
-                else # must be a variable [either pivot or normal variable]
-                  vr = nil
-                  # add this as an argument
-                  case @variable['type'].downcase
-                    when 'string', 'choice'
-                      @static_value = @variable['distribution']['static_value'].inspect
-                    else
-                      @static_value = @variable['distribution']['static_value']
-                  end
-
-                  # TODO: remove enum and choice as this is not the variable type
-                  if @variable['type'] == 'enum' || @variable['type'].downcase == 'choice'
-                    @values_and_weights = @variable['distribution']['enumerations'].map { |v| { value: v } }.to_json
-                    vr = JSON.parse(discrete_uncertain_variable_template.result(get_binding))
-                  elsif @variable['distribution']['type'] == 'discrete_uncertain'
-                    # puts @variable.inspect
-                    if @variable['distribution']['discrete_weights']
-                      fail "Discrete variable '#{@variable['name']}' does not have equal length of values and weights" if @variable['distribution']['discrete_values'].size != @variable['distribution']['discrete_weights'].size
-                      @values_and_weights = @variable['distribution']['discrete_values'].zip(@variable['distribution']['discrete_weights']).map { |v, w| { value: v, weight: w } }.to_json
-                    else
-                      @values_and_weights = @variable['distribution']['discrete_values'].map { |v| { value: v } }.to_json
-                    end
-
-                    if @variable['variable_type'] == 'pivot'
-
-                      vr = JSON.parse(pivot_variable_template.result(get_binding))
-                    else
-                      vr = JSON.parse(discrete_uncertain_variable_template.result(get_binding))
-                    end
-                  else
-                    if @variable['variable_type'] == 'pivot'
-                      fail 'Currently unable to pivot on continuous variables... stay tuned.'
-                    else
-                      vr = JSON.parse(uncertain_variable_template.result(get_binding))
-                    end
-                  end
-                  fail 'variable was nil after processing' if vr.nil?
-                  wf['variables'] << vr
+            @measure_paths.each do |measure_path|
+              measure_dir_to_add = "#{measure_path}/#{measure['measure_file_name_directory']}"
+              if Dir.exist? measure_dir_to_add
+                if File.exist? "#{measure_dir_to_add}/measure.rb"
+                  measure['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
-
-              openstudio_analysis_json['analysis']['problem']['workflow'] << wf
             end
-          end
 
-          openstudio_analysis_json
-        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['local_path_to_measure']
 
-        protected
-
-        # helper method for ERB
-        def get_binding
-          binding
-        end
-
-        # Package up the seed, weather files, and measures
-        def save_analysis_zip(model)
-          def add_directory_to_zip(zipfile, local_directory, relative_zip_directory)
-            # puts "Add Directory #{local_directory}"
-            Dir[File.join("#{local_directory}", '**', '**')].each do |file|
-              # puts "Adding File #{file}"
-              zipfile.add(file.sub(local_directory, relative_zip_directory), file)
-            end
-            zipfile
+            a.workflow.add_measure_from_excel(measure)
           end
 
-          zipfile_name = "#{@export_path}/#{model[:name]}.zip"
-          FileUtils.rm_f(zipfile_name) if File.exist?(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
-
-            # Add only the measures that are defined in the spreadsheet
-            required_measures = @variables['data'].map { |v| v['measure_file_name_directory'] if v['enabled'] }.compact.uniq
-
-            # Convert this into a hash which looks like {name: measure_name}. This will allow us to add more
-            # fields to the measure, such as which directory is the measure.
-            required_measures = required_measures.map { |value| { name: value } }
-
-            # first validate that all the measures exist
-            errors = []
-            required_measures.each do |measure|
-              next if measure.key? :path
-
-              @measure_paths.each do |measure_path|
-                measure_dir_to_add = "#{measure_path}/#{measure[:name]}"
-                if Dir.exist? measure_dir_to_add
-                  if File.exist? "#{measure_dir_to_add}/measure.rb"
-                    measure[:path] = measure_path
-                    break
-                  else
-                    errors << "Measure in directory '#{@measure_path}/#{measure}' did not contain a measure.rb file"
-                  end
-                end
-              end
-            end
-
-            # validate that all measures were found
-            required_measures.each do |measure|
-              unless measure.key? :path
-                errors << "Could not find measure '#{measure}' in directory '#{@measure_path}'"
-              end
-            end
+          @other_files.each do |library|
+            a.libraries.add(library[:path], library_name: library[:lib_zip_name])
+          end
 
-            fail errors.join("\n") unless errors.empty?
+          @worker_inits.each do |w|
+            a.worker_inits.add(w[:path],  args: w[:args])
+          end
 
-            required_measures.each do |measure|
-              measure_dir_to_add = "#{measure[:path]}/#{measure[:name]}"
-              puts "  Adding measure #{measure_dir_to_add} to zip file"
-              Dir[File.join(measure_dir_to_add, '**')].each do |file|
-                if File.directory?(file)
-                  if File.basename(file) == 'resources' || File.basename(file) == 'lib'
-                    add_directory_to_zip(zipfile, file, "./measures/#{measure[:name]}/#{File.basename(file)}")
-                  else
-                    # puts "Skipping Directory #{File.basename(file)}"
-                  end
-                else
-                  # puts "Adding File #{file}"
-                  # added_measures << measure_dir unless added_measures.include? measure_dir
-                  zipfile.add(file.sub(measure_dir_to_add, "./measures/#{measure[:name]}/"), file)
-                end
-              end
-            end
+          @worker_finals.each do |w|
+            a.worker_finalizes.add(w[:path], args: w[:args])
+          end
 
-            # puts "Adding #{model[:path]}"
-            zipfile.add("./seed/#{File.basename(model[:path])}", model[:path])
+          # Add in the outputs
+          @outputs['output_variables'].each do |o|
+            o = Hash[o.map { |k, v| [k.to_sym, v] }]
+            a.add_output(o)
+          end
 
-            # 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
+          a.analysis_type = @problem['analysis_type']
+          @algorithm.each do |k, v|
+            a.algorithm.set_attribute(k, v)
+          end
 
-            # puts "Adding in Worker initialize scripts #{@worker_inits}"
-            @worker_inits.each_with_index do |f, index|
-              # this is ordered
-              f[:ordered_file_name] = "#{index.to_s.rjust(2, '0')}_#{File.basename(f[:path])}"
-              f[:index] = index
-
-              zipfile.add(f[:path].sub(f[:path], "./lib/worker_initialize/#{f[:ordered_file_name]}"), f[:path])
-              arg_file = "#{File.basename(f[:ordered_file_name], '.*')}.args"
-              file = Tempfile.new('arg')
-              file.write(f[:args])
-              zipfile.add("./lib/worker_initialize/#{arg_file}", file)
-              file.close
-            end
+          # clear out the seed files before adding new ones
+          a.seed_model = seed_model[:path]
 
-            # puts "Adding in Worker finalize scripts #{@worker_finals}"
-            @worker_finals.each_with_index do |f, index|
-              # this is ordered
-              f[:ordered_file_name] = "#{index.to_s.rjust(2, '0')}_#{File.basename(f[:path])}"
-              f[:index] = index
-
-              zipfile.add(f[:path].sub(f[:path], "./lib/worker_finalize/#{f[:ordered_file_name]}"), f[:path])
-              arg_file = "#{File.basename(f[:ordered_file_name], '.*')}.args"
-              file = Tempfile.new('arg')
-              file.write(f[:args])
-              zipfile.add("./lib/worker_finalize/#{arg_file}", file)
-              file.close
-            end
+          # 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
-        end
 
-        def create_analysis_json(analysis_json, model, append_model_name)
-          def deep_copy(o)
-            Marshal.load(Marshal.dump(o))
-          end
+          a
+        end
 
-          # append the model name to the analysis name if requested (normally if there are more than
-          # 1 models in the spreadsheet)
-          new_analysis_json = deep_copy(analysis_json)
-          if append_model_name
-            new_analysis_json['analysis']['display_name'] = new_analysis_json['analysis']['display_name'] + ' - ' + model[:display_name]
-            new_analysis_json['analysis']['name'] = new_analysis_json['analysis']['name'] + '_' + model[:name]
+        # Return an array of analyses objects of OpenStudio::Analysis::Formulation
+        def analyses
+          as = []
+          @models.map do |model|
+            as << analysis(model, @models.count > 1)
           end
 
-          # Set the seed model in the analysis_json
-          new_analysis_json['analysis']['seed']['file_type'] = model[:type]
-          # This is the path that will be seen on the server when this runs
-          new_analysis_json['analysis']['seed']['path'] = "./seed/#{File.basename(model[:path])}"
+          as
+        end
 
-          # Set the weather file as the first in the list -- this is optional
-          new_analysis_json['analysis']['weather_file']['file_type'].downcase == 'epw'
-          if File.extname(@weather_files.first) =~ /.zip/i
-            new_analysis_json['analysis']['weather_file']['path'] = "./weather/#{File.basename(@weather_files.first, '.zip')}.epw"
-          else
-            # get the first EPW file (not the first file)
-            weather = @weather_files.find { |w| File.extname(w).downcase == '.epw' }
-            fail "Could not find a weather file (*.epw) in weather directory #{File.dirname(@weather_files.first)}" unless weather
-            new_analysis_json['analysis']['weather_file']['path'] = "./weather/#{File.basename(weather)}"
+        # save_analysis will iterate over each model that is defined in the spreadsheet and save the
+        # zip and json file.
+        def save_analysis
+          analyses.each do |a|
+            puts "Saving JSON and ZIP file for #{@name}:#{a.display_name}"
+            json_file_name = "#{@export_path}/#{a.name}.json"
+            FileUtils.rm_f(json_file_name) if File.exist?(json_file_name)
+            # File.open(json_file_name, 'w') { |f| f << JSON.pretty_generate(new_analysis_json) }
+
+            a.save json_file_name
+            a.save_zip "#{File.dirname(json_file_name)}/#{File.basename(json_file_name, '.*')}.zip"
           end
-
-          json_file_name = "#{@export_path}/#{model[:name]}.json"
-          FileUtils.rm_f(json_file_name) if File.exist?(json_file_name)
-          File.open(json_file_name, 'w') { |f| f << JSON.pretty_generate(new_analysis_json) }
         end
 
+        protected
+
         # 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
@@ -680,6 +469,7 @@ module OpenStudio
                 unless (Pathname.new weather_path).absolute?
                   weather_path = File.expand_path(File.join(@root_path, weather_path))
                 end
+                @weather_paths << weather_path
                 @weather_files += Dir.glob(weather_path)
               end
             elsif b_models
@@ -736,12 +526,13 @@ module OpenStudio
           # If you add a new column and you want that variable in the hash, then you must add it here.
           # rows = @xls.sheet('Variables').parse(:enabled => "# variable")
           # puts rows.inspect
+
           rows = nil
           begin
             if @version >= '0.3.3'.to_version
               rows = @xls.sheet('Variables').parse(enabled: '# variable',
                                                    measure_name_or_var_type: 'type',
-                                                   measure_file_name_or_var_display_name: 'parameter display name.*',
+                                                   measure_file_name_or_var_display_name: 'parameter display name*',
                                                    measure_file_name_directory: 'measure directory',
                                                    measure_type_or_parameter_name_in_measure: 'parameter name in measure',
                                                    display_name_short: 'parameter short display name',
@@ -765,7 +556,7 @@ module OpenStudio
             elsif @version >= '0.3.0'.to_version
               rows = @xls.sheet('Variables').parse(enabled: '# variable',
                                                    measure_name_or_var_type: 'type',
-                                                   measure_file_name_or_var_display_name: 'parameter display name.*',
+                                                   measure_file_name_or_var_display_name: 'parameter display name*',
                                                    measure_file_name_directory: 'measure directory',
                                                    measure_type_or_parameter_name_in_measure: 'parameter name in measure',
                                                    # sampling_method: 'sampling method',
@@ -788,7 +579,7 @@ module OpenStudio
             elsif @version >= '0.2.0'.to_version
               rows = @xls.sheet('Variables').parse(enabled: '# variable',
                                                    measure_name_or_var_type: 'type',
-                                                   measure_file_name_or_var_display_name: 'parameter display name.*',
+                                                   measure_file_name_or_var_display_name: 'parameter display name*',
                                                    measure_file_name_directory: 'measure directory',
                                                    measure_type_or_parameter_name_in_measure: 'parameter name in measure',
                                                    sampling_method: 'sampling method',
@@ -811,7 +602,7 @@ module OpenStudio
             elsif @version >= '0.1.12'.to_version
               rows = @xls.sheet('Variables').parse(enabled: '# variable',
                                                    measure_name_or_var_type: 'type',
-                                                   measure_file_name_or_var_display_name: 'parameter display name.*',
+                                                   measure_file_name_or_var_display_name: 'parameter display name*',
                                                    measure_type_or_parameter_name_in_measure: 'parameter name in measure',
                                                    sampling_method: 'sampling method',
                                                    variable_type: 'Variable Type',
@@ -833,7 +624,7 @@ module OpenStudio
             elsif @version >= '0.1.11'.to_version
               rows = @xls.sheet('Variables').parse(enabled: '# variable',
                                                    measure_name_or_var_type: 'type',
-                                                   measure_file_name_or_var_display_name: 'parameter display name.*',
+                                                   measure_file_name_or_var_display_name: 'parameter display name*',
                                                    measure_type_or_parameter_name_in_measure: 'parameter name in measure',
                                                    sampling_method: 'sampling method',
                                                    variable_type: 'Variable Type',
@@ -855,7 +646,7 @@ module OpenStudio
             else
               rows = @xls.sheet('Variables').parse(enabled: '# variable',
                                                    measure_name_or_var_type: 'type',
-                                                   measure_file_name_or_var_display_name: 'parameter display name.*',
+                                                   measure_file_name_or_var_display_name: 'parameter display name*',
                                                    measure_type_or_parameter_name_in_measure: 'parameter name in measure',
                                                    sampling_method: 'sampling method',
                                                    variable_type: 'Variable Type',
@@ -876,7 +667,7 @@ module OpenStudio
                                                    clean: true)
             end
           rescue => e
-            raise "#{e.message} with Spreadsheet #{@xls_filename} with Version #{@version}  "
+            raise "Unable to parse spreadsheet #{@xls_filename} with version #{@version} due to error: #{e.message}"
           end
 
           fail "Could not find the sheet name 'Variables' in excel file #{@root_path}" unless rows
@@ -909,7 +700,9 @@ module OpenStudio
 
                 # parse the choices/enums
                 if var['type'] == 'enum' || var['type'] == 'choice' # this is now a choice
-                  var['distribution']['enumerations'] = row[:enums].gsub('|', '').split(',').map(&:strip)
+                  if row[:enums]
+                    var['distribution']['enumerations'] = row[:enums].gsub('|', '').split(',').map(&:strip)
+                  end
                 elsif var['type'] == 'bool'
                   var['distribution']['enumerations'] = []
                   var['distribution']['enumerations'] << 'true' # TODO: should this be a real bool?
@@ -1032,7 +825,6 @@ module OpenStudio
 
           variable_index = -1
           group_index = 1
-          @algorithm['objective_functions'] = []
 
           rows.each_with_index do |row, icnt|
             next if icnt < 2 # skip the first 3 lines of the file
@@ -1047,13 +839,6 @@ module OpenStudio
             var['export'] = row[:export].downcase == 'true' ? true : false if row[:export]
             var['variable_type'] = row[:variable_type].downcase if row[:variable_type]
             var['objective_function'] = row[:objective_function].downcase == 'true' ? true : false
-            if var['objective_function']
-              @algorithm['objective_functions'] << var['name']
-              variable_index += 1
-              var['objective_function_index'] = variable_index
-            else
-              var['objective_function_index'] = nil
-            end
             var['objective_function_target'] = row[:objective_function_target]
             var['scaling_factor'] = row[:scaling_factor]