openstudio-workflow 0.0.1 → 0.0.2

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

@@ -0,0 +1,229 @@
+######################################################################
+#  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
+######################################################################
+
+# module containing the methods to apply measures to a model
+# must define the following
+#   @logger : where to log information
+#   @model : the OpenStudio model on which to apply measures
+#   @datapoint_json : the datapoint JSON
+#   @anlaysis_json : the analysis JSON
+#   @output_attributes : hash to store any output attributes
+#   @sql_filename : needed for reporting measures
+
+module OpenStudio
+  module Workflow
+    module ApplyMeasures
+      MEASURE_TYPES = {
+        openstudio_measure: 'RubyMeasure',
+        energyplus_measure: 'EnergyPlusMeasure',
+        reporting_measure: 'ReportingMeasure'
+      }
+
+      def apply_arguments(argument_map, argument)
+        success = true
+
+        unless argument[:value].nil?
+          @logger.info "Setting argument value #{argument[:name]} to #{argument[:value]}"
+
+          v = argument_map[argument[:name]]
+          fail "Could not find argument map in measure for '#{argument[:name]}' with value '#{argument[:value]}'" unless v
+          value_set = v.setValue(argument[:value])
+          fail "Could not set argument #{argument[:name]} of value #{argument[:value]} on model" unless value_set
+          argument_map[argument[:name]] = v.clone
+        else
+          @logger.warn "Value for argument '#{argument[:name]}' not set in argument list therefore will use default"
+          # success = false
+
+          # TODO: what is the fail case (success = false?)
+        end
+
+        success
+      end
+
+      # Apply the variable values to the measure argument map object
+      def apply_variables(argument_map, variable)
+        success = true
+
+        # save the uuid of the variable
+        variable_uuid = variable[:uuid].to_sym
+        if variable[:argument]
+          variable_name = variable[: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]
+              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]}"
+                v = argument_map[variable_name]
+                fail 'Could not find argument map in measure' unless v
+                variable_value = @datapoint_json[:data_point][:set_variable_values][variable_uuid]
+                value_set = v.setValue(variable_value)
+                fail "Could not set variable '#{variable_name}' of value #{variable_value} on model" unless value_set
+                argument_map[variable_name] = v.clone
+              else
+                fail "[ERROR] Value for variable '#{variable_name}:#{variable_uuid}' not set in datapoint object"
+                # @logger.error "Value for variable '#{variable_name}:#{variable_uuid}' not set in datapoint object"
+                # success = false
+              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
+        else
+          fail "Variable '#{variable_name}' is defined but no argument is present"
+        end
+
+        success
+      end
+
+      def apply_measure(workflow_item)
+        @logger.info "Starting #{__method__} for #{workflow_item[:name]}"
+        start_time = ::Time.now
+        current_dir = Dir.pwd
+        begin
+
+          measure_working_directory = "#{@run_directory}/#{workflow_item[:measure_definition_class_name]}"
+
+          @logger.info "Creating run directory to #{measure_working_directory}"
+          FileUtils.mkdir_p measure_working_directory
+          Dir.chdir measure_working_directory
+
+          measure_path = workflow_item[:measure_definition_directory]
+          measure_name = workflow_item[:measure_definition_class_name]
+          @logger.info "Apply measure running in #{Dir.pwd}"
+
+          measure_file_path = nil
+          if (Pathname.new measure_path).absolute?
+            measure_file_path = measure_path
+          else
+            measure_file_path = File.expand_path(File.join(@options[:analysis_root_path], measure_path, 'measure.rb'))
+          end
+
+          @logger.info "Loading Measure from #{measure_file_path}"
+          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
+          runner = OpenStudio::Ruleset::OSRunner.new
+          result = nil
+
+          arguments = nil
+          if workflow_item[:measure_type] == 'RubyMeasure'
+            arguments = measure.arguments(@model)
+          elsif workflow_item[:measure_type] == 'EnergyPlusMeasure'
+            arguments = measure.arguments(@model)
+          elsif workflow_item[:measure_type] == 'ReportingMeasure'
+            arguments = measure.arguments
+          end
+
+          # Create argument map and initialize all the arguments
+          argument_map = OpenStudio::Ruleset::OSArgumentMap.new
+          arguments.each do |v|
+            argument_map[v.name] = v.clone
+          end
+          # @logger.info "Argument map for measure is #{argument_map}"
+
+          @logger.info "Iterating over arguments for workflow item '#{workflow_item[:name]}'"
+          if workflow_item[:arguments]
+            workflow_item[:arguments].each do |argument|
+              success = apply_arguments(argument_map, argument)
+              fail 'Could not set arguments' unless success
+            end
+          end
+
+          @logger.info "Iterating over variables for workflow item '#{workflow_item[:name]}'"
+          if workflow_item[:variables]
+            workflow_item[:variables].each do |variable|
+              success = apply_variables(argument_map, variable)
+              fail 'Could not set variables' unless success
+            end
+          end
+
+          begin
+            @logger.info "Calling measure.run for '#{workflow_item[:name]}'"
+            if workflow_item[:measure_type] == 'RubyMeasure'
+              measure.run(@model, runner, argument_map)
+            elsif workflow_item[:measure_type] == 'EnergyPlusMeasure'
+              measure.run(@model_idf, runner, argument_map)
+            elsif workflow_item[:measure_type] == 'ReportingMeasure'
+              # This is silly, set the last model and last sqlfile instead of passing it into the measure.run method
+              runner.setLastOpenStudioModel(@model)
+              runner.setLastEnergyPlusSqlFilePath(@sql_filename)
+
+              measure.run(runner, argument_map)
+            end
+            @logger.info "Finished measure.run for '#{workflow_item[:name]}'"
+          rescue => e
+            log_message = "Runner error #{__FILE__} failed with #{e.message}, #{e.backtrace.join("\n")}"
+            raise log_message
+          end
+
+          begin
+            result = runner.result
+            @logger.info "Running of measure '#{workflow_item[:name]}' completed. Post-processing measure output"
+
+            @logger.info result.initialCondition.get.logMessage unless result.initialCondition.empty?
+            @logger.info result.finalCondition.get.logMessage unless result.finalCondition.empty?
+
+            result.warnings.each { |w| @logger.warn w.logMessage }
+            an_error = false
+            result.errors.each do |w|
+              @logger.error w.logMessage
+              an_error = true
+            end
+            fail "Measure #{measure_name} reported an error, check log" if an_error
+            result.info.each { |w| @logger.info w.logMessage }
+          rescue => e
+            log_message = "Runner error #{__FILE__} failed with #{e.message}, #{e.backtrace.join("\n")}"
+            raise log_message
+          end
+
+          begin
+            measure_attributes = JSON.parse(OpenStudio.toJSON(result.attributes), symbolize_names: true)
+            @output_attributes[workflow_item[:name].to_sym] = measure_attributes[:attributes]
+          rescue => e
+            log_message = "TODO: #{__FILE__} failed with #{e.message}, #{e.backtrace.join("\n")}"
+            @logger.warn log_message
+          end
+        ensure
+          Dir.chdir current_dir
+          @logger.info "Finished #{__method__} for #{workflow_item[:name]} in #{::Time.now - start_time} s"
+        end
+      end
+
+      def apply_measures(measure_type)
+        if @analysis_json[:analysis][:problem] && @analysis_json[:analysis][:problem][:workflow]
+          current_dir = Dir.pwd
+          begin
+            @logger.info "Applying measures for #{MEASURE_TYPES[measure_type]}"
+            @analysis_json[:analysis][:problem][:workflow].each do |wf|
+              next unless wf[:measure_type] == MEASURE_TYPES[measure_type]
+
+              apply_measure(wf)
+            end
+          ensure
+            Dir.chdir current_dir
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -18,19 +18,17 @@
 ######################################################################
 
 class RunEnergyplus
