openstudio-workflow 1.0.0.pat1 → 1.0.0

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

@@ -0,0 +1,136 @@
+######################################################################
+#  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
+######################################################################
+
+# Run the initialization job to run validations and initializations
+class RunInitialization < OpenStudio::Workflow::Job
+  require 'openstudio/workflow/util'
+  include OpenStudio::Workflow::Util::WeatherFile
+  include OpenStudio::Workflow::Util::Model
+  include OpenStudio::Workflow::Util::Measure
+
+  def initialize(input_adapter, output_adapter, registry, options = {})
+    defaults = {
+      verify_osw: true
+    }
+    options = defaults.merge(options)
+    super
+  end
+
+  def perform
+    # DLM: why are there multiple loggers running around?  there is one in the registry can we just use that?
+    @logger.info "Calling #{__method__} in the #{self.class} class"
+
+    # Communicate that the workflow has been started
+    @logger.debug 'Registering that the workflow has started with the adapter'
+    @output_adapter.communicate_started
+
+    # Load various files and set basic directories for the registry
+    @registry.register(:workflow) { @input_adapter.workflow }
+    raise 'Specified workflow was nil' unless @registry[:workflow]
+    @logger.debug 'Retrieved the workflow from the adapter'
+
+    @registry.register(:osw_dir) { @input_adapter.osw_dir }
+    @logger.debug "osw_dir is #{@registry[:osw_dir]}"
+
+    @registry.register(:datapoint) { @input_adapter.datapoint }
+    @logger.debug 'Found associated OSD file' if @registry[:datapoint]
+
+    @registry.register(:analysis) { @input_adapter.analysis }
+    @logger.debug 'Found associated OSA file' if @registry[:analysis]
+
+    # create the real WorkflowJSON here, we will be able to edit this during the run
+    if @registry[:openstudio_2]
+      workflow_json = OpenStudio::WorkflowJSON.new(JSON.fast_generate(@registry[:workflow]))
+      workflow_json.setOswDir(@registry[:osw_dir])
+    else
+      workflow_json = WorkflowJSON_Shim.new(@registry[:workflow], @registry[:osw_dir])
+    end
+    @registry.register(:workflow_json) { workflow_json }
+
+    @registry.register(:root_dir) { workflow_json.absoluteRootDir }
+    @logger.debug "The root_dir for the datapoint is #{@registry[:root_dir]}"
+
+    # create the runner with our WorkflowJSON
+    @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'
+      validate_measures(@registry, @logger)
+      @logger.info 'Validated the measure workflow'
+    end
+
+    # Load or create the seed OSM object
+    @logger.debug 'Finding and loading the seed file'
+    model_path = workflow_json.seedFile
+    if !model_path.empty?
+
+      model_full_path = workflow_json.findFile(model_path.get)
+      if model_full_path.empty?
+        raise "Seed model #{model_path.get} specified in OSW cannot be found"
+      end
+      model_full_path = model_full_path.get
+
+      if File.extname(model_full_path.to_s) == '.idf'
+        @registry.register(:model_idf) { load_idf(model_full_path, @logger) }
+        @registry.register(:model) { nil }
+      else
+        @registry.register(:model) { load_osm(model_full_path, @logger) }
+      end
+    else
+      @registry.register(:model) { OpenStudio::Model::Model.new }
+    end
+
+    # Find the weather file, should it exist and be findable
+    @logger.debug 'Getting the initial weather file'
+    weather_path = workflow_json.weatherFile
+    if weather_path.empty?
+      @logger.debug 'No weather file specified in OSW, looking in model'
+      if @registry[:model]
+        model = @registry[:model]
+        unless model.weatherFile.empty?
+          weather_path = model.weatherFile.get.path
+        end
+      end
+    end
+
+    unless weather_path.empty?
+      weather_path = weather_path.get
+      @logger.debug 'Searching for weather file #{weather_path}'
+
+      weather_full_path = workflow_json.findFile(weather_path)
+      if weather_full_path.empty?
+        weather_full_path = workflow_json.findFile(File.basename(weather_path.to_s))
+      end
+
+      if weather_full_path.empty?
+        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]
+
+    nil
+  end
+end

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

