openstudio-standards 0.2.16 → 0.2.17.rc2

data/lib/openstudio-standards/utilities/array.rb

@@ -0,0 +1,11 @@
+# Taken from: https://github.com/rubyworks/facets/blob/master/lib/core/facets/array/mode.rb#L14
+class Array
+  # Get most common value from an array
+  # If there is a tie for most common, an array is returned of the tied values
+  def mode
+    max = 0
+    c = Hash.new 0
+    each { |x| cc = c[x] += 1; max = cc if cc > max }
+    c.select { |k, v| v == max }.map { |k, v| k }
+  end
+end

data/lib/openstudio-standards/utilities/logging.rb

@@ -36,6 +36,54 @@ def log_messages_to_runner(runner, debug = false)
   end
 end
 
+# A function that writes error message to log file and stop the execution.
+#
+# @param msg [String] error message
+# @param log_level [OpenStudio::LogLevel] log level, eg. OpenStudio::Info
+# @param log_path [String] the log file directory
+# @param debug [Boolean] debug mode
+def terminate_prm_write_log(msg, log_path, debug = false)
+  OpenStudio.logFree(OpenStudio::ERROR, 'prm.log', msg)
+  log_messages_to_file_prm("#{log_path}/prm.log", debug)
+  raise msg
+end
+
+# A function to export log messages specific to PRM to a log file.
+#
+# @param file_path [String] the file path to the log file
+# @param debug [Boolean] debug mode
+# @return message [Array] array of message strings
+def log_messages_to_file_prm(file_path, debug = false)
+  messages = []
+
+  File.open(file_path, 'w') do |file|
+    $OPENSTUDIO_LOG.logMessages.each do |msg|
+      # only apply to prm
+      if msg.logChannel.casecmp? 'prm.log'
+        # Report the message in the correct way
+        if msg.logLevel == OpenStudio::Info
+          s = "[#{msg.logChannel}] INFO  #{msg.logMessage}"
+          file.puts(s)
+          messages << s
+        elsif msg.logLevel == OpenStudio::Warn
+          s = "[#{msg.logChannel}] WARN  #{msg.logMessage}"
+          file.puts(s)
+          messages << s
+        elsif msg.logLevel == OpenStudio::Error
+          s = "[#{msg.logChannel}] ERROR #{msg.logMessage}"
+          file.puts(s)
+          messages << s
+        elsif msg.logLevel == OpenStudio::Debug && debug
+          s = "[#{msg.logChannel}] DEBUG #{msg.logMessage}"
+          file.puts(s)
+          messages << s
+        end
+      end
+    end
+  end
+  return messages
+end
+
 # Log the info, warning, and error messages to a file.
 #
 # runner @param [file_path] The path to the log file

data/lib/openstudio-standards/utilities/object_info.rb

@@ -0,0 +1,20 @@
+#
+# Get hash of object field names and values
+# @author: Xuechen (Jerry) Lei, PNNL
+# @param  obj [object]
+#
+# @return [Hash<String>] FieldName:Value
+#
+def getObjectHash(obj)
+  fields_array = obj.to_s.split(/\n/)
+  output_hash = { 'object type' => fields_array.shift.split(/,/)[0] }
+  right = nil
+  fields_array.each do |ori_field|
+    left, right = ori_field.split(/[,;]/)
+    left = left.strip
+    right.slice!('!-')
+    right = right.strip
+    output_hash[right] = left
+  end
+  return output_hash
+end

data/lib/openstudio-standards/utilities/schedule_translator.rb