-
   # 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'
+      energyplus_path = '/usr/local/EnergyPlus-8-1-0'
     end
-    
+
     defaults = {
       energyplus_path: energyplus_path
     }
@@ -64,8 +62,8 @@ class RunEnergyplus
     end
 
     # Need to check the in.idf and in.osm
-    #FileUtils.copy(options[:osm], "#{@run_directory}/in.osm")
-    #FileUtils.copy(options[:idf], "#{@run_directory}/in.idf")
+    # FileUtils.copy(options[:osm], "#{@run_directory}/in.osm")
+    # FileUtils.copy(options[:idf], "#{@run_directory}/in.idf")
 
     # can't create symlinks because the /vagrant mount is actually a windows mount
     @logger.info "Copying EnergyPlus files to run directory: #{@run_directory}"
@@ -92,7 +90,7 @@ class RunEnergyplus
       @logger.info "Starting simulation in run directory: #{Dir.pwd}"
 
       File.open('stdout-expandobject', 'w') do |file|
-        IO.popen('ExpandObjects') do |io|
+        IO.popen('./ExpandObjects') do |io|
           while (line = io.gets)
             file << line
           end
@@ -107,14 +105,13 @@ class RunEnergyplus
 
       # create stdout
       File.open('stdout-energyplus', 'w') do |file|
