openstudio-workflow 0.0.1 → 0.0.2

data/lib/openstudio/workflow/jobs/run_runmanager/run_runmanager.rb

@@ -0,0 +1,226 @@
+######################################################################
+#  Copyright (c) 2008-2014, Alliance for Sustainable Energy.
+#  All rights reserved.
+#
+#  This library is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  This library is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with this library; if not, write to the Free Software
+#  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+######################################################################
+
+require 'openstudio'
+
+# TODO: I hear that measures can step on each other if not run in their own directory
+class RunRunmanager
+  # Mixin the MeasureApplication module to apply measures
+  include OpenStudio::Workflow::ApplyMeasures
+
+  # Initialize
+  # param directory: base directory where the simulation files are prepared
+  # param logger: logger object in which to write log messages
+  def initialize(directory, logger, adapter, options = {})
+    energyplus_path = nil
+    if /cygwin|mswin|mingw|bccwin|wince|emx/ =~ RUBY_PLATFORM
+      energyplus_path = 'C:/EnergyPlus-8-1-0'
+    else
+      energyplus_path = '/usr/local/EnergyPlus-8-1-0'
+    end
+
+    defaults = {
+      analysis_root_path: '.',
+      energyplus_path: energyplus_path
+    }
+    @options = defaults.merge(options)
+
+    @analysis_root_path = OpenStudio::Path.new(options[:analysis_root_path])
+    @directory = OpenStudio::Path.new(directory)
+    # TODO: there is a base number of arguments that each job will need including @run_directory. abstract it out.
+    @run_directory = @directory / OpenStudio::Path.new('run')
+    @adapter = adapter
+    @results = {}
+    @logger = logger
+    @logger.info "#{self.class} passed the following options #{@options}"
+
+    # initialize instance variables that are needed in the perform section
+    @model = nil
+    @model_idf = nil
+    @initial_weather_file = nil
+    @weather_file_path = nil
+    @analysis_json = nil
+    # TODO: rename datapoint_json to just datapoint
+    @datapoint_json = nil
+    @output_attributes = {}
+    @report_measures = []
+  end
+
+  def perform
+    @logger.info "Calling #{__method__} in the #{self.class} class"
+    @logger.info "Current directory is #{@directory}"
+
+    begin
+
+      @logger.info 'Retrieving datapoint and problem'
+      @datapoint_json = @adapter.get_datapoint(@directory.to_s, @options)
+      @analysis_json = @adapter.get_problem(@directory.to_s, @options)
+
+      # @results[:weather_filename]
+      # File.open("#{@run_directory}/measure_attributes.json", 'w') do
+      #    |f| f << JSON.pretty_generate(@output_attributes)
+      # end
+
+      if @analysis_json && @datapoint_json
+
+        if @analysis_json[:openstudio_version].nil?
+          @logger.info 'analysis_json missing openstudio_version'
+          if @analysis_json[:analysis] && @analysis_json[:analysis][:openstudio_version]
+            version = @analysis_json[:analysis][:openstudio_version]
+            @logger.info "setting analysis_json openstudio_version to '#{version}'"
+            @analysis_json[:openstudio_version] = version
+          end
+        end
+
+        if @datapoint_json[:openstudio_version].nil?
+          @logger.info 'datapoint_json missing openstudio_version'
+          if @analysis_json[:analysis] && @analysis_json[:analysis][:openstudio_version]
+            version = @analysis_json[:analysis][:openstudio_version]
+            @logger.info "setting datapoint_json openstudio_version to '#{version}'"
+            @datapoint_json[:openstudio_version] = version
+          end
+        end
+
+        # set up log file
+        logSink = OpenStudio::FileLogSink.new(@run_directory / OpenStudio::Path.new('openstudio.log'))
+        # logSink.setLogLevel(OpenStudio::Debug)
+        logSink.setLogLevel(OpenStudio::Trace)
+        OpenStudio::Logger.instance.standardOutLogger.disable
+
+        @logger.info 'Parsing Analysis JSON input'
+
+        # load problem formulation
+        loadResult = OpenStudio::Analysis.loadJSON(JSON.pretty_generate(@analysis_json))
+        if loadResult.analysisObject.empty?
+          loadResult.errors.each { |error|
+            @logger.warn error.logMessage # DLM: is this right?
+          }
+          fail 'Unable to load analysis json.'
+        end
+
+        @logger.info 'Get Analysis From OpenStudio'
+        analysis = loadResult.analysisObject.get.to_Analysis.get
+
+        # fix up paths
+        @logger.info 'Fix Paths'
+        analysis.updateInputPathData(loadResult.projectDir, @analysis_root_path)
+
+        # save for reference only
+        analysis_options = OpenStudio::Analysis::AnalysisSerializationOptions.new(@analysis_root_path)
+        analysis.saveJSON(@run_directory / OpenStudio::Path.new('formulation_final.json'), analysis_options, true)
+
+        @logger.info 'Parsing DataPoint JSON input'
+
+        # load data point to run
+        loadResult = OpenStudio::Analysis.loadJSON(JSON.pretty_generate(@datapoint_json))
+        if loadResult.analysisObject.empty?
+          loadResult.errors.each { |error|
+            @logger.warn error.logMessage
+          }
+          fail 'Unable to load data point json.'
+        end
+        data_point = loadResult.analysisObject.get.to_DataPoint.get
+        analysis.addDataPoint(data_point) # also hooks up real copy of problem
+
+        @logger.info 'Creating RunManager'
+
+        # create a RunManager
+        run_manager_path = @run_directory / OpenStudio::Path.new('run.db')
+        run_manager = OpenStudio::Runmanager::RunManager.new(run_manager_path, true, false, false)
+
+        # have problem create the workflow
+        @logger.info 'Creating Workflow'
+        workflow = analysis.problem.createWorkflow(data_point, OpenStudio::Path.new($OpenStudio_Dir))
+        params = OpenStudio::Runmanager::JobParams.new
+        params.append('cleanoutfiles', 'standard')
+        workflow.add(params)
+
+        tools = OpenStudio::Runmanager::ConfigOptions.makeTools(OpenStudio::Path.new(@options[:energyplus_path]),
+                                                                OpenStudio::Path.new,
+                                                                OpenStudio::Path.new,
+                                                                $OpenStudio_RubyExeDir,
+                                                                OpenStudio::Path.new)
+        workflow.add(tools)
+        # DLM: Elaine somehow we need to add info to data point to avoid this error:
+        # [openstudio.analysis.AnalysisObject] <1> The json string cannot be parsed as an
+        # OpenStudio analysis framework json file, because Unable to find ToolInfo object
+        # at expected location.
+
+        # queue the RunManager job
+        @logger.info 'Queue RunManager Job'
+        url_search_paths = OpenStudio::URLSearchPathVector.new
+        weather_file_path = OpenStudio::Path.new
+        if analysis.weatherFile
+          weather_file_path = analysis.weatherFile.get.path
+        end
+        job = workflow.create(@run_directory, analysis.seed.path, weather_file_path, url_search_paths)
+        OpenStudio::Runmanager::JobFactory.optimizeJobTree(job)
+        analysis.setDataPointRunInformation(data_point, job, OpenStudio::PathVector.new)
+        run_manager.enqueue(job, false)
+
+        @logger.info 'Waiting for simulation to finish'
+
+        if false
+          # Get some introspection on what the current running job is. For now just
+          # look at the directories that are being generated
+          job_dirs = []
+          while run_manager.workPending
+            sleep 1
+            OpenStudio::Application.instance.processEvents
+
+            # check if there are any new folders that were creates
+            temp_dirs = Dir[File.join(@run_directory.to_s, '*/')].map { |d| d.split('/').pop }.sort
+            if (temp_dirs + job_dirs).uniq != job_dirs
+              @logger.info "#{(temp_dirs - job_dirs).join(',')}"
+              job_dirs = temp_dirs
+            end
+          end
+        else
+          run_manager.waitForFinished
+        end
+
+        @logger.info 'Simulation finished'
+
+        # use the completed job to populate data_point with results
+        @logger.info 'Updating OpenStudio DataPoint object'
+        analysis.problem.updateDataPoint(data_point, job)
+
+        @logger.info data_point
+
+        @results = { pat_data_point: ::MultiJson.load(data_point.toJSON, symbolize_names: true) }
+
+        # Savet this to the directory for debugging purposes
+        File.open("#{@run_directory}/data_point_result.json", 'w') { |f| f << MultiJson.dump(@results, pretty: true) }
+
+        fail 'Simulation Failed' if data_point.failed
+      else
+        fail 'Could not find analysis_json and datapoint_json'
+      end
+
+    rescue => e
+      log_message = "#{__FILE__} failed with #{e.message}, #{e.backtrace.join("\n")}"
+      @logger.error log_message
+
+      # do not raise as the results will never end up in the datapoint
+      # raise log_message
+    end
+
+    @results
+  end
+end