@@ -0,0 +1,59 @@
+######################################################################
+#  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
+######################################################################
+
+# Run any OpenStudio measures contained in the OSW
+class RunOpenStudioMeasures < OpenStudio::Workflow::Job
+  # Mixin the required util modules
+  require 'openstudio/workflow/util'
+  include OpenStudio::Workflow::Util::Measure
+  include OpenStudio::Workflow::Util::Model
+
+  def initialize(input_adapter, output_adapter, registry, options = {})
+    super
+  end
+
+  def perform
+    @logger.debug "Calling #{__method__} in the #{self.class} class"
+
+    # Ensure output_attributes is initialized in the registry
+    @registry.register(:output_attributes) { {} } unless @registry[:output_attributes]
+
+    # Execute the OpenStudio measures
+    @options[:output_adapter] = @output_adapter
+    @logger.info 'Beginning to execute OpenStudio measures.'
+    apply_measures('ModelMeasure'.to_MeasureType, @registry, @options)
+    @logger.info('Finished applying OpenStudio measures.')
+
+    # Send the measure output attributes to the output adapter
+    @logger.debug 'Communicating measure output attributes to the output adapter'
+    @output_adapter.communicate_measure_attributes @registry[:output_attributes]
+
+    # save the final OSM
+    save_osm(@registry[:model], @registry[:run_dir])
+
+    # Save the OSM if the :debug option is true
+    return nil unless @options[:debug]
+    @registry[:time_logger].start('Saving OSM') if @registry[:time_logger]
+    osm_name = save_osm(@registry[:model], @registry[:root_dir])
+    @registry[:time_logger].stop('Saving OSM') if @registry[:time_logger]
+    @logger.debug "Saved model as #{osm_name}"
+
+    nil
+  end
+end

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

@@ -0,0 +1,53 @@
+######################################################################
+#  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
+######################################################################
+
+# Clean up the run directory. Currently this class does nothing else, although eventually cleanup should become driven
+# and responsive to options
+class RunPostprocess < OpenStudio::Workflow::Job
+  require 'openstudio/workflow/util/post_process'
+  include OpenStudio::Workflow::Util::PostProcess
+
+  def initialize(input_adapter, output_adapter, registry, options = {})
+    defaults = {
+      cleanup: true
+    }
+    options = defaults.merge(options)
+    super
+  end
+
+  def perform
+    @logger.debug "Calling #{__method__} in the #{self.class} class"
+
+    @logger.info 'Gathering reports'
+    gather_reports(@registry[:run_dir], @registry[:root_dir], @logger)
+    @logger.info 'Finished gathering reports'
+
+    if @options[:cleanup]
+      @logger.info 'Beginning cleanup of the run directory'
+      cleanup(@registry[:run_dir], @registry[:root_dir], @logger)
+      @logger.info 'Finished cleanup of the run directory'
+    else
+      @logger.info 'Flag for cleanup in options set to false. Moving to next step.'
+    end
+
+    @logger.info 'Finished postprocess'
+
+    nil
+  end
+end

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

@@ -0,0 +1,81 @@
+######################################################################
+#  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
+######################################################################
+
+# Prepares the directory for the EnergyPlus simulation
+class RunPreprocess < OpenStudio::Workflow::Job
+  require 'openstudio/workflow/util'
+  include OpenStudio::Workflow::Util::EnergyPlus
+  include OpenStudio::Workflow::Util::Model
+  include OpenStudio::Workflow::Util::Measure
+
+  def initialize(input_adapter, output_adapter, registry, options = {})
+    super
+  end
+
+  def perform
+    @logger.debug "Calling #{__method__} in the #{self.class} class"
+
+    # 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
+    @logger.info('Finished collect output requests from Reporting measures.')
+
+    # Perform pre-processing on in.idf to capture logic in RunManager
+    @registry[:time_logger].start('Running EnergyPlus Preprocess') if @registry[:time_logger]
+    energyplus_preprocess(@registry[:model_idf], @logger)
+    @registry[:time_logger].start('Running EnergyPlus Preprocess') if @registry[:time_logger]
+    @logger.info 'Finished preprocess job for EnergyPlus simulation'
+
+    # Save the model objects in the registry to the run directory
+    if File.exist?("#{@registry[:run_dir]}/in.idf")
+      # DLM: why is this here?
+      @logger.warn 'IDF (in.idf) already exists in the run directory. Will simulate using this file'
+    else
+      save_idf(@registry[:model_idf], @registry[:run_dir])
+    end
+
+    # Save the generated IDF file if the :debug option is true
+    return nil unless @options[:debug]
+    @registry[:time_logger].start('Saving IDF') if @registry[:time_logger]
+    idf_name = save_idf(@registry[:model_idf], @registry[:root_dir])
+    @registry[:time_logger].stop('Saving IDF') if @registry[:time_logger]
+    @logger.debug "Saved IDF as #{idf_name}"
+
+    nil
+  end
+end

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