-        IO.popen('EnergyPlus') do |io|
+        IO.popen('./EnergyPlus') do |io|
           while (line = io.gets)
             file << line
           end
         end
       end
-
-    rescue Exception => e
+    rescue => e
       log_message = "#{__FILE__} failed with #{e.message}, #{e.backtrace.join("\n")}"
       @logger.error log_message
     ensure

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

@@ -19,13 +19,14 @@
 
 # TODO: I hear that measures can step on each other if not run in their own directory
 class RunOpenstudio
-  CRASH_ON_NO_WORKFLOW_VARIABLE = false
+  # 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 = {})
-    defaults = {format: 'hash', use_monthly_reports: false, analysis_root_path: '.'}
+    defaults = { format: 'hash', use_monthly_reports: false, analysis_root_path: '.' }
     @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.
@@ -38,28 +39,26 @@ class RunOpenstudio
     # 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 = []
-    @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"
+    @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 = load_seed_model
+
       load_weather_file
 
       apply_measures(:openstudio_measure)
@@ -68,10 +67,19 @@ class RunOpenstudio
 
       apply_measures(:energyplus_measure)
 
-      @logger.info "Measure output attributes JSON is #{@output_attributes}"
-      File.open("#{@run_directory}/measure_attributes.json", 'w') {
+      # check if the weather file has changed. This is cheesy for now. Should have a default measure that
+      # always sets the weather file so that it can be better controlled
+      updated_weather_file = get_weather_file_from_model
+      unless updated_weather_file == @initial_weather_file
+        # reset the result hash so the future processes know which weather file to run
+        @logger.info "Updating the weather file result to be #{updated_weather_file }"
+        @results[:weather_filename] = "#{@weather_file_path}/#{updated_weather_file}"
+      end
+
+      @logger.info 'Saving measure output attributes JSON'
+      File.open("#{@run_directory}/measure_attributes.json", 'w') do
           |f| f << JSON.pretty_generate(@output_attributes)
-      }
+      end
     end
 
     save_osm_and_idf
@@ -147,7 +155,7 @@ class RunOpenstudio
         fail "Seed model '#{baseline_model_path}' did not exist"
       end
     else
-      fail "No baseline/seed model found"
+      fail 'No baseline/seed model found'
     end
 
     model
@@ -155,6 +163,8 @@ class RunOpenstudio
 
   # Save the weather file to the instance variable
   def load_weather_file
+    @initial_weather_file = get_weather_file_from_model
+
     weather_filename = nil
     if @options[:run_xml] && @options[:run_xml][:weather_filename]
       if File.exist? @options[:run_xml][:weather_filename]
@@ -164,6 +174,7 @@ class RunOpenstudio
       if @analysis_json[:analysis][:weather_file][:path]
         weather_filename = File.expand_path(
             File.join(@options[:analysis_root_path], @analysis_json[:analysis][:weather_file][:path]))
+        @weather_file_path = File.dirname(weather_filename)
       else
         fail 'No weather file path defined'
       end
@@ -180,6 +191,20 @@ class RunOpenstudio
     weather_filename
   end
 
+  def get_weather_file_from_model
+    wf = nil
+    # grab the weather file out of the OSM if it exists
+    if @model.weatherFile.empty?
+      @logger.info 'No weather file in model'
+    else
+      # this is the weather file from the OSM model
+      wf = File.basename(@model.weatherFile.get.path.get.to_s)
+      @logger.info "Model weather file is #{wf}" # unless model.weatherFile.empty?
+    end
+
+    wf
+  end
+
   # Forward translate to energyplus
   def translate_to_energyplus
     if @model_idf.nil?
@@ -194,151 +219,4 @@ class RunOpenstudio
       @logger.info "Translate object to energyplus IDF took #{b.to_f - a.to_f}"
     end
   end