data/lib/openstudio/workflow/jobs/run_xml/run_xml.rb

@@ -21,11 +21,9 @@ require 'libxml'
 
 # This actually belongs as another class that gets added as a state dynamically
 class RunXml
-
-  CRASH_ON_NO_WORKFLOW_VARIABLE = FALSE
   # RunXml
   def initialize(directory, logger, adapter, options = {})
-    defaults = {use_monthly_reports: false, analysis_root_path: '.', xml_library_file: 'xml_runner.rb'}
+    defaults = { use_monthly_reports: false, analysis_root_path: '.', xml_library_file: 'xml_runner.rb' }
     @options = defaults.merge(options)
     @directory = directory
     # TODO: there is a base number of arguments that each job will need including @run_directory. abstract it out.
@@ -37,7 +35,7 @@ class RunXml
 
     # initialize instance variables that are needed in the perform section
     @weather_filename = nil
-    @weather_directory = File.expand_path(File.join(@options[:analysis_root_path], "weather"))
+    @weather_directory = File.expand_path(File.join(@options[:analysis_root_path], 'weather'))
     @logger.info "Weather directory is: #{@weather_directory}"
     @model_xml = nil
     @model = nil
@@ -48,18 +46,17 @@ class RunXml
     @output_attributes = {}
     @report_measures = []
     @measure_type_lookup = {
-        :openstudio_measure => 'RubyMeasure',
-        :energyplus_measure => 'EnergyPlusMeasure',
-        :reporting_measure => 'ReportingMeasure'
+      openstudio_measure: 'RubyMeasure',
+      energyplus_measure: 'EnergyPlusMeasure',
+      reporting_measure: 'ReportingMeasure'
     }
   end
 