@@ -0,0 +1,86 @@
+######################################################################
+#  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
+######################################################################
+
+# Run reporting measures and execute scripts to post-process objective functions and results on the filesystem
+class RunReportingMeasures < OpenStudio::Workflow::Job
+  require 'csv'
+  require 'ostruct'
+  require 'openstudio/workflow/util'
+  include OpenStudio::Workflow::Util::Model
+  include OpenStudio::Workflow::Util::Measure
+  include OpenStudio::Workflow::Util::PostProcess
+
+  def initialize(input_adapter, output_adapter, registry, options = {})
+    defaults = {
+      load_simulation_osm: false,
+      load_simulation_idf: false,
+      load_simulation_sql: false
+    }
+    options = defaults.merge(options)
+    super
+  end
+
+  def perform
+    @logger.debug "Calling #{__method__} in the #{self.class} class"
+    @logger.debug 'RunPostProcess Retrieving datapoint and problem'
+
+    # Ensure output_attributes is initialized in the registry
+    @registry.register(:output_attributes) { {} } unless @registry[:output_attributes]
+
+    # Load simulation files as required
+    if @options[:load_simulation_osm]
+      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]
+      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]}"
+    end
+
+    # Apply reporting measures
+    @options[:output_adapter] = @output_adapter
+    @logger.info 'Beginning to execute Reporting measures.'
+    apply_measures('ReportingMeasure'.to_MeasureType, @registry, @options)
+    @logger.info('Finished applying Reporting measures.')
+
+    # Send the updated measure_attributes to the output adapter
+    @logger.debug 'Communicating measures output attributes to the output adapter'
+    @output_adapter.communicate_measure_attributes @registry[:output_attributes]
+
+    # Parse the files generated by the local output adapter
+    results, objective_functions = run_extract_inputs_and_outputs @registry[:run_dir], @logger
+    @registry.register(:results) { results }
+
+    # Send the objective function results to the output adapter
+    @logger.debug "Objective Function JSON is #{objective_functions}"
+    @output_adapter.communicate_objective_function objective_functions
+
+    nil
+  end
+end

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

@@ -0,0 +1,49 @@
+######################################################################
+#  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
+######################################################################
+
+# Run the initialization job to validate the directory and initialize the adapters.
+class RunTranslation < OpenStudio::Workflow::Job
+  require 'openstudio/workflow/util/model'
+  include OpenStudio::Workflow::Util::Model
+
+  def initialize(input_adapter, output_adapter, registry, options = {})
+    super
+  end
+
+  def perform
+    @logger.debug "Calling #{__method__} in the #{self.class} class"
+
+    # Translate the OSM to an IDF
+    @logger.info 'Beginning the translation to IDF'
+    @registry[:time_logger].start('Translating to EnergyPlus') if @registry[:time_logger]
+    model_idf = translate_to_energyplus @registry[:model], @logger
+    @registry[:time_logger].stop('Translating to EnergyPlus') if @registry[:time_logger]
+    @registry.register(:model_idf) { model_idf }
+    @logger.info 'Successfully translated to IDF'
+
+    # Save the generated IDF file if the :debug option is true
+    return nil unless @options[:debug]
+    @registry[:time_logger].start('Saving IDF') if @registry[:time_logger]
+    idf_name = save_idf(@registry[:model_idf], @registry[:root_dir])
+    @registry[:time_logger].stop('Saving IDF') if @registry[:time_logger]
+    @logger.debug "Saved IDF as #{idf_name}"
+
+    nil
+  end
+end

data/lib/openstudio/workflow/multi_delegator.rb

@@ -21,8 +21,6 @@ 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]
   end
 end