@@ -0,0 +1,348 @@
+# *******************************************************************************
+# The following notice pertains to the function below named
+# convert_schedule_compact_to_schedule_ruleset
+# *******************************************************************************
+# OpenStudio(R), Copyright (c) 2008-2020, Alliance for Sustainable Energy, LLC.
+# All rights reserved.
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# (1) Redistributions of source code must retain the above copyright notice,
+# this list of conditions and the following disclaimer.
+#
+# (2) Redistributions in binary form must reproduce the above copyright notice,
+# this list of conditions and the following disclaimer in the documentation
+# and/or other materials provided with the distribution.
+#
+# (3) Neither the name of the copyright holder nor the names of any contributors
+# may be used to endorse or promote products derived from this software without
+# specific prior written permission from the respective party.
+#
+# (4) Other than as required in clauses (1) and (2), distributions in any form
+# of modifications or other derivative works may not use the "OpenStudio"
+# trademark, "OS", "os", or any other confusingly similar designation without
+# specific prior written permission from Alliance for Sustainable Energy, LLC.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) AND ANY CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S), ANY CONTRIBUTORS, THE
+# UNITED STATES GOVERNMENT, OR THE UNITED STATES DEPARTMENT OF ENERGY, NOR ANY OF
+# THEIR EMPLOYEES, BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+# OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+# STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+# OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+# *******************************************************************************
+
+ForStruct = Struct.new(:daytypes)
+UntilStruct = Struct.new(:timestamp)
+ThroughStruct = Struct.new(:startdate)
+
+class ScheduleTranslator
+  attr_accessor :os_schedule
+
+  def initialize(os_model, os_schedule, name_prefix = nil)
+    @os_schedule = os_schedule
+    @os = os_model
+    @sched_name = os_schedule.name.get.to_s
+    @sched_type = os_schedule.scheduleTypeLimits.get
+    @base_year = os_model.getYearDescription.assumedYear
+    @schedule = []
+    @name_prefix = name_prefix
+  end
+
+  # Convert from scheduleCompact to scheduleRuleset
+  # @Author Nicholas Long and Andrew Parker, NREL
+  # @Return ScheduleRuleset object
+  def convert_schedule_compact_to_schedule_ruleset
+    @sched_name = @os_schedule.getString(1).get
+    @sched_name = "#{@name_prefix} #{@sched_name}" unless @name_prefix.nil?
+    @sched_type = @os_schedule.scheduleTypeLimits.get # TODO: - will fail if no limits set in source schedule
+
+    # puts "Translating #{@sched_name}"
+
+    i_thru = -1
+    i_for = -1
+    i_until = -1
+    sUntil = ''
+
+    (3..@os_schedule.numFields - 1).each do |i|
+      val = @os_schedule.getString(i).get
+
+      # Trap for interpolated schedules
+      if val =~ /Interpolate/
+        puts "[WARNING] Schedule #{@sched_name} is interpolated.  It will not be translated to .osm"
+        return false
+      end
+
+      # add : if it doesn't already exist
+      val = val.gsub(/Through\s/, 'Through: ')
+      val = val.gsub(/For\s/, 'For: ')
+      val = val.gsub(/Until\s/, 'Until: ')
+
+      if val =~ /through:/i
+        i_thru += 1
+        i_for = -1
+        i_until = -1
+
+        str = val.split(':')[1].strip
+        if @schedule.empty?
+          @schedule << { start_date: '01/01', end_date: str, for: [] }
+        else
+          @schedule << { start_date: @schedule[@schedule.size - 1][:end_date], end_date: str, for: [] }
+        end
+
+        next
+      end
+
+      if val =~ /for[:\s]/i
+        i_for += 1
+        i_until = -1
+
+        arr = val.match(/for[:\s](.*)/i)[0].strip.downcase.split(' ')
+        @schedule[i_thru][:for] << { daytype: arr, until: [] }
+        next
+      end
+
+      if val =~ /until:/i
+        i_until += 1
+
+        str = val.split(':')[1..2].join(':').strip
+        sUntil = str
+
+        next
+      end
+
+      dVal = @os_schedule.getDouble(i).get
+      # puts "thru: #{i_thru} for: #{i_for} until #{i_until}"
+      @schedule[i_thru][:for][i_for][:until] << { timestamp: sUntil, value: dVal }
+    end
+
+    # DEBUG spit out the schedule for quick check\
+    #     puts @schedule.inspect
+    #     @schedule.each do |sch|
+    #      puts "#{sch[:start_date]} to #{sch[:end_date]}"
+    #      sch[:for].each do |fr|
+    #        puts fr[:daytype]
+    #        fr[:until].each do |ut|
+    #          puts "#{ut[:timestamp]} : #{ut[:value]}"
+    #        end
+    #      end
+    #     end
+
+    os_schedule_ruleset = OpenStudio::Model::ScheduleRuleset.new(@os)
+    os_schedule_ruleset.setName(@sched_name)
+    os_schedule_ruleset.setScheduleTypeLimits(@sched_type)
+
+    i_rule = 0
+    @schedule.each do |sch|
+      # create a simple hash to make sure that the schedule covers all days needed
+      # and that "allotherdays", can adequately be handled
+      coverage = { mon: false, tue: false, wed: false, thu: false, fri: false, sat: false,
+                   sun: false, sdd: false, wdd: false, hol: false }
+      sch[:for].each do |fr|
+        i_rule += 1
+        os_schedule_rule = OpenStudio::Model::ScheduleRule.new(os_schedule_ruleset)
+        os_schedule_rule.setName("#{@sched_name} Rule #{i_rule}")
+        os_schedule_rule.setApplyMonday(false)
+        os_schedule_rule.setApplyTuesday(false)
+        os_schedule_rule.setApplyWednesday(false)
+        os_schedule_rule.setApplyThursday(false)
+        os_schedule_rule.setApplyFriday(false)
+        os_schedule_rule.setApplySaturday(false)
+        os_schedule_rule.setApplySunday(false)
+
+        mody = sch[:start_date].split('/')
+        mo = mody[0].to_i
+        dy = mody[1].to_i
+        osdate_start = OpenStudio::Date.new(OpenStudio::MonthOfYear.new(mo.to_i), dy.to_i)
+        if mo != 1 && dy != 1
+          osdate_start += OpenStudio::Time.new(1)
+        end
+        os_schedule_rule.setStartDate(osdate_start)
+        mody = sch[:end_date].split('/')
+        mo = mody[0].to_i
+        dy = mody[1].to_i
+        osdate_end = OpenStudio::Date.new(OpenStudio::MonthOfYear.new(mo.to_i), dy.to_i)
+        os_schedule_rule.setEndDate(osdate_end)
+
+        # create os day model
+        # TODO break this out as a method
+        if fr[:daytype].include?('monday') || fr[:daytype].include?('alldays') || fr[:daytype].include?('weekdays')
+          os_schedule_rule.setApplyMonday(true)
+          coverage[:mon] = true
+        end
+        if fr[:daytype].include?('tuesday') || fr[:daytype].include?('alldays') || fr[:daytype].include?('weekdays')
+          os_schedule_rule.setApplyTuesday(true)
+          coverage[:tue] = true
+        end
+        if fr[:daytype].include?('wednesday') || fr[:daytype].include?('alldays') || fr[:daytype].include?('weekdays')
+          os_schedule_rule.setApplyWednesday(true)
+          coverage[:wed] = true
+        end
+        if fr[:daytype].include?('thursday') || fr[:daytype].include?('alldays') || fr[:daytype].include?('weekdays')
+          os_schedule_rule.setApplyThursday(true)
+          coverage[:thu] = true
+        end
+        if fr[:daytype].include?('friday') || fr[:daytype].include?('alldays') || fr[:daytype].include?('weekdays')
+          os_schedule_rule.setApplyFriday(true)
+          coverage[:fri] = true
+        end
+        if fr[:daytype].include?('saturday') || fr[:daytype].include?('alldays')
+          os_schedule_rule.setApplySaturday(true)
+          coverage[:sat] = true
+        end
+        if fr[:daytype].include?('sunday') || fr[:daytype].include?('alldays')
+          os_schedule_rule.setApplySunday(true)
+          coverage[:sun] = true
+        end
+        if fr[:daytype].include?('allotherdays')
+          # needs to be a unique rule set
+          if !coverage[:mon]
+            os_schedule_rule.setApplyMonday(true)
+            coverage[:mon] = true
+          end
+          if !coverage[:tue]
+            os_schedule_rule.setApplyTuesday(true)
+            coverage[:tue] = true
+          end
+          if !coverage[:wed]
+            os_schedule_rule.setApplyWednesday(true)
+            coverage[:wed] = true
+          end
+          if !coverage[:thu]
+            os_schedule_rule.setApplyThursday(true)
+            coverage[:thu] = true
+          end
+          if !coverage[:fri]
+            os_schedule_rule.setApplyFriday(true)
+            coverage[:fri] = true
+          end
+          if !coverage[:sat]
+            os_schedule_rule.setApplySaturday(true)
+            coverage[:sat] = true
+          end
+          if !coverage[:sun]
+            os_schedule_rule.setApplySunday(true)
+            coverage[:sun] = true
+          end
+        end
+
+        osday = os_schedule_rule.daySchedule
+        osday.setName("#{@sched_name} Rule #{i_rule} Day Sch")
+        # osday.setString(1, @sched_type)
+        fr[:until].each do |ut|
+          hr = ut[:timestamp].split(':')[0].to_i
+          mn = ut[:timestamp].split(':')[1].to_i
+
+          ostime = OpenStudio::Time.new(0, hr, mn, 0)
+          osday.addValue(ostime, ut[:value])
+        end
+
+        # set the winter and summer design days
+        if fr[:daytype].include?('winterdesignday') ||
+           (fr[:daytype].include?('allotherdays') && !coverage[:wdd])
+
+          # this actually clones osday
+          os_schedule_ruleset.setWinterDesignDaySchedule(osday)
+
+          coverage[:wdd] = true
+        end
+        if fr[:daytype].include?('summerdesignday') ||
+           (fr[:daytype].include?('allotherdays') && !coverage[:sdd])
+
+          # this actually clones osday
+          os_schedule_ruleset.setSummerDesignDaySchedule(osday)
+
+          coverage[:sdd] = true
+        end
+
+        # now check if for some reason that we have alldays for section
+        # but the date/time stamp is not in the winter/summer
+        if !coverage[:wdd]
+          osdate_wdd = OpenStudio::Date.new(OpenStudio::MonthOfYear.new(1), 15)
+          if fr[:daytype].include?('alldays') && (osdate_start < osdate_wdd) && (osdate_end > osdate_wdd)
+            os_schedule_ruleset.setWinterDesignDaySchedule(osday)
+            coverage[:wdd] = true
+            # puts "[INFO] **** Setting DesignDay based on date, not by actual schedule ****"
+          end
+        end
+        if !coverage[:sdd]
+          osdate_wdd = OpenStudio::Date.new(OpenStudio::MonthOfYear.new(7), 15)
+          if fr[:daytype].include?('alldays') && (osdate_start < osdate_wdd) && (osdate_end > osdate_wdd)
+            os_schedule_ruleset.setSummerDesignDaySchedule(osday)
+            coverage[:sdd] = true
+            # puts "[INFO] **** Setting DesignDay based on date, not by actual schedule ****"
+          end
+        end
+      end
+    end
+
+    # Clean up tasks on the naming after all the schedule rule and days are
+    # configured
+    ostemp = os_schedule_ruleset.winterDesignDaySchedule
+    ostemp.setName("#{@sched_name} Winter Design Day")
+    # ostemp.setString(1, @sched_type)
+
+    ostemp = os_schedule_ruleset.summerDesignDaySchedule
+    ostemp.setName("#{@sched_name} Summer Design Day")
+    # ostemp.setString(1, @sched_type)
+
+    ostemp = os_schedule_ruleset.defaultDaySchedule
+    ostemp.setName("#{@sched_name} Default Schedule")
+    # ostemp.setString(1, @sched_type)
+
+    # Remove rules that don't apply to any days
+    os_schedule_ruleset.scheduleRules.each do |sr|
+      if !sr.applySunday && !sr.applyMonday && !sr.applyTuesday &&
+         !sr.applyWednesday && !sr.applyThursday && !sr.applyFriday &&
+         !sr.applySaturday
+        sr.daySchedule.remove
+        sr.remove
+      end
+    end
+
+    sched_i = 0
+    os_schedule_ruleset.scheduleRules.each do |sr|
+      sched_i += 1
+      sr.setName("#{@sched_name} Rule #{sched_i}")
+      sr.daySchedule.setName("#{@sched_name} Rule #{sched_i} Day Schedule")
+    end
+
+    # If the default profile is never used throughout the year,
+    # make the most commonly used rule the default instead.
+
+    # Get an array that shows which rule is used on each day in the date range.
+    # A value of -1 means that the default profile is used on that day,
+    # so if -1 never appears in the list, it isn't used.
+    year = @base_year
+    year_start_date = OpenStudio::Date.new(OpenStudio::MonthOfYear.new('January'), 1, year)
+    year_end_date = OpenStudio::Date.new(OpenStudio::MonthOfYear.new('December'), 31, year)
+    rules_used_each_day = os_schedule_ruleset.getActiveRuleIndices(year_start_date, year_end_date)
+    rules_freq = rules_used_each_day.group_by { |n| n }
+    most_freq_rule_index = rules_freq.values.max_by(&:size).first
+    if !rules_used_each_day.include?(-1)
+      OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.schedule_translator', "#{os_schedule_ruleset.name} does not use the default profile, it will be replaced.")
+
+      # Get times/values from the most commonly used rule then remove that rule.
+      rule_vector = os_schedule_ruleset.scheduleRules
+      new_default_day_sch = rule_vector[most_freq_rule_index].daySchedule
+      new_default_day_sch_values = new_default_day_sch.values
+      new_default_day_sch_times = new_default_day_sch.times
+      rule_vector[most_freq_rule_index].remove
+
+      # Reset values in default profile
+      default_day_sch = os_schedule_ruleset.defaultDaySchedule
+      default_day_sch.clearValues
+
+      # Update values and times for default profile
+      for i in 0..(new_default_day_sch_values.size - 1)
+        default_day_sch.addValue(new_default_day_sch_times[i], new_default_day_sch_values[i])
+      end
+    end
+
+    return os_schedule_ruleset
+  end
+end