-
   def perform
     @logger.info "Calling #{__method__} in the #{self.class} class"
     @logger.info "Current directory is #{@directory}"
 
-    @logger.info "Retrieving datapoint and problem"
+    @logger.info 'Retrieving datapoint and problem'
     @datapoint_json = @adapter.get_datapoint(@directory, @options)
     @analysis_json = @adapter.get_problem(@directory, @options)
 
@@ -67,12 +64,18 @@ class RunXml
       @model_xml = load_xml_model
       @weather_filename = load_weather_file
 
-      apply_xml_measures
+      begin
+        apply_xml_measures
+      rescue => e
+        log_message = "Exception during 'apply_xml_measure' with #{e.message}, #{e.backtrace.join("\n")}"
+        raise log_message
+      end
 
-      @logger.info "XML measure output attributes JSON is #{@output_attributes}"
-      File.open("#{@run_directory}/measure_attributes_xml.json", 'w') {
-          |f| f << JSON.pretty_generate(@output_attributes)
-      }
+      # @logger.debug "XML measure output attributes JSON is #{@output_attributes}"
+      File.open("#{@run_directory}/measure_attributes_xml.json", 'w') do
+      |f|
+        f << JSON.pretty_generate(@output_attributes)
+      end
     end
 
     create_osm_from_xml
@@ -126,7 +129,6 @@ class RunXml
           @logger.warn "Could not find weather file for simulation #{weather_filename}. Will continue because may change"
         end
 
-
       else
         fail 'No weather file path defined'
       end
@@ -143,18 +145,20 @@ class RunXml
     @model_xml.save(xml_filename)
 
     @logger.info 'Starting XML to OSM translation'
+    begin
+      # set the lib path first -- very specific for this application right now
+      @space_lib_path = File.expand_path("#{File.dirname(@options[:xml_library_file])}/space_types")
+      require @options[:xml_library_file]
 
-    # set the lib path first -- very specific for this applciation right now
-    @space_lib_path = File.expand_path("#{File.dirname(@options[:xml_library_file])}/space_types")
-    require @options[:xml_library_file]
+      @logger.info "The weather file is #{@weather_filename}"
 
-    @logger.info "The weather file is #{@weather_filename}"
-    begin
       osxt = Main.new(@weather_directory, @space_lib_path)
-      osm, idf, new_xml, building_name, weather_file = osxt.process(@model_xml.to_s, false, true)
-    rescue Exception => e
+      # def process(as_xml, ideal_loads=false, optimized_model=false, return_objects=false)
+      osm, idf, new_xml, building_name, weather_file = osxt.process(@model_xml.to_s, false, false, true)
+      # return [model, idf_model, zones_xml, building_name, weather_file]
+    rescue => e
       log_message = "Runner error #{__FILE__} failed with #{e.message}, #{e.backtrace.join("\n")}"