@@ -43,6 +41,6 @@ class MultiDelegator
   end
 
   class <<self
-    alias_method :to, :new
+    alias to new
   end
 end

data/lib/openstudio/workflow/registry.rb

@@ -0,0 +1,137 @@
+module OpenStudio
+  module Workflow
+    # Registers objects in a single place. Based on Hashicorps's Vagrant Registry class
+    #
+    # This allows certain components (such as models, weather files, proxy settings, etc.) to be registered as blocks
+    #   and lazily updated. This allows for the state of various objects to be updated through evaluation of or
+    #   overwriting the key. An instance of this class is passed between jobs to allow for highly flexible workflow
+    #   definitions. Note that hashes can be passed into the registry as follows: hash = {...};
+    #   Registry.new.register(:hash) { hash } or Registry.new.register(:hash) { {...} }. This class will likely absorb
+    #   un-abstracted elements of the adapter class, see Workflow#Adapter
+
+    # @todo (rhorsey) registry should be a member of WorkflowRunner - DLM
+    # @todo (rhorsey) how is this different than a regular hash?  why is it important to be able to register keys with blocks that return values instead of values, looks like the block is called on insert anyway? let's not go crazy on performance optimizations until we have to - DLM
+    class Registry
+      def initialize
+        @items = {}
+        @results_cache = {}
+      end
+
+      # Register a key and cache it's value. Note that if a key with the given name already exists it is overwritten
+      #
+      # @param [] key The key for the passed in block. Symbols are highly recommended
+      # @param [Proc] block The block (Proc) which contains the registered information
+      # @return [] Returns block.call from the registries cache
+      #
+      def register(key, &block)
+        raise ArgumentError, 'block required' unless block_given?
+        @items[key] = block
+        @results_cache[key] = @items[key].call
+      end
+
+      # Get the cached value of the given key
+      #
+      # @param [] key  The key defining the block
+      # @return [] Returns the registries cached value for the key or nil if the key was not found
+      #
+      def get(key)
+        return nil unless @items.key?(key)
+        @results_cache[key]
+      end
+      alias [] get
+
+      # Re-evaluate the proc of a key and update the cache
+      #
+      # @param [Sym or String] key This will evaluate the item assigned to the key and update the cache if possible
+      # @return [] If successful the method returns the new value, and if it cannot find or cannot update the key it
+      #   returns nil
+      #
+      def eval(key)
+        return nil unless @items.key?(key)
+        begin
+          @items[key].call
+        rescue
+          return nil
+        end
+        @results_cache[key] = @items[key].call
+      end
+
+      # Checks if the given key is registered with the registry
+      #
+      # @return [Boolean]
+      #
+      def key?(key)
+        @items.key?(key)
+      end
+      alias has_key? key?
+
+      # Returns an array populated with the keys of this object
+      #
+      # @return [Array]
+      #
+      def keys
+        @items.keys
+      end
+
+      # Return the number of elements in this registry
+      #
+      # @return [Fixnum]
+      #
+      def length
+        @items.keys.length
+      end
+      alias size length
+
+      # Checks if this registry has any items
+      #
+      # @return [Boolean]
+      #
+      def empty?
+        @items.keys.empty?
+      end
+
+      # Merge one registry with another and return a completely new registry. Note that the result cache is completely
+      #   busted, so any gets on the new registry will result in a cache miss
+      #
+      # @param [Registry] other The other #Registry to merge onto of self
+      # @return [Registry] A merged #Registry
+      #
+      def merge(other)
+        self.class.new.tap do |result|
+          result.merge!(self)
+          result.merge!(other)
+        end
+      end
+
+      # Like #merge but updates self
+      #
+      # @param [Registry] other The other #Registry to merge onto of self
+      # @return [Void]
+      #
+      def merge!(other)
+        @items.merge!(other.__internal_state[:items])
+        self
+      end
+
+      # Converts the registry to a hash
+      #
+      # @return [Hash] The registry as a hash
+      #
+      def to_hash
+        result = {}
+        @results_cache.each_pair do |key, value|
+          result[key] = value
+        end
+
+        result
+      end
+
+      def __internal_state
+        {
+          items: @items,
+          results_cache: @results_cache
+        }
+      end
+    end
+  end
+end