openstudio-workflow 0.0.1

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

@@ -0,0 +1,45 @@
+######################################################################
+#  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 Prelight job to prepare the directory for simulations.
+class RunPreflight
+
+  def initialize(directory, logger, adapter, options = {})
+    defaults = {}
+    @options = defaults.merge(options)
+    @directory = directory
+    @adapter = adapter
+    @results = {}
+    @logger = logger
+
+  end
+
+  def perform
+    @logger.info "Calling #{__method__} in the #{self.class} class"
+
+
+    @adapter.communicate_started @directory, @options
+
+    # Add the moment this does nothing.
+
+    # return the results back to the caller--always
+    @results
+  end
+end

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

@@ -0,0 +1,279 @@
+######################################################################
+#  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 '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'}
+    @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.
+    @run_directory = "#{@directory}/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
+    @weather_filename = nil
+    @weather_directory = File.expand_path(File.join(@options[:analysis_root_path], "weather"))
+    @logger.info "Weather directory is: #{@weather_directory}"
+    @model_xml = nil
+    @model = nil
+    @model_idf = nil
+    @analysis_json = nil
+    # TODO: rename datapoint_json to just datapoint
+    @datapoint_json = nil
+    @output_attributes = {}
+    @report_measures = []
+    @measure_type_lookup = {
+        :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"
+    @datapoint_json = @adapter.get_datapoint(@directory, @options)
+    @analysis_json = @adapter.get_problem(@directory, @options)
+
+    if @analysis_json && @analysis_json[:analysis]
+      @model_xml = load_xml_model
+      @weather_filename = load_weather_file
+
+      apply_xml_measures
+
+      @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)
+      }
+    end
+
+    create_osm_from_xml
+
+    @results
+  end
+
+  private
+
+  def load_xml_model
+    model = nil
+    @logger.info 'Loading seed model'
+
+    if @analysis_json[:analysis][:seed]
+      @logger.info "Seed model is #{@analysis_json[:analysis][:seed]}"
+      if @analysis_json[:analysis][:seed][:path]
+
+        # assume that the seed model has been placed in the directory
+        baseline_model_path = File.expand_path(
+            File.join(@options[:analysis_root_path], @analysis_json[:analysis][:seed][:path]))
+
+        if File.exist? baseline_model_path
+          @logger.info "Reading in baseline model #{baseline_model_path}"
+          model = LibXML::XML::Document.file(baseline_model_path)
+          fail 'XML model is nil' if model.nil?
+
+          model.save("#{@run_directory}/original.xml")
+        else
+          fail "Seed model '#{baseline_model_path}' did not exist"
+        end
+      else
+        fail 'No seed model path in JSON defined'
+      end
+    else
+      fail 'No seed model block'
+    end
+
+    model
+  end
+
+  # Save the weather file to the instance variable
+  def load_weather_file
+    weather_filename = nil
+    if @analysis_json[:analysis][:weather_file]
+      if @analysis_json[:analysis][:weather_file][:path]
+        # This last(4) needs to be cleaned up.  Why don't we know the path of the file?
+        # assume that the seed model has been placed in the directory
+        weather_filename = File.expand_path(
+            File.join(@options[:analysis_root_path], @analysis_json[:analysis][:weather_file][:path]))
+        unless File.exist?(weather_filename)
+          @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
+    else
+      fail 'No weather file block defined'
+    end
+
+    weather_filename
+  end
+
+  def create_osm_from_xml
+    # Save the final state of the XML file
+    xml_filename = "#{@run_directory}/final.xml"
+    @model_xml.save(xml_filename)
+
+    @logger.info 'Starting XML to OSM translation'
+
+    # 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}"
+    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
+      log_message = "Runner error #{__FILE__} failed with #{e.message}, #{e.backtrace.join("\n")}"
+      fail log_message
+    end
+
+    if osm
+      osm_filename = "#{@run_directory}/xml_out.osm"
+      File.open(osm_filename, 'w') { |f| f << osm }
+
+      @logger.info 'Finished XML to OSM translation'
+    else
+      fail 'No OSM model output from XML translation'
+    end
+
+    @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))
+  end
+
+  def apply_xml_measures
+    # iterate over the workflow and grab the measures
+    if @analysis_json[:analysis][:problem] && @analysis_json[:analysis][:problem][:workflow]
+      @analysis_json[:analysis][:problem][:workflow].each do |wf|
+        if wf[:measure_type] == 'XmlMeasure'
+          # need to map the variables to the XML classes
+          measure_path = wf[:measure_definition_directory]
+          measure_name = wf[:measure_definition_class_name]
+
+          @logger.info "XML Measure path is #{measure_path}"
+          @logger.info "XML Measure name is #{measure_name}"
+
+          @logger.info "Loading measure in relative path #{measure_path}"
+          measure_file_path = File.expand_path(
+              File.join(@options[:analysis_root_path], measure_path, 'measure.rb'))
+          fail "Measure file does not exist #{measure_name} in #{measure_file_path}" unless File.exist? measure_file_path
+
+          require measure_file_path
+          measure = Object.const_get(measure_name).new
+
+          @logger.info "iterate over arguments for workflow item #{wf[:name]}"
+
+          # The Argument hash in the workflow json file looks like the following
+          # {
+          #    "display_name": "Set XPath",
+          #    "machine_name": "set_xpath",
+          #    "name": "xpath",
+          #    "value": "/building/blocks/block/envelope/surfaces/window/layout/wwr",
+          #    "uuid": "440dcce0-7663-0131-41f1-14109fdf0b37",
+          #    "version_uuid": "440e4bd0-7663-0131-41f2-14109fdf0b37"
+          # }
+          args = {}
+          if wf[:arguments]
+            wf[:arguments].each do |wf_arg|
+              if wf_arg[:value]
+                @logger.info "Setting argument value #{wf_arg[:name]} to #{wf_arg[:value]}"
+                # Note that these measures have symbolized hash keys and not strings.  I really want indifferential access here!
+                args[wf_arg[:name].to_sym] = wf_arg[:value]
+              end
+            end
+          end
+
+          @logger.info "iterate over variables for workflow item #{wf[:name]}"
+          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"
+              # },
+              variable_uuid = wf_var[:uuid].to_sym # this is what the variable value is set to
+              if wf_var[:argument]
+                variable_name = wf_var[:argument][:name]
+
+                # 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]}"
+
+                      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]}_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]}'"
+
+                      # Catch a very specific case where the weather file has to be changed
+                      if wf[:name] == 'location'
+                        @logger.warn "VERY SPECIFIC case to change the location to #{@datapoint_json[:data_point][:set_variable_values][variable_uuid]}"
+                        @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
+                    end
+                  else
+                    fail 'No block for set_variable_values in data point record'
+                  end
+                else
+                  fail 'No block for data_point in data_point record'
+                end
+              end
+            end
+          end
+
+          # Run the XML Measure
+          xml_changed = measure.run(@model_xml, nil, args)
+
+          # save the JSON with the changed values
+          # the measure has to implement the "results_to_json" method
+          @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