-      fail log_message
+      raise log_message
     end
 
     if osm
@@ -168,7 +172,7 @@ class RunXml
 
     @results[:osm_filename] = File.expand_path(osm_filename)
     @results[:xml_filename] = File.expand_path(xml_filename)
-    @results[:weather_filename] = File.expand_path(File.join(@weather_directory,@weather_filename))
+    @results[:weather_filename] = File.expand_path(File.join(@weather_directory, @weather_filename))
   end
 
   def apply_xml_measures
@@ -217,12 +221,12 @@ class RunXml
           if wf[:variables]
             wf[:variables].each do |wf_var|
               # Argument hash in workflow looks like the following
-              # "argument": {
-              #    "display_name": "Window-To-Wall Ratio",
-              #    "machine_name": "window_to_wall_ratio",
-              #    "name": "value",
-              #    "uuid": "a0618d15-bb0b-4494-a72f-8ad628693a7e",
-              #    "version_uuid": "b33cf6b0-f1aa-4706-afab-9470e6bd1912"
+              # argument: {
+              #     display_name: "Window-To-Wall Ratio",
+              #     display_name_short: "Window-To-Wall Ratio",
+              #     name: "value",
+              #     value_type: "double",
+              #     uuid: "27909cb0-f8c9-0131-9b05-14109fdf0b37"
               # },
               variable_uuid = wf_var[:uuid].to_sym # this is what the variable value is set to
               if wf_var[:argument]
@@ -231,11 +235,11 @@ class RunXml
                 # Get the value from the data point json that was set via R / Problem Formulation
                 if @datapoint_json[:data_point]
                   if @datapoint_json[:data_point][:set_variable_values]
-                    if @datapoint_json[:data_point][:set_variable_values][variable_uuid]
-                      @logger.info "Setting variable #{variable_name} to #{@datapoint_json[:data_point][:set_variable_values][variable_uuid]}"
+                    unless @datapoint_json[:data_point][:set_variable_values][variable_uuid].nil?
+                      @logger.info "Setting variable '#{variable_name}' to '#{@datapoint_json[:data_point][:set_variable_values][variable_uuid]}'"
 
                       args[wf_var[:argument][:name].to_sym] = @datapoint_json[:data_point][:set_variable_values][variable_uuid]
-                      args["#{wf_var[:argument][:name]}_machine_name".to_sym] = wf_var[:argument][:machine_name]
+                      args["#{wf_var[:argument][:name]}_machine_name".to_sym] = wf_var[:argument][:display_name].snake_case
                       args["#{wf_var[:argument][:name]}_type".to_sym] = wf_var[:value_type] if wf_var[:value_type]
                       @logger.info "Setting the machine name for argument '#{wf_var[:argument][:name]}' to '#{args["#{wf_var[:argument][:name]}_machine_name".to_sym]}'"
 
@@ -245,9 +249,7 @@ class RunXml
                         @weather_filename = @datapoint_json[:data_point][:set_variable_values][variable_uuid]
                       end
                     else
-                      @logger.info "Value for variable '#{variable_name}:#{variable_uuid}' not set in datapoint object"
-                      fail "Value for variable '#{variable_name}:#{variable_uuid}' not set in datapoint object" if CRASH_ON_NO_WORKFLOW_VARIABLE
-                      break
+                      fail "[ERROR] Value for variable '#{variable_name}:#{variable_uuid}' not set in datapoint object"
                     end
                   else
                     fail 'No block for set_variable_values in data point record'
@@ -267,13 +269,9 @@ class RunXml
           @output_attributes[wf[:name].to_sym] = measure.variable_values
           measure.results_to_json("#{@run_directory}/#{wf[:name]}_results.json")
 
-          # TODO: do we want to do this?
-          #ros.communicate_intermediate_result(measure.variable_values)
-
           @logger.info "Finished applying measure workflow #{wf[:name]} with change flag set to '#{xml_changed}'"
         end
       end
     end
-
   end
-end
+end

data/lib/openstudio/workflow/multi_delegator.rb

@@ -20,10 +20,10 @@
 require 'logger'
 
 class Logger