data/lib/openstudio-standards/utilities/sqlfile.rb

@@ -16,6 +16,34 @@ Standard.class_eval do
     return model.sqlFile.get
   end
 
+  # Write out a SQL query to retrieve simulation outputs
+  # from the TabularDataWithStrings table in the SQL
+  # database produced by OpenStudio/EnergyPlus after
+  # running a simulation.
+  #
+  # @param model [OpenStudio::Model::Model] OpenStudio model object
+  # @param report_name [String] Name of the report as defined in the HTM simulation output file
+  # @param table_name [String] Name of the table as defined in the HTM simulation output file
+  # @param row_name [String] Name of the row as defined in the HTM simulation output file
+  # @param column_name [String] Name of the column as defined in the HTM simulation output file
+  # @param units [String] Unit of the value to be retrieved
+  #
+  # @return [String] Result of the query
+  def run_query_tabulardatawithstrings(model, report_name, table_name, row_name, column_name, units = '*')
+    # Define the query
+    query = "Select Value FROM TabularDataWithStrings WHERE
+    ReportName = '#{report_name}' AND
+    TableName = '#{table_name}' AND
+    RowName = '#{row_name}' AND
+    ColumnName = '#{column_name}' AND
+    Units = '#{units}'"
+    # Run the query if the expected output is a string
+    return model.sqlFile.get.execAndReturnFirstString(query).get if units.empty?
+
+    # Run the query if the expected output is a double
+    return model.sqlFile.get.execAndReturnFirstDouble(query).get
+  end
+
   # Get the weather run period for the model
   #
   # @param model [OpenStudio::Model::Model] OpenStudio model object