data/lib/openstudio/workflow/multi_delegator.rb

@@ -0,0 +1,48 @@
+######################################################################
+#  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 '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
+
+# Class to allow multiple logging paths
+class MultiDelegator
+  def initialize(*targets)
+    @targets = targets
+  end
+
+  def self.delegate(*methods)
+    methods.each do |m|
+      define_method(m) do |*args|
+        @targets.map { |t| t.send(m, *args) }
+      end
+    end
+    self
+  end
+
+  class <<self
+    alias to new
+  end
+end

data/lib/openstudio/workflow/run.rb

@@ -0,0 +1,258 @@
+######################################################################
+#  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 Class for OpenStudio workflow.  The data are passed in via the adapter
+module OpenStudio
+  module Workflow
+    class Run
+      include AASM
+
+      attr_accessor :logger
+
+      attr_reader :options
+      attr_reader :adapter
+      attr_reader :directory
+      attr_reader :run_directory
+      attr_reader :final_state
+      attr_reader :job_results
+
+
+      # Create a nice name for the state object instead of aasm
+      alias 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},
+        ]
+      end
+
+      # The default states for the workflow.  Note that the states of :queued of :finished need
+      # to exist for all cases.
+      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}
+        ]
+      end
+
+      # initialize a new run class
+      #
+      # @param adapter an instance of the adapter class
+      # @param directory location of the datapoint directory to run. This is needed
+      #        independent of the adapter that is being used. Note that the simulation will actually run in 'run'
+      def initialize(adapter, directory, options = {})
+        @adapter = adapter
+        @directory = directory
+        # TODO: run directory is a convention right now. Move to a configuration item
+        @run_directory = "#{@directory}/run"
+
+        defaults = {
+            transitions: OpenStudio::Workflow::Run.default_transition,
+            states: OpenStudio::Workflow::Run.default_states,
+            jobs: {}
+        }
+        @options = defaults.merge(options)
+
+        @error = false
+
+        @job_results = {}
+
+        # By default blow away the entire run directory every time and recreate it
+        FileUtils.rm_rf(@run_directory) if File.exist?(@run_directory)
+        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")
+
+        l = @adapter.get_logger @directory, @options
+        if l
+          @logger = ::Logger.new MultiDelegator.delegate(:write, :close).to(STDOUT, log_file, l)
+        else
+          @logger = ::Logger.new MultiDelegator.delegate(:write, :close).to(STDOUT, log_file)
+        end
+
+        @logger.info "Initializing directory #{@directory} for simulation with options #{@options}"
+
+        super()
+
+        # load the state machine
+        machine
+      end
+
+      # 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"
+        begin
+          while self.state.current_state != :finished && !@error
+            self.step
+          end
+
+          @logger.info "Finished workflow"
+
+          if @error
+            # need to tell the system that this failed
+            @adapter.communicate_failure @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"
+
+          # TODO: define the outputs and figure out how to show it correctory
+          obj_function_array ||= ['NA']
+
+          # Print the objective functions to the screen even though the file is being used right now
+          # Note as well that we can't guarantee that the csv format will be in the right order
+          puts obj_function_array.join(',')
+        end
+
+        state.current_state
+      end
+
+      # call back for when there is an exception running any of the state transitions
+      def step_error(*args)
+        # Make sure to set the instance variable @error to true in order to stop the :step
+        # event from being fired.
+        @error = true
+        @logger.error "Found error in state '#{aasm.current_state}' with message #{args}}"
+
+        # Call the error_out event to transition to the :errored state
+        error_out
+      end
+
+      # TODO: these methods needs to be dynamic or inherited
+      # run energplus
+      def run_energyplus
+        @logger.info "Running #{__method__}"
+        klass = get_run_class(__method__)
+
+        @job_results[__method__.to_sym] = klass.perform
+      end
+
+      # run openstudio to create the model and apply the measures
+      def run_openstudio
+        @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__)
+
+        @job_results[__method__.to_sym] = klass.perform
+      end
+
+      # preconfigured run method for preflight. This configures the input directories and sets everything
+      # up for running the simulations.
+      def run_preflight
+        @logger.info "Running #{__method__}"
+        klass = get_run_class(__method__)
+
+        @job_results[__method__.to_sym] = klass.perform
+      end
+
+      def run_xml
+        @logger.info "Running #{__method__}"
+        klass = get_run_class(__method__)
+
+        @job_results[__method__.to_sym] = klass.perform
+        @logger.info @job_results
+      end
+
+      def final_state
+        state.current_state
+      end
+
+      private
+
+      # Create a state machine from the predefined transitions methods.  This loads in
+      # 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"
+        @options[:states].each do |s|
+          s[:options] ? o = s[:options] : o = {}
+          OpenStudio::Workflow::Run.aasm.states << AASM::State.new(s[:state], self.class, o)
+        end
+        OpenStudio::Workflow::Run.aasm.initial_state(:queued)
+
+        # Create a new event and add in the transitions
+        new_event = OpenStudio::Workflow::Run.aasm.event(:step)
+        event = OpenStudio::Workflow::Run.aasm.events[:step]
+
+        # TODO: make a config option to not go to the error state. Useful to not error-state when testing
+        event.options[:error] = 'step_error'
+        @options[:transitions].each do |t|
+          event.transitions(t)
+        end
+
+        # 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)
+      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}"
+        #  result = @options[:jobs][state.current_state]
+        #end
+
+        #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.
+        @options.merge(@job_results)
+      end
+
+      def get_run_class(from_method)
+        require_relative "jobs/#{from_method}/#{from_method}"
+        klass_name = from_method.to_s.split('_').map(&:capitalize) * ''
+        @logger.info "Getting method for state transition '#{from_method}'"
+        klass = Object.const_get(klass_name).new(@directory, @logger, @adapter, get_job_options)
+        klass
+      end
+    end
+  end
+end