-  def format_message(severity, datetime, progname, msg)
-    #"#{datetime} (#{$$}) #{msg}\n"
-    #"#{datetime}: #{msg}\n"
-    "[%s %s] %s\n" % [ datetime.strftime("%H:%M:%S.%6N"), severity, msg ]
+  def format_message(severity, datetime, _progname, msg)
+    # "#{datetime} (#{$$}) #{msg}\n"
+    # "#{datetime}: #{msg}\n"
+    "[%s %s] %s\n" % [datetime.strftime('%H:%M:%S.%6N'), severity, msg]
   end
 end
 
@@ -43,6 +43,6 @@ class MultiDelegator
   end
 
   class <<self
-    alias to new
+    alias_method :to, :new
   end
-end
+end

data/lib/openstudio/workflow/run.rb

@@ -32,19 +32,19 @@ module OpenStudio
       attr_reader :final_state
       attr_reader :job_results
 
-
       # Create a nice name for the state object instead of aasm
-      alias state aasm
+      alias_method :state, :aasm
 
       # load the transitions
       def self.default_transition
         # TODO: replace these with dynamic states from a config file of some sort
         [
-            {from: :queued, to: :preflight},
-            {from: :preflight, to: :openstudio},
-            {from: :openstudio, to: :energyplus},
-            {from: :energyplus, to: :postprocess},
-            {from: :postprocess, to: :finished},
+          { from: :queued, to: :preflight },
+          { from: :preflight, to: :openstudio },
+          { from: :openstudio, to: :energyplus },
+          { from: :energyplus, to: :reporting_measures },
+          { from: :reporting_measures, to: :postprocess },
+          { from: :postprocess, to: :finished }
         ]
       end
 
@@ -53,13 +53,38 @@ module OpenStudio
       def self.default_states
         # TODO: replace this with some sort of dynamic store
         [
-            {state: :queued, :options => {initial: true}},
-            {state: :preflight, :options => {after_enter: :run_preflight}},
-            {state: :openstudio, :options => {after_enter: :run_openstudio}},
-            {state: :energyplus, :options => {after_enter: :run_energyplus}},
-            {state: :postprocess, :options => {after_enter: :run_postprocess}},
-            {state: :finished},
-            {state: :errored}
+          { state: :queued, options: { initial: true } },
+          { state: :preflight, options: { after_enter: :run_preflight } },
+          { state: :openstudio, options: { after_enter: :run_openstudio } }, # TODO: this should be run_openstudio_measures and run_energyplus_measures
+          { state: :energyplus, options: { after_enter: :run_energyplus } },
+          { state: :reporting_measures, options: { after_enter: :run_reporting_measures } },
+          { state: :postprocess, options: { after_enter: :run_postprocess } },
+          { state: :finished },
+          { state: :errored }
+        ]
+      end
+
+      # transitions for pat job
+      def self.pat_transition
+        # TODO: replace these with dynamic states from a config file of some sort
+        [
+          { from: :queued, to: :preflight },
+          { from: :preflight, to: :runmanager },
+          { from: :runmanager, to: :postprocess },
+          { from: :postprocess, to: :finished }
+        ]
+      end
+
+      # states for pat job
+      def self.pat_states
+        # TODO: replace this with some sort of dynamic store
+        [
+          { state: :queued, options: { initial: true } },
+          { state: :preflight, options: { after_enter: :run_preflight } },
+          { state: :runmanager, options: { after_enter: :run_runmanager } },
+          { state: :postprocess, options: { after_enter: :run_postprocess } },
+          { state: :finished },
+          { state: :errored }
         ]
       end
 
@@ -74,11 +99,20 @@ module OpenStudio
         # TODO: run directory is a convention right now. Move to a configuration item
         @run_directory = "#{@directory}/run"
 
-        defaults = {
+        defaults = nil
+        if options[:is_pat]
+          defaults = {
+            transitions: OpenStudio::Workflow::Run.pat_transition,
+            states: OpenStudio::Workflow::Run.pat_states,
+            jobs: {}
+          }
+        else
+          defaults = {
             transitions: OpenStudio::Workflow::Run.default_transition,
             states: OpenStudio::Workflow::Run.default_states,
             jobs: {}
-        }
+          }
+        end
         @options = defaults.merge(options)
 
         @error = false
@@ -90,7 +124,7 @@ module OpenStudio
         FileUtils.mkdir_p(@run_directory)
 
         # There is a namespace conflict when OpenStudio is loaded: be careful!
-        log_file = File.open("#{@run_directory}/run.log", "a")
+        log_file = File.open("#{@run_directory}/run.log", 'a')
 
         l = @adapter.get_logger @directory, @options
         if l