@@ -384,6 +412,46 @@ Standard.class_eval do
     return heating_or_cooling_setpoint_unmet
   end
 
+   # Get the total unmet load hours during occupancy of a model that has been simulated
+  #
+  # @param model [OpenStudio::Model::Model] OpenStudio model object
+  # @return [Float] returns the number of total unmet load hours during occupancy in a simulated model
+  def model_get_unmet_load_hours(model)
+    result = OpenStudio::OptionalDouble.new
+    sql = model.sqlFile
+    if sql.is_initialized
+      sql = sql.get
+      query = "SELECT Value
+              FROM tabulardatawithstrings
+              WHERE ReportName='AnnualBuildingUtilityPerformanceSummary'
+              AND ReportForString='Entire Facility'
+              AND TableName='Comfort and Setpoint Not Met Summary'
+              AND ColumnName='Facility'
+              AND RowName='Time Setpoint Not Met During Occupied Heating'
+              AND Units='Hours'"
+      val = sql.execAndReturnFirstDouble(query)
+      if val.is_initialized
+        result = OpenStudio::OptionalDouble.new(val.get).to_f
+      end
+      query = "SELECT Value
+              FROM tabulardatawithstrings
+              WHERE ReportName='AnnualBuildingUtilityPerformanceSummary'
+              AND ReportForString='Entire Facility'
+              AND TableName='Comfort and Setpoint Not Met Summary'
+              AND ColumnName='Facility'
+              AND RowName='Time Setpoint Not Met During Occupied Cooling'
+              AND Units='Hours'"
+      val = sql.execAndReturnFirstDouble(query)
+      if val.is_initialized
+        result += OpenStudio::OptionalDouble.new(val.get).to_f
+      end
+    else
+      OpenStudio.logFree(OpenStudio::Error, 'openstudio.model.Model', 'Model has no sql file containing results, cannot lookup data.')
+    end
+
+    return result
+  end
+ 
   # Gets the model annual energy consumption by fuel and enduse in GJ from the sql file
   #
   # @param model [OpenStudio::Model::Model] OpenStudio model object

data/lib/openstudio-standards/version.rb

@@ -13,5 +13,5 @@ module OpenstudioStandards
     end
     return 'git-not-found-on-this-system'
   end
-  VERSION = '0.2.16'.freeze
-end
+  VERSION = '0.2.17.rc2'.freeze
+end

data/lib/openstudio-standards/weather/Weather.Model.rb

@@ -81,13 +81,49 @@ class Standard
     return climate_zone_weather_file_map
   end
 
+  # Get absolute path of a weather file included within openstudio-standards
+  #
+  # @param weather_file_name [String] Name of a weather file include within openstudio-standards
+  # @return [String] Weather file path
+  def model_get_weather_file(weather_file_name)
+    # Define where the weather files lives
+    weather_dir = nil
+    if __dir__[0] == ':' # Running from OpenStudio CLI
+      # load weather file from embedded files
+      epw_string = load_resource_relative("../../../data/weather/#{weather_file_name}")
+      ddy_string = load_resource_relative("../../../data/weather/#{weather_file_name.gsub('.epw', '.ddy')}")
+      stat_string = load_resource_relative("../../../data/weather/#{weather_file_name.gsub('.epw', '.stat')}")
+
+      # extract to local weather dir
+      weather_dir = File.expand_path(File.join(Dir.pwd, 'extracted_files/weather/'))
+      OpenStudio.logFree(OpenStudio::Info, 'openstudio.weather.Model', "Extracting weather files from OpenStudio CLI to #{weather_dir}")
+      FileUtils.mkdir_p(weather_dir)
+      File.open("#{weather_dir}/#{weather_file_name}", 'wb') { |f| f << epw_string; f.flush }
+      File.open("#{weather_dir}/#{weather_file_name.gsub('.epw', '.ddy')}", 'wb') { |f| f << ddy_string; f.flush }
+      File.open("#{weather_dir}/#{weather_file_name.gsub('.epw', '.stat')}", 'wb') { |f| f << stat_string; f.flush }
+    else
+      # loaded gem from system path
+      top_dir = File.expand_path('../../..', File.dirname(__FILE__))
+      weather_dir = File.expand_path("#{top_dir}/data/weather")
+    end
+
+    # Add Weather File
+    unless (Pathname.new weather_dir).absolute?
+      weather_dir = File.expand_path(File.join(File.dirname(__FILE__), weather_dir))
+    end
+
+    weather_file = File.join(weather_dir, weather_file_name)
+
+    return weather_file
+  end
+
   # Adds the design days and weather file for the specified climate zone
   #
   # @param model [OpenStudio::Model::Model] OpenStudio model object
   # @param climate_zone [String] ASHRAE climate zone, e.g. 'ASHRAE 169-2013-4A'
   # @param epw_file [String] the name of the epw file; if blank will default to epw file for the ASHRAE climate zone
   # @return [Bool] returns true if successful, false if not
-  def model_add_design_days_and_weather_file(model, climate_zone, epw_file = '')
+  def model_add_design_days_and_weather_file(model, climate_zone, epw_file = '', weather_dir = nil)
     success = true
     require_relative 'Weather.stat_file'
 
@@ -110,33 +146,8 @@ class Standard
       success = false
     end
 
-    # Define where the weather files lives
-    weather_dir = nil
-    if __dir__[0] == ':' # Running from OpenStudio CLI
-      # load weather file from embedded files
-      epw_string = load_resource_relative("../../../data/weather/#{weather_file_name}")
-      ddy_string = load_resource_relative("../../../data/weather/#{weather_file_name.gsub('.epw', '.ddy')}")
-      stat_string = load_resource_relative("../../../data/weather/#{weather_file_name.gsub('.epw', '.stat')}")
-
-      # extract to local weather dir
-      weather_dir = File.expand_path(File.join(Dir.pwd, 'extracted_files/weather/'))
-      OpenStudio.logFree(OpenStudio::Info, 'openstudio.weather.Model', "Extracting weather files from OpenStudio CLI to #{weather_dir}")
-      FileUtils.mkdir_p(weather_dir)
-      File.open("#{weather_dir}/#{weather_file_name}", 'wb') { |f| f << epw_string; f.flush }
-      File.open("#{weather_dir}/#{weather_file_name.gsub('.epw', '.ddy')}", 'wb') { |f| f << ddy_string; f.flush }
-      File.open("#{weather_dir}/#{weather_file_name.gsub('.epw', '.stat')}", 'wb') { |f| f << stat_string; f.flush }
-    else
-      # loaded gem from system path
-      top_dir = File.expand_path('../../..', File.dirname(__FILE__))
-      weather_dir = File.expand_path("#{top_dir}/data/weather")
-    end
-
-    # Add Weather File
-    unless (Pathname.new weather_dir).absolute?
-      weather_dir = File.expand_path(File.join(File.dirname(__FILE__), weather_dir))
-    end
+    weather_file = model_get_weather_file(weather_file_name)
 
-    weather_file = File.join(weather_dir, weather_file_name)
     epw_file = OpenStudio::EpwFile.new(weather_file)
     OpenStudio::Model::WeatherFile.setWeatherFile(model, epw_file).get
 
@@ -212,30 +223,8 @@ class Standard
       OpenStudio.logFree(OpenStudio::Warn, 'openstudio.weather.Model', "Could not determine the weather file for climate zone: #{climate_zone}, cannot get ground temperatures from stat file.")
     end
 
-    # Define where the weather files lives
-    weather_dir = nil
-    if __dir__[0] == ':' # Running from OpenStudio CLI
-      # load stat file from embedded files
-      stat_string = load_resource_relative("../../../data/weather/#{weather_file_name.gsub('.epw', '.stat')}")
-
-      # extract to local weather dir
-      weather_dir = File.expand_path(File.join(Dir.pwd, 'extracted_files/weather/'))
-      OpenStudio.logFree(OpenStudio::Info, 'openstudio.weather.Model', "Extracting stat file from OpenStudio CLI to #{weather_dir}")
-      FileUtils.mkdir_p(weather_dir)
-      File.open("#{weather_dir}/#{weather_file_name.gsub('.epw', '.stat')}", 'wb') { |f| f << stat_string; f.flush }
-    else
-      # loaded gem from system path
-      top_dir = File.expand_path('../../..', File.dirname(__FILE__))
-      weather_dir = File.expand_path("#{top_dir}/data/weather")
-    end
-
-    # Expand the weather directory path
-    unless (Pathname.new weather_dir).absolute?
-      weather_dir = File.expand_path(File.join(File.dirname(__FILE__), weather_dir))
-    end
-
     # Get the path to the stat file
-    weather_file = File.join(weather_dir, weather_file_name)
+    weather_file = model_get_weather_file(weather_file_name)
 
     # Add ground temperatures via parsing of STAT file.
     ground_temperatures = []
@@ -347,7 +336,6 @@ end
 module BTAP
   module Environment
     require_relative 'Weather.stat_file'
-    # rubocop:enable Style/MutableConstant
 
     # this method is used to populate user interfaces if needed from the hash above.
     def self.get_canadian_weather_file_names
@@ -922,7 +910,7 @@ module BTAP
           end
         end
         return heating_design_day_number, cooling_design_day_number
-      end #def get_heating_design_day_number
+      end # def get_heating_design_day_number
 
       # This method calculates dehumidification degree days (DDD)
       # @author sara.gilani@canada.ca
@@ -960,7 +948,7 @@ module BTAP
                                                                     c5 * (line[DRY_BULB_TEMPERATURE].to_f + convert_c_to_k)**3 +
                                                                     c6 * (line[DRY_BULB_TEMPERATURE].to_f + convert_c_to_k)**4 +
                                                                     c7 * Math.log((line[DRY_BULB_TEMPERATURE].to_f + convert_c_to_k), Math.exp(1)) # 2.718281828459
-              line[CALCULATED_SATURATION_PRESSURE_OF_WATER_VAPOR] = (Math.exp(1))**(line[CALCULATED_SATURATION_PRESSURE_OF_WATER_VAPOR].to_f)
+              line[CALCULATED_SATURATION_PRESSURE_OF_WATER_VAPOR] = Math.exp(1)**line[CALCULATED_SATURATION_PRESSURE_OF_WATER_VAPOR].to_f
             else # if line[DRY_BULB_TEMPERATURE].to_f > 0.0
               line[CALCULATED_SATURATION_PRESSURE_OF_WATER_VAPOR] = c8 / (line[DRY_BULB_TEMPERATURE].to_f + convert_c_to_k) +
                                                                     c9 +
@@ -968,7 +956,7 @@ module BTAP
                                                                     c11 * (line[DRY_BULB_TEMPERATURE].to_f + convert_c_to_k)**2 +
                                                                     c12 * (line[DRY_BULB_TEMPERATURE].to_f + convert_c_to_k)**3 +
                                                                     c13 * Math.log((line[DRY_BULB_TEMPERATURE].to_f + convert_c_to_k), Math.exp(1))
-              line[CALCULATED_SATURATION_PRESSURE_OF_WATER_VAPOR] = (Math.exp(1))**(line[CALCULATED_SATURATION_PRESSURE_OF_WATER_VAPOR].to_f)
+              line[CALCULATED_SATURATION_PRESSURE_OF_WATER_VAPOR] = Math.exp(1)**line[CALCULATED_SATURATION_PRESSURE_OF_WATER_VAPOR].to_f
             end
 
             # Step 2: calculate pw (PARTIAL_PRESSURE_OF_WATER_VAPOR), [Pascal]
@@ -1003,7 +991,6 @@ module BTAP
         # puts @filearray
         return ddd
       end # def calculate_humidity_ratio
-
     end # Environment
   end
 end