-
-  def apply_arguments(argument_map, argument)
-    success = true
-
-    if argument[:value]
-      @logger.info "Setting argument value #{argument[:name]} to #{argument[:value]}"
-
-      v = argument_map[argument[:name]]
-      fail 'Could not find argument map in measure' unless v
-      value_set = v.setValue(argument[:value])
-      fail "Could not set argument #{argument[:name]} of value #{argument[:value]} on model" unless value_set
-      argument_map[argument[:name]] = v.clone
-    else
-      fail "Value for argument '#{argument[:name]}' not set in argument list" if CRASH_ON_NO_WORKFLOW_VARIABLE
-      @logger.warn "Value for argument '#{argument[:name]}' not set in argument list therefore will use default"
-      #success = false
-
-      # TODO: what is the fail case (success = false?)
-    end
-
-    success
-  end
-
-  # Apply the variable values to the measure argument map object
-  def apply_variables(argument_map, variable)
-    success = true
-
-    # save the uuid of the variable
-    variable_uuid = variable[:uuid].to_sym
-    if variable[:argument]
-      variable_name = variable[: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]}"
-            v = argument_map[variable_name]
-            fail 'Could not find argument map in measure' unless v
-            variable_value = @datapoint_json[:data_point][:set_variable_values][variable_uuid]
-            value_set = v.setValue(variable_value)
-            fail "Could not set variable '#{variable_name}' of value #{variable_value} on model" unless value_set
-            argument_map[variable_name] = v.clone
-          else
-            fail "[ERROR] Value for variable '#{variable_name}:#{variable_uuid}' not set in datapoint object" if CRASH_ON_NO_WORKFLOW_VARIABLE
-            @logger.warn "Value for variable '#{variable_name}:#{variable_uuid}' not set in datapoint object"
-            # success = false
-          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
-    else
-      fail "Variable '#{variable_name}' is defined but no argument is present"
-    end
-
-    success
-  end
-
-  def apply_measure(workflow_item)
-    measure_path = workflow_item[:measure_definition_directory]
-    measure_name = workflow_item[:measure_definition_class_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
-    runner = OpenStudio::Ruleset::OSRunner.new
-    result = nil
-
-    arguments = measure.arguments(@model)
-
-    # Create argument map and initialize all the arguments
-    argument_map = OpenStudio::Ruleset::OSArgumentMap.new
-    arguments.each do |v|
-      argument_map[v.name] = v.clone
-    end
-
-    @logger.info "Iterating over arguments for workflow item '#{workflow_item[:name]}'"
-    if workflow_item[:arguments]
-      workflow_item[:arguments].each do |argument|
-        success = apply_arguments(argument_map, argument)
-        fail "could not set arguments" unless success
-      end
-    end
-
-    @logger.info "Iterating over variables for workflow item '#{workflow_item[:name]}'"
-    if workflow_item[:variables]
-      workflow_item[:variables].each do |variable|
-        success = apply_variables(argument_map, variable)
-        fail "could not set variables" unless success
-      end
-    end
-
-    begin
-      if workflow_item[:measure_type] == 'RubyMeasure'
-        @logger.info "Running runner for '#{workflow_item[:name]}'"
-        measure.run(@model, runner, argument_map)
-        @logger.info "Finished runner for '#{workflow_item[:name]}'"
-      elsif workflow_item[:measure_type] == 'EnergyPlusMeasure'
-        measure.run(@model_idf, runner, argument_map)
-      elsif workflow_item[:measure_type] == 'ReportingMeasure'
-        report_measures << measure
-      end
-    rescue Exception => e
-      log_message = "Runner error #{__FILE__} failed with #{e.message}, #{e.backtrace.join("\n")}"
-      fail log_message
-    end
-
-    begin
-      result = runner.result
-
-      @logger.info result.initialCondition.get.logMessage unless result.initialCondition.empty?
-      @logger.info result.finalCondition.get.logMessage unless result.finalCondition.empty?
-
-      result.warnings.each { |w| @logger.info w.logMessage }
-      result.errors.each { |w| @logger.info w.logMessage }
-      result.info.each { |w| @logger.info w.logMessage }
-    rescue Exception => e
-      log_message = "Runner error #{__FILE__} failed with #{e.message}, #{e.backtrace.join("\n")}"
-      fail log_message
-    end
-
-    begin
-      measure_attributes = JSON.parse(OpenStudio::toJSON(result.attributes), symbolize_names: true)
-      @output_attributes[workflow_item[:name].to_sym] = measure_attributes[:attributes]
-    rescue Exception => e
-      log_message = "TODO: #{__FILE__} failed with #{e.message}, #{e.backtrace.join("\n")}"
-      @logger.warn log_message
-    end
-  end
-
-  def apply_measures(measure_type)
-    if @analysis_json[:analysis][:problem] && @analysis_json[:analysis][:problem][:workflow]
-      @logger.info "Applying measures for #{@measure_type_lookup[measure_type]}"
-      @analysis_json[:analysis][:problem][:workflow].each do |wf|
-        next unless wf[:measure_type] == @measure_type_lookup[measure_type]
-
-        apply_measure(wf)
-      end
-    end
-  end
 end