openstudio-workflow 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 41a1b251ada32dafc258c2f0fc90afbbc4ba043d
-  data.tar.gz: 87b2d6a43d56d43c2eb51317ec060fbdb5737026
+  metadata.gz: d9d68b3e07b560c00048d9804bc0b335616b4ff6
+  data.tar.gz: 48da479660bf59a3f06297a4b80917c9ad8fb534
 SHA512:
-  metadata.gz: 52e7e0b922390bf6ba53039a35d31da5db0a5d1936d014147158c878ec6366b86f39186f6b5834783e46e63d06577933acc369aa21fb6b194be77341ddb66f77
-  data.tar.gz: e307a06376afd682d42a8f02e07450eb939fba1d07bd7d4d096966a7b6d7aad1fc27286ad8d349c089490b5287dc125bf36c972192daed8448835a051fb3853c
+  metadata.gz: 4e2fd88631224d04ca0f347863ab5ed19817f08e3edf05c3a1109a3e54be82a71ae3d88040e3a7ff91d2507762a22adc919be436bd9c05744478127434543525
+  data.tar.gz: a9fa849f8c5d4e0534c25a223764486356eafb1d4ef9f10e7e8525c64ad38a5ea01556180e57ad9ab9c9d70ff0e7a28e0534f06b5b1587ae529be9924e7ce22f

data/lib/openstudio/workflow/adapters/input/local.rb

@@ -27,9 +27,27 @@ module OpenStudio
         def initialize(osw_path = './workflow.osw')
           @osw_abs_path = File.absolute_path(osw_path, Dir.pwd)
 
-          @workflow = if File.exist? @osw_abs_path
-                        ::JSON.parse(File.read(@osw_abs_path), symbolize_names: true)
-                      end
+          @workflow = nil
+          if File.exist? @osw_abs_path
+            @workflow = ::JSON.parse(File.read(@osw_abs_path), symbolize_names: true)
+          end
+                   
+          @workflow_json = nil
+          @run_options = nil
+          if @workflow
+            begin
+              # Create a temporary WorkflowJSON, will not be same one used in registry during simulation
+              @workflow_json = OpenStudio::WorkflowJSON.new(JSON.fast_generate(workflow))
+              @workflow_json.setOswDir(osw_dir)
+            rescue NameError => e
+              @workflow_json = WorkflowJSON_Shim.new(workflow, osw_dir)
+            end
+            
+            begin 
+              @run_options = @workflow_json.runOptions
+            rescue
+            end
+          end
         end
 
         # Get the OSW file from the local filesystem
@@ -55,23 +73,147 @@ module OpenStudio
         #
         def run_dir
           result = File.join(osw_dir, 'run')
-          if workflow
+          if @workflow_json
             begin
-              workflow_json = nil
-              begin
-                # Create a temporary WorkflowJSON to compute run directory
-                workflow_json = OpenStudio::WorkflowJSON.new(JSON.fast_generate(workflow))
-                workflow_json.setOswDir(osw_dir)
-              rescue Exception => e
-                workflow_json = WorkflowJSON_Shim.new(workflow, osw_dir)
-              end
-              result = workflow_json.absoluteRunDir.to_s
+              result = @workflow_json.absoluteRunDir.to_s
             rescue
             end
           end
           result
         end
+        
+        def output_adapter(user_options, default, logger)
+          
+          # user option trumps all others
+          return user_options[:output_adapter] if user_options[:output_adapter]
+          
+          # try to read from OSW
+          if @run_options && !@run_options.empty?
+            custom_adapter = @run_options.get.customOutputAdapter
+            if !custom_adapter.empty?
+              begin
+                custom_file_name = custom_adapter.get.customFileName
+                class_name = custom_adapter.get.className
+                options = ::JSON.parse(custom_adapter.get.options, :symbolize_names => true)
+                
+                # merge with user options, user options will replace options loaded from OSW
+                options.merge!(user_options)
+                  
+                # stick output_directory in options
+                options[:output_directory] = run_dir
+                
+                p = @workflow_json.findFile(custom_file_name)
+                if !p.empty?
+                  load(p.get.to_s)
+                  output_adapter = eval("#{class_name}.new(options)")
+                  return output_adapter
+                else
+                  log_message = "Failed to load custom adapter file '#{custom_file_name}'"
+                  logger.error log_message
+                  raise log_message
+                end
+              rescue
+                log_message = "Failed to load custom adapter '#{class_name}' from file '#{custom_file_name}'"
+                logger.error log_message
+                raise log_message
+              end
+            end
+          end
+        
+          return default
+        end
+        
+        def jobs(user_options, default, logger)
+          
+          # user option trumps all others
+          return user_options[:jobs] if user_options[:jobs]
 