@@ -100,6 +134,7 @@ module OpenStudio
         end
 
         @logger.info "Initializing directory #{@directory} for simulation with options #{@options}"
+        @logger.info "OpenStudio loaded: '#{$openstudio_gem}'"
 
         super()
 
@@ -110,29 +145,32 @@ module OpenStudio
       # run the simulations.
       # TODO: add a catch if any job fails; TODO: make a block method to provide feedback
       def run
-        @logger.info "Starting workflow"
+        @logger.info "Starting workflow in #{@directory}"
         begin
-          while self.state.current_state != :finished && !@error
-            self.step
+          while state.current_state != :finished && !@error
+            step
           end
 
-          @logger.info "Finished workflow"
+          @logger.info 'Finished workflow - communicating results and zipping files'
 
+          # TODO: this should be a job that handles the use case with a :guard on if @job_results[:run_postprocess]
+          # or @job_results[:run_reporting_measures]
+          # these are the results that need to be sent back to adapter
+          if @job_results[:run_runmanager]
+            @logger.info 'Sending the run_runmananger results back to the adapter'
+            @adapter.communicate_results @directory, @job_results[:run_runmanager]
+          elsif @job_results[:run_reporting_measures]
+            @logger.info 'Sending the reporting measuers results back to the adapter'
+            @adapter.communicate_results @directory, @job_results[:run_reporting_measures]
+          end
+        ensure
           if @error
-            # need to tell the system that this failed
             @adapter.communicate_failure @directory
+          else
+            @adapter.communicate_complete @directory
           end
 
-          # TODO: this should be a job that handles the use case with a :guard on if @job_results[:run_postprocess]
-          if @job_results[:run_postprocess]
-            # these are the results that need to be sent back to adapter
-            @logger.info "Sending the results back to the adapter"
-            #@logger.info "Sending communicate_results the following options #{@job_results}"
-            @adapter.communicate_results @directory, @job_results[:run_postprocess]
-          end
-        ensure
-          @adapter.communicate_complete @directory
-          @logger.info "Running workflow from #{__FILE__} complete"
+          @logger.info 'Workflow complete'
 
           # TODO: define the outputs and figure out how to show it correctory
           obj_function_array ||= ['NA']
@@ -174,6 +212,24 @@ module OpenStudio
         @job_results[__method__.to_sym] = klass.perform
       end
 
+      # run a pat file using runmanager
+      def run_runmanager
+        @logger.info "Running #{__method__}"
+        klass = get_run_class(__method__)
+
+        # TODO: save the resulting filenames to an array
+        @job_results[__method__.to_sym] = klass.perform
+      end
+
+      # run reporting measures
+      def run_reporting_measures
+        @logger.info "Running #{__method__}"
+        klass = get_run_class(__method__)
+
+        # TODO: save the resulting filenames to an array
+        @job_results[__method__.to_sym] = klass.perform
+      end
+
       def run_postprocess
         @logger.info "Running #{__method__}"
         klass = get_run_class(__method__)
@@ -208,7 +264,7 @@ module OpenStudio
       # a single event of :step which steps through the transitions defined in the Hash in default_transitions
       # and calls the actions defined in the states in the Hash of default_states
       def machine
-        @logger.info "Initializing state machine"
+        @logger.info 'Initializing state machine'
         @options[:states].each do |s|
           s[:options] ? o = s[:options] : o = {}
           OpenStudio::Workflow::Run.aasm.states << AASM::State.new(s[:state], self.class, o)
@@ -228,18 +284,18 @@ module OpenStudio
         # Add in special event to error_out the state machine
         new_event = OpenStudio::Workflow::Run.aasm.event(:error_out)
         event = OpenStudio::Workflow::Run.aasm.events[:error_out]
-        event.transitions(:to => :errored)
+        event.transitions(to: :errored)
       end
 
       # Get any options that may have been sent into the class defining the workflow step
       def get_job_options
         result = {}
-        #if @options[:jobs].has_key?(state.current_state)
-        #logger.info "Retrieving job options from the @options array for #{state.current_state}"
+        # if @options[:jobs].has_key?(state.current_state)
+        # logger.info "Retrieving job options from the @options array for #{state.current_state}"
         #  result = @options[:jobs][state.current_state]
-        #end
+        # end
 
-        #result
+        # result
 
         # TODO fix this so that it gets the base config options plus its job options. Need to
         # also merge in all the former job results.
@@ -255,4 +311,4 @@ module OpenStudio
       end
     end
   end
-end
+end