+          # try to read from OSW
+          begin
+            #log_message = "Reading custom job states from OSW is not currently supported'"
+            #logger.info log_message
+          rescue
+          end
+        
+          return default
+        end
+        
+        def debug(user_options, default)
+          
+          # user option trumps all others
+          return user_options[:debug] if user_options[:debug]
+          
+          # try to read from OSW
+          if @run_options && !@run_options.empty?
+            return @run_options.get.debug
+          end
+        
+          return default
+        end
+        
+        def preserve_run_dir(user_options, default)
+          
+          # user option trumps all others
+          return user_options[:preserve_run_dir] if user_options[:preserve_run_dir]
+          
+          # try to read from OSW
+          if @run_options && !@run_options.empty?
+            return @run_options.get.preserveRunDir
+          end
+        
+          return default
+        end
+        
+        def cleanup(user_options, default)
+          
+          # user option trumps all others
+          return user_options[:cleanup] if user_options[:cleanup]
+          
+          # try to read from OSW
+          if @run_options && !@run_options.empty?
+            return @run_options.get.cleanup
+          end
+        
+          return default
+        end
+        
+        def energyplus_path(user_options, default)
+          
+          # user option trumps all others
+          return user_options[:energyplus_path] if user_options[:energyplus_path]
+        
+          return default
+        end
+        
+        def profile(user_options, default)
+          
+          # user option trumps all others
+          return user_options[:profile] if user_options[:profile]
+        
+          return default
+        end   
+        
+        def verify_osw(user_options, default)
+          
+          # user option trumps all others
+          return user_options[:verify_osw] if user_options[:verify_osw]
+        
+          return default
+        end   
+        
+        def weather_file(user_options, default)
+          
+          # user option trumps all others
+          return user_options[:weather_file] if user_options[:weather_file]
+          
+          # try to read from OSW
+          if !@workflow_json.weatherFile.empty?
+            return @workflow_json.weatherFile.get.to_s
+          end
+        
+          return default
+        end
+        
         # Get the associated OSD (datapoint) file from the local filesystem
         #
         def datapoint
@@ -91,6 +233,7 @@ module OpenStudio
             ::JSON.parse(File.read(osa_abs_path), symbolize_names: true)
           end
         end
+        
       end
     end
   end

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

@@ -70,8 +70,6 @@ class RunInitialization < OpenStudio::Workflow::Job
     @registry.register(:runner) { WorkflowRunner.new(@registry[:logger], @registry[:workflow_json], @registry[:openstudio_2]) }
     @logger.debug 'Initialized runner'
 
-    workflow_json.start
-
     # Validate the OSW measures if the flag is set to true, (the default state)
     if @options[:verify_osw]
       @logger.info 'Attempting to validate the measure workflow'
@@ -100,6 +98,14 @@ class RunInitialization < OpenStudio::Workflow::Job
       @registry.register(:model) { OpenStudio::Model::Model.new }
     end
 
+    if @registry[:openstudio_2]
+      if @registry[:model]
+        @registry[:model].setWorkflowJSON(workflow_json.clone)
+      end
+    end
+    
+    # DLM: TODO, load weather_file from options so it can be overriden by user_options
+    
     # Find the weather file, should it exist and be findable
     @logger.debug 'Getting the initial weather file'
     weather_path = workflow_json.weatherFile
@@ -123,14 +129,17 @@ class RunInitialization < OpenStudio::Workflow::Job
       end
 
       if weather_full_path.empty?
-        raise "Weather file #{weather_path} specified but cannot be found"
+        raise "Weather file '#{weather_path}' specified but cannot be found"
       end
       weather_full_path = weather_full_path.get
 
       @registry.register(:wf) { weather_full_path.to_s }
+
     end
     @logger.warn 'No valid weather file defined in either the osm or osw.' unless @registry[:wf]
 
+    workflow_json.start
+    
     nil
   end
 end

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

@@ -30,7 +30,17 @@ class RunOpenStudioMeasures < OpenStudio::Workflow::Job
 
   def perform
     @logger.debug "Calling #{__method__} in the #{self.class} class"
-
+    
+    # set weather file
+    if @registry[:wf] && @registry[:model]
+      epwFile = OpenStudio::EpwFile.load(@registry[:wf])
+      if !epwFile.empty?
+        OpenStudio::Model::WeatherFile.setWeatherFile(@registry[:model], epwFile.get)
+      else
+        @logger.warn "Could not load weather file from '#{weather_full_path.to_s}'"
+      end
+    end
+      
     # Ensure output_attributes is initialized in the registry
     @registry.register(:output_attributes) { {} } unless @registry[:output_attributes]
 

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

@@ -34,25 +34,13 @@ class RunPreprocess < OpenStudio::Workflow::Job
     # Ensure that the directory is created (but it should already be at this point)
     FileUtils.mkdir_p(@registry[:run_dir])
 
-    # Copy in the weather file defined in the registry, or alternately in the options
-    if @registry[:wf]
-      @logger.info "Weather file for EnergyPlus simulation is #{@registry[:wf]}"
-      FileUtils.copy(@registry[:wf], "#{@registry[:run_dir]}/in.epw")
-    elsif @options[:simulation_weather_file]
-      @logger.warn "Using weather file defined in options: #{@options[:simulation_weather_file]}"
-      FileUtils.copy(@options[:simulation_weather_file], "#{@registry[:run_dir]}/in.epw")
-    else
-      @logger.warn "EPW file not found or not sent to #{self.class}"
-    end
-
     # save the pre-preprocess file
     File.open("#{@registry[:run_dir]}/pre-preprocess.idf", 'w') { |f| f << @registry[:model_idf].to_s }
 
     # Add any EnergyPlus Output Requests from Reporting Measures
     @logger.info 'Beginning to collect output requests from Reporting measures.'
-    @options[:energyplus_output_requests] = true
-    apply_measures('ReportingMeasure'.to_MeasureType, @registry, @options)
-    @options[:energyplus_output_requests] = nil
+    energyplus_output_requests = true
+    apply_measures('ReportingMeasure'.to_MeasureType, @registry, @options, energyplus_output_requests)
     @logger.info('Finished collect output requests from Reporting measures.')
 
     # Perform pre-processing on in.idf to capture logic in RunManager

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

@@ -44,25 +44,37 @@ class RunReportingMeasures < OpenStudio::Workflow::Job
     @registry.register(:output_attributes) { {} } unless @registry[:output_attributes]
 
     # Load simulation files as required
-    if @options[:load_simulation_osm]
+    if @registry[:model].nil?
       osm_path = File.absolute_path(File.join(@registry[:run_dir], 'in.osm'))
       @logger.debug "Attempting to load #{osm_path}"
       @registry.register(:model) { load_osm('.', osm_path) }
       raise "Unable to load #{osm_path}" unless @registry[:model]
       @logger.debug "Successfully loaded #{osm_path}"
     end
-    if @options[:load_simulation_idf]
+    if @registry[:model_idf].nil?
       idf_path = File.absolute_path(File.join(@registry[:run_dir], 'in.idf'))
       @logger.debug "Attempting to load #{idf_path}"
       @registry.register(:model_idf) { load_idf('.', idf_path) }
       raise "Unable to load #{idf_path}" unless @registry[:model_idf]
       @logger.debug "Successfully loaded #{idf_path}"
     end
-    if @options[:load_simulation_sql]
-      @registry.register(:sql) { File.absolute_path(File.join(@registry[:run_dir], 'eplusout.sql')) }
-      @logger.debug "Registered the sql filepath as #{@registry[:sql]}"
+    if @registry[:sql].nil?
+      sql_path = File.absolute_path(File.join(@registry[:run_dir], 'eplusout.sql'))
+      if File.exists?(sql_path)
+        @registry.register(:sql) { sql_path }
+        @logger.debug "Registered the sql filepath as #{@registry[:sql]}"
+      end
+      #raise "Unable to load #{sql_path}" unless @registry[:sql]
     end
-
+    if @registry[:wf].nil?
+      epw_path = File.absolute_path(File.join(@registry[:run_dir], 'in.epw'))
+      if File.exists?(epw_path)
+        @registry.register(:wf) { epw_path }
+        @logger.debug "Registered the wf filepath as #{@registry[:wf]}"
+      end
+      #raise "Unable to load #{epw_path}" unless @registry[:wf]
+    end
+    
     # Apply reporting measures
     @options[:output_adapter] = @output_adapter
     @logger.info 'Beginning to execute Reporting measures.'

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

@@ -28,7 +28,19 @@ class RunTranslation < OpenStudio::Workflow::Job
 
   def perform
     @logger.debug "Calling #{__method__} in the #{self.class} class"
+    
+    # Ensure that the run directory is created
+    FileUtils.mkdir_p(@registry[:run_dir])
 
+    # Copy in the weather file defined in the registry, or alternately in the options
+    if @registry[:wf]
+      @logger.info "Weather file for EnergyPlus simulation is #{@registry[:wf]}"
+      FileUtils.copy(@registry[:wf], "#{@registry[:run_dir]}/in.epw")
+      @registry.register(:wf) { "#{@registry[:run_dir]}/in.epw" }
+    else
+      @logger.warn "EPW file not found or not sent to #{self.class}"
+    end
+    
     # Translate the OSM to an IDF
     @logger.info 'Beginning the translation to IDF'
     @registry[:time_logger].start('Translating to EnergyPlus') if @registry[:time_logger]

data/lib/openstudio/workflow/run.rb

@@ -22,6 +22,7 @@ require_relative 'adapters/input/local'
 require_relative 'adapters/output/local'
 
 require 'logger'
+require 'pathname'
 
 # Run Class for OpenStudio workflow.  All comments here need some love, as well as the code itself
 module OpenStudio
@@ -66,37 +67,43 @@ module OpenStudio
       #
       # @param [String] osw_path the path to the OSW file to run. It is highly recommended that this be an absolute
       #   path, however if not it will be made absolute relative to the current working directory
-      # @param [Hash] options ({}) A set of user-specified options that are used to override default behaviors. Some
-      #   sort of definitive documentation is needed for this hash
-      # @option options [Hash] :transitions Non-default transitions set (see Run#default_transition)
-      # @option options [Hash] :states Non-default states set (see Run#default_states)
-      # @option options [Hash] :jobs ???
-      # @todo (rhorsey) establish definitive documentation on all option parameters
-      #
-      def initialize(osw_path, options = {})
+      # @param [Hash] user_options ({}) A set of user-specified options that are used to override default behaviors. 
+      # @option user_options [Hash] :cleanup Remove unneccessary files during post processing, overrides OSW option if set, defaults to true
+      # @option user_options [Hash] :debug Print debugging messages, overrides OSW option if set, defaults to false
+      # @option user_options [Hash] :energyplus_path Specifies path to energyplus executable, defaults to empty
+      # @option user_options [Hash] :jobs Simulation workflow, overrides jobs in OSW if set, defaults to default_jobs
+      # @option user_options [Hash] :output_adapter Output adapter to use, overrides output adapter in OSW if set, defaults to local adapter
+      # @option user_options [Hash] :preserve_run_dir Prevents run directory from being cleaned prior to run, overrides OSW option if set, defaults to false - DLM, Deprecate
+      # @option user_options [Hash] :profile Produce additional output for profiling simulations, defaults to false
+      # @option user_options [Hash] :targets Log targets to write to, defaults to standard out and run.log
+      # @option user_options [Hash] :verify_osw Check OSW for correctness, defaults to true
+      # @option user_options [Hash] :weather_file Initial weather file to load, overrides OSW option if set, defaults to empty
+      def initialize(osw_path, user_options = {})
         # DLM - what is final_message?
         @final_message = ''
         @current_state = nil
-
-        # Registry is a large hash of objects that are populated during the run, the number of objects in the registry should be reduced over time
-        # - openstudio_2 - true if we are running in OpenStudio 2.X environment
-        # - logger - general logger
+        @options = {}
+        
+        # Registry is a large hash of objects that are populated during the run, the number of objects in the registry should be reduced over time, especially if the functionality can be added to the WorkflowJSON class
+        # - analysis - the current OSA parsed as a Ruby Hash
+        # - datapoint - the current OSD parsed as a Ruby Hash
         # - log_targets - IO devices that are being logged to
-        # - time_logger - logger for doing profiling - time to run each step will be captured in OSResult, deprecate
-        # - workflow - the current OSW parsed as a Ruby Hash
-        # - workflow_json - the current WorkflowJSON object
+        # - logger - general logger
+        # - model - the current OpenStudio Model object, updated after each step
+        # - model_idf - the current EnergyPlus Workspace object, updated after each step
+        # - openstudio_2 - true if we are running in OpenStudio 2.X environment
+        # - osw_path - the path the OSW was loaded from as a string
         # - osw_dir - the directory the OSW was loaded from as a string
+        # - output_attributes - added during simulation time
+        # - results - objective function values
         # - root_dir - the root directory in the OSW as a string
         # - run_dir - the run directory for the simulation as a string
-        # - datapoint - the current OSD parsed as a Ruby Hash
-        # - analysis - the current OSA parsed as a Ruby Hash
         # - runner - the current OSRunner object
-        # - results - the output of the run_extract_inputs_and_outputs method
-        # - model - the current OpenStudio Model object, updated after each step
-        # - model_idf - the current EnergyPlus Workspace object, updated after each step
-        # - wf - the path to the current weather file as a string, updated after each step
-        # - output_attributes - ? - deprecate
         # - sql - the path to the current EnergyPlus SQL file as a string
+        # - time_logger - logger for doing profiling - time to run each step will be captured in OSResult, deprecate
+        # - wf - the path to the current weather file as a string, updated after each step
+        # - workflow - the current OSW parsed as a Ruby Hash
+        # - workflow_json - the current WorkflowJSON object        
         @registry = Registry.new
 
         openstudio_2 = false
@@ -110,26 +117,28 @@ module OpenStudio
 
         # get the input osw
         @input_adapter = OpenStudio::Workflow::InputAdapter::Local.new(osw_path)
-
-        # create the output adapter
-        @output_adapter = nil
-        if options[:output_adapter]
-          @output_adapter = options[:output_adapter]
-        else
-          @output_adapter = OpenStudio::Workflow::OutputAdapter::Local.new(output_directory: @input_adapter.run_dir)
-        end
-
-        @registry.register(:osw_path) { @input_adapter.osw_path }
-        @registry.register(:osw_dir) { @input_adapter.osw_dir }
-        @registry.register(:run_dir) { @input_adapter.run_dir }
-
+        
         # DLM: need to check that we have correct permissions to all these paths
+        @registry.register(:osw_path) { Pathname.new(@input_adapter.osw_path).realpath }
+        @registry.register(:osw_dir) { Pathname.new(@input_adapter.osw_dir).realpath }
+        @registry.register(:run_dir) { Pathname.new(@input_adapter.run_dir).cleanpath } # run dir might not yet exist, calling realpath will throw
+        
+        # get info to set up logging first in case of failures later
+        @options[:debug] = @input_adapter.debug(user_options, false)
+        @options[:preserve_run_dir] = @input_adapter.preserve_run_dir(user_options, false)
+        @options[:profile] = @input_adapter.profile(user_options, false)
+        
+        # if running in osw dir, force preserve run dir
+        if @registry[:osw_dir] == @registry[:run_dir]
+          # force preserving the run directory
+          @options[:preserve_run_dir] = true
+        end
 
         # By default blow away the entire run directory every time and recreate it
-        unless options[:preserve_run_dir]
+        unless @options[:preserve_run_dir]
           if File.exist?(@registry[:run_dir])
             # logger is not initialized yet (it needs run dir to exist for log)
-            puts "Removing existing run directory #{@registry[:run_dir]}" if options[:debug]
+            puts "Removing existing run directory #{@registry[:run_dir]}" if @options[:debug]
 
             # DLM: this is dangerous, we are calling rm_rf on a user entered directory, need to check this first
             # TODO: Echoing Dan's comment
@@ -138,17 +147,14 @@ module OpenStudio
         end
         FileUtils.mkdir_p(@registry[:run_dir])
 
-        defaults = {
-          jobs: OpenStudio::Workflow::Run.default_jobs,
-          preserve_run_dir: false,
-          debug: false,
-          profile: true
-        }
-        if options[:targets].nil?
-          # DLM: need to make sure that run.log will be closed later
-          defaults[:targets] = [STDOUT, File.open(File.join(@registry[:run_dir], 'run.log'), 'a')]
+        # set up logging after cleaning run dir
+        if user_options[:targets]
+          @options[:targets] = user_options[:targets]
+        else
+          # don't create these files unless we want to use them
+          # DLM: TODO, make sure that run.log will be closed later 
+          @options[:targets] = [STDOUT, File.open(File.join(@registry[:run_dir], 'run.log'), 'a')]
         end
-        @options = defaults.merge(options)
 
         @registry.register(:log_targets) { @options[:targets] }
         @registry.register(:time_logger) { TimeLogger.new } if @options[:profile]
@@ -158,9 +164,23 @@ module OpenStudio
         @logger = ::Logger.new(MultiDelegator.delegate(:write, :close).to(*@options[:targets])) # * is the splat operator
         @logger.level = logger_level 
         @registry.register(:logger) { @logger }
-
+        
         @logger.info "openstudio_2 = #{@registry[:openstudio_2]}"
         
+        # get the output adapter
+        default_output_adapter = OpenStudio::Workflow::OutputAdapter::Local.new(output_directory: @input_adapter.run_dir)
+        @output_adapter = @input_adapter.output_adapter(user_options, default_output_adapter, @logger)
+
+        # get the jobs
+        default_jobs = OpenStudio::Workflow::Run.default_jobs
+        @jobs = @input_adapter.jobs(user_options, default_jobs, @logger)
+
+        # get other run options out of user_options and into permanent options 
+        @options[:cleanup] = @input_adapter.cleanup(user_options, true)
+        @options[:energyplus_path] = @input_adapter.energyplus_path(user_options, nil) 
+        @options[:verify_osw] = @input_adapter.verify_osw(user_options, true)
+        @options[:weather_file] = @input_adapter.weather_file(user_options, nil)
+
         openstudio_dir = "unknown"
         begin
           openstudio_dir = $OpenStudio_Dir
@@ -175,7 +195,6 @@ module OpenStudio
 
         # Define the state and transitions
         @current_state = :queued
-        @jobs = @options[:jobs]
       end
 
       # execute the workflow defined in the state object
@@ -232,7 +251,7 @@ module OpenStudio
       def step
         step_instance = @jobs.find { |h| h[:state] == @current_state }
         require step_instance[:file]
-        klass = OpenStudio::Workflow.new_class(step_instance[:job], @input_adapter, @output_adapter, @registry, options)
+        klass = OpenStudio::Workflow.new_class(step_instance[:job], @input_adapter, @output_adapter, @registry, @options)
         @output_adapter.communicate_transition("Starting state #{@current_state}", :state)
         state_return = klass.perform
         if state_return