openstudio-standards 0.8.5 → 0.8.7

data/lib/openstudio-standards/btap/costing/btap_workflow.rb

@@ -1,117 +0,0 @@
-require_relative '../../../../lib/openstudio-standards.rb'
-
-class BTAPWorkflow
-  attr_accessor :workflow
-
-  def initialize(measures_folder: File.join(__dir__, '../../measures'))
-    @model = nil
-    @run_dir = nil
-    @sql_path = nil
-    @idf_name = 'in.idf'
-    @osm_name = 'in.osm'
-    @osw_name = 'out.osw'
-    @epw_path = 'in.epw'
-    @workflow = OpenStudio::WorkflowJSON.new
-    @workflow.addMeasurePath(measures_folder)
-    @run_cli_verbose = true
-    @os_measures = []
-    @ep_measures = []
-    @report_measures = []
-  end
-
-  def set_run_dir(run_dir: "#{Dir.pwd}/Run")
-    puts "set run folder to #{run_dir}"
-    @run_dir = run_dir
-    @sql_path = OpenStudio::Path.new("#{@run_dir}/run/eplusout.sql")
-    return self
-  end
-
-  def add_os_measure(measure)
-    @os_measures << measure
-  end
-
-  def add_ep_measure(measure)
-    @ep_measures << measure
-  end
-
-  def add_reporting_measure(measure)
-    @report_measures << measure
-    return self
-  end
-
-  def add_measures_to_workflow
-    unless @os_measures.empty?
-      measure_type = OpenStudio::MeasureType.new("ModelMeasure")
-      @workflow.setMeasureSteps(measure_type, @os_measures)
-    end
-    unless @ep_measures.empty?
-      measure_type = OpenStudio::MeasureType.new("EnergyPlusMeasure")
-      @workflow.setMeasureSteps(measure_type, @ep_measures)
-    end
-    unless @report_measures.empty?
-      measure_type = OpenStudio::MeasureType.new("ReportingMeasure")
-      @workflow.setMeasureSteps(measure_type, @report_measures)
-    end
-    @workflow
-    return self
-  end
-
-  def add_btap_create_necb_prototype_building_measure(building_type:, epw_file:, template:, primary_heating_fuel:)
-    os_measure_type = OpenStudio::MeasureType.new("ModelMeasure")
-    create_prototype_measure = OpenStudio::MeasureStep.new("btap_create_necb_prototype_building")
-    create_prototype_measure.setName("btap_create_necb_prototype_building")
-    create_prototype_measure.setArgument('building_type', building_type)
-    create_prototype_measure.setArgument('epw_file', epw_file)
-    create_prototype_measure.setArgument('template', template)
-    create_prototype_measure.setArgument('primary_heating_fuel', primary_heating_fuel)
-    @os_measures << create_prototype_measure
-  end
-
-
-  def add_btap_results_measure
-    reporting_measure_type = OpenStudio::MeasureType.new("ReportingMeasure")
-    btap_results = OpenStudio::MeasureStep.new("btap_results")
-    btap_results.setName("btap_results")
-    btap_results.setArgument('generate_hourly_report', 'false')
-    btap_results.setArgument('output_diet', false)
-    btap_results.setArgument('envelope_costing', true)
-    btap_results.setArgument('lighting_costing', true)
-    btap_results.setArgument('boilers_costing', true)
-    btap_results.setArgument('chillers_costing', true)
-    btap_results.setArgument('cooling_towers_costing', true)
-    btap_results.setArgument('shw_costing', true)
-    btap_results.setArgument('ventilation_costing', true)
-    btap_results.setArgument('zone_system_costing', true)
-    @report_measures << btap_results
-  end
-
-
-  def run_command(command:)
-    stdout_str, stderr_str, status = Open3.capture3({}, command)
-    if status.success?
-      puts "Command completed successfully"
-      puts "stdout: #{stdout_str}"
-      puts "stderr: #{stderr_str}"
-      return true
-    else
-      puts "Error running command: '#{command}'"
-      puts "stdout: #{stdout_str}"
-      puts "stderr: #{stderr_str}"
-      return false
-    end
-  end
-
-  def run_workflow(postprocess_only: nil, osw_path:)
-    #command to run workflow
-    os_ruby_cli = "bundle exec ruby #{File.join(File.dirname(OpenStudio.getOpenStudioCLI.to_s), '..', 'Ruby', 'openstudio_cli.rb')}"
-    extra_args = ' --postprocess_only ' if postprocess_only == true
-    cmd = "#{os_ruby_cli} run #{extra_args} --debug --workflow \"#{osw_path}\""
-    puts "running cli command: #{cmd}"
-    OpenStudio.logFree(OpenStudio::Info, 'openstudio.model.Model', "running cli command: #{cmd}")
-    self.run_command(command: cmd)
-    OpenStudio.logFree(OpenStudio::Info, 'openstudio.model.Model', 'Finished cli run.')
-    #Ensure items are written to disk.
-    sleep 3
-    return true
-  end
-end

data/lib/openstudio-standards/btap/costing/copy_test_results_files_to_expected_results.rb

@@ -1,11 +0,0 @@
-require 'fileutils'
-
-folder_path = "#{File.dirname(__FILE__)}/btap_results/tests/regression_files/"
-puts folder_path
-Dir.glob(folder_path + "/*test_result.cost.json").sort.each do |f|
-  new_file = f.gsub("test_result.cost.json","expected_result.cost.json")
-  FileUtils.cp(f,new_file )
-  FileUtils.rm(f, :force => true)
-  puts "created new #{new_file}"
-end
-

data/lib/openstudio-standards/btap/costing/cost_building_from_file.rb

@@ -1,136 +0,0 @@
-require 'fileutils'
-require 'json'
-require 'optparse'
-require_relative './btap_costing.rb'
-
-# This script is used to apply costs to a list of costing items produced by btap_costing.  Right now it can only be run
-# from the btap_results resources folder because it uses btap_costing.rb.  It can be used elsewhere probably but then
-# the require_relative statement has to be changed.  It takes in the following command line arguments:
-# -c (string, required) Location of the json containing the list of items to be costed and the original costing City and
-#    Province.
-# -d (string, optional) Location of a custom costing database containing the costing information for the items that
-#    need costing.  This is used only if you do not want to use the standard costing database.  It must have the same
-#    structure as the 'costs' hash in the default costing database
-# -t (string, optional) The city to use when finding localization factors (only if you do not want to use the city that
-#    used in the original run).
-# -p (string, optional) Same as -t only for Province.
-# -o (string, optional) The location and name of the output file containing the costs.  If a name and path are not
-#    provided then one called cost_list_output.json will be put in the same directory as this file.
-#
-# The output of this script is a json file containing the following cost summary:
-#     {
-#       envelope: (float) Building envelope costs (to 2 decimal places).
-#       lighting: (float) Ligting costs (to 2 decimal places).
-#       heating_and_cooling: (float) Heating and cooling costs (not related to ventilation) (to 2 decimal places).
-#       shw: (float) Service hot water costs (to 2 decimal places).
-#       ventilation: (float) Ventilation (including ventilation air heating and cooling) costs (to 2 decimal places).
-#       grand_total: (float) Total costs (to 2 decimal places).
-#     }
-class BTAPCostFromFile
-  def cost_file()
-    # Get the commond line arguments
-    args = {}
-    OptionParser.new do |opts|
-      opts.banner = "Usage: example.rb [options]"
-      opts.on("-c", "--costlist_location=NAME", "Costing List File Location") do |n|
-        args['cost_file'] = n
-      end
-
-      opts.on("-d", "--custom_costing=NAME", "Custom Costing Database Location") do |n|
-        args['custom_db_file'] = n
-      end
-
-      opts.on("-t", "--custom_city=NAME", "Custom Costing City") do |n|
-        args['custom_city'] = n
-      end
-
-      opts.on("-p", "--custom_province=NAME", "Custom Costing Province") do |n|
-        args['custom_province'] = n
-      end
-
-      opts.on("-o", "--output_name=NAME", "Output file name and location") do |n|
-        args['output_loc'] = n
-      end
-
-      opts.on("-h", "--help", "Prints this help") do
-        puts opts
-        exit
-      end
-    end.parse!
-
-    curr_folder = (File.dirname(__FILE__)).to_s + "/"
-
-    # Get the output file location from the arguments
-    outputLoc = args['output_loc']
-    if outputLoc.nil?
-      outputFile = "./cost_list_output.json"
-    elsif outputLoc[0] == "."
-      if outputLoc[1] == "."
-        outputFile = curr_folder + outputLoc
-      elsif outputLoc[1] == "/"
-        outputFile = curr_folder + outputLoc[2..-1]
-      else
-        outputFile = curr_folder + outputLoc[1..-1]
-      end
-    elsif outputLoc[0] == "/"
-      outputFile = outputLoc
-    else
-      outputFile = curr_folder + outputLoc
-    end
-
-    # Get the cost list location from the arguments
-    costListLoc = args['cost_file']
-    if costListLoc.nil?
-      raise("No cost list location specified.  Please enter the location and name of the costed item list after the -c")
-    elsif costListLoc[0] == "."
-      if costListLoc[1] == "."
-        cost_loc = curr_folder + costListLoc
-      elsif costListLoc[1] == "/"
-        cost_loc = curr_folder + costListLoc[2..-1]
-      else
-        cost_loc = curr_folder + costListLoc[1..-1]
-      end
-    elsif costListLoc[0] == "/"
-      cost_loc = costListLoc
-    else
-      cost_loc = curr_folder + costListLoc
-    end
-
-    # Get the custom costing database location from the arguments
-    custDB = args['custom_db_file']
-    if custDB.nil?
-      db_loc = nil
-    else
-      if custDB[0] == "."
-        if custDB[1] == "."
-          db_loc = curr_folder + custDB
-        elsif custDB[1] == "/"
-          db_loc = curr_folder + custDB[2..-1]
-        else
-          db_loc = curr_folder + custDB[1..-1]
-        end
-      elsif custDB[0] == "/"
-        db_loc = custDB
-      else
-        db_loc = curr_folder + custDB
-      end
-    end
-
-    # Set the custom costing city and province location if specified
-    args['custom_city'].nil? ? customCity = nil : customCity = args['custom_city'].to_s
-    args['custom_province'].nil? ? customProv = nil : customProv = args['custom_province'].to_s
-
-    # Get the costed items list
-    costList = JSON.parse(File.read(cost_loc))
-
-    # Create a BTAPCosting object and pass the btap_items list, and optional costing database, costing City and costing
-    # Province arguments.  Get the resulting costs and save them in a json (see the description of the -o inline
-    # arguments above for more information).
-    btapCosting = BTAPCosting.new()
-    costResults = btapCosting.cost_list_items(btap_items: costList, custom_costing: custDB, custCity: customCity, custProvince: customProv)
-
-    File.write(outputFile, JSON.pretty_generate(costResults))
-  end
-end
-# Create a 'BTAPCostFromFile' object and call the 'cost_file' method to run the above script.
-BTAPCostFromFile.new().cost_file()

data/lib/openstudio-standards/btap/costing/costing_database_wrapper.rb

@@ -1,173 +0,0 @@
-require 'singleton'
-require 'json'
-require 'csv'
-
-# Singleton class to centralize all database operations
-class CostingDatabase
-  include Singleton
-
-  def initialize
-    @cp = CommonPaths.instance # Stores paths
-    @db = Hash.new             # Stores the costing database
-
-    # Load the database from the individual CSV files
-    # Load costing data
-    @db['costs'] = []                # Costing data
-    @db['localization_factors'] = [] # Local costing factors
-    @db['raw'] = {}                  # Raw data
-    @db['db_errors'] = []
-
-    data_costs = CSV.read(@cp.costs_path)
-
-    1.upto data_costs.length - 1 do |i|
-      row = data_costs[i]
-      index = row.each
-      item = Hash.new
-      item["baseCosts"] = Hash.new
-      costs = item["baseCosts"]
-
-      item["id"]               = index.next
-      item["sheet"]            = index.next
-      item["source"]           = index.next
-      item["description"]      = index.next
-      item["city"]             = index.next
-      item["province_state"]   = index.next
-      costs["materialOpCost"]  = index.next.to_f
-      costs["laborOpCost"]     = index.next.to_f
-      costs["equipmentOpCost"] = index.next.to_f
-
-      @db["costs"] << item
-    end
-
-    # Load the localization factors
-    data_factors = CSV.read(@cp.costs_local_factors_path)
-
-    1.upto data_factors.length - 1 do |i|
-      row = data_factors[i]
-      index = row.each
-      item = Hash.new
-
-      item["province_state"] = index.next
-      item["city"]           = index.next
-      item["division"]       = index.next
-      item["code_prefix"]    = index.next
-      item["material"]       = index.next.to_f
-      item["installation"]   = index.next.to_f
-      item["total"]          = index.next.to_f
-
-      @db["localization_factors"] << item
-    end
-
-    # Load the raw data
-    raw_data_names = [
-      'locations',
-      'construction_sets',
-      'constructions_opaque',
-      'materials_opaque',
-      'constructions_glazing',
-      'materials_glazing',
-      'Constructions',
-      'ConstructionProperties',
-      'lighting_sets',
-      'lighting',
-      'materials_lighting',
-      'hvac_vent_ahu',
-      'materials_hvac'
-    ]
-
-    0.upto(raw_data_names.length - 1) do |i|
-      data_path = @cp.raw_paths[i]
-      unless File.exist?(data_path)
-        raise("Error: Could not find #{data_path}")
-      end
-      @db['raw'][raw_data_names[i]] = CSV.read(data_path, headers: true).map { |row| row.to_hash}
-    end
-  end
-
-  # Validate the construction sets and the AHU items.
-  def validate_database()
-    validate_constructions_sets()
-    validate_ahu_items_and_quantities()
-  end
-
-  def validate_constructions_sets()
-    construction_sets = @db['raw']['construction_sets']
-    failed = false
-    templates = ["NECB2011", "NECB2015", "NECB2017", "NECB2020", "BTAPPRE1980", "BTAP1980TO2010"]
-    bad_records = {}
-    bad_records[:invalid_space_type_names] = []
-    bad_records[:min_max_floor_range_errors] = []
-    #  CHECK if spacetype names are valid in costing database
-    valid_space_types = []
-    templates.each do |template|
-      valid_space_types += Standard.build(template.gsub(/\s+/, "")).get_all_spacetype_names.map { |spacetype| (template + '-' + spacetype[0].to_s + '-' + spacetype[1].to_s).strip }
-    end
-    # construction_sets
-
-    construction_sets.each do |row|
-      target_space_type = "#{row['template'].gsub(/\s+/, "") + '-' + row['building_type']}-#{row['space_type']}".strip
-      unless valid_space_types.include?(target_space_type.to_s)
-        bad_records[:invalid_space_type_names] << {template: row['template'].gsub(/\s+/, ""), space_type: target_space_type}
-      end
-    end
-
-
-    # Check if # of floors contains 1 to 999
-    #Get Unique spacetypes.
-    bad_evelope_story_ranges = []
-    space_types = construction_sets.map { |row| {template: row["template"], building_type: row["building_type"], space_type: row["space_type"]} }.uniq
-    space_types.each do |space_type|
-      range = Array.new
-      instances = construction_sets.select { |row| row['template'] == space_type[:template] && row['building_type'] == space_type[:building_type] && row['space_type'] == space_type[:space_type] }
-      instances.each do |instance|
-        min_val = instance['min_stories'].to_i
-        min_val = 0 if min_val == 1
-        max_val = instance['max_stories'].to_i
-        range << min_val
-        range << max_val
-        failed = true
-      end
-      range.sort!
-      incomplete_range = (range.first != 0 or range.last < 999)
-      possible_duplicate = (range.uniq.size != range.size)
-      if incomplete_range or possible_duplicate
-        space_type[:range] = range
-        space_type[:error] = {incomplete_range: incomplete_range, possible_duplicate: possible_duplicate}
-        bad_records[:min_max_floor_range_errors] << space_type
-      end
-    end
-    if bad_records[:min_max_floor_range_errors].size > 0 or bad_records[:invalid_space_type_names].size > 0
-      puts "Errors in ConstructionSets Costing Table."
-      puts JSON.pretty_generate(bad_records)
-      raise("costing spreadsheet validation failed")
-    end
-  end
-
-
-  # This method verifies that, for a given row the number of items listed in the 'id_layers' column is the same as the
-  # number of quantities listed in the 'Id_layers_quantity_multipliers' column in the 'hvac_vent_ahu' sheet in the
-  # costing spreadsheet.  If there is a difference in the number of items and number of quantities in a row then that
-  # row needs to be investigated and fixed.
-  def validate_ahu_items_and_quantities()
-    # Find out if there are a different number of items and number oof quantities in any row of the 'hvac_vent_ahu'
-    # sheet.
-    diff_id_quantities = @db['raw']['hvac_vent_ahu'].select{|data| data['id_layers'].to_s.split(',').size != data['Id_layers_quantity_multipliers'].to_s.split(',').size}
-    # If there is a difference (that is the diff_id_quantities has something in it) then raise an error.
-    unless diff_id_quantities.empty?
-      puts "Errors in the hvac_vent_ahu Costing Table.  The number of id_layers does not match the number of"
-      puts "Id_layers_quantity_multipliers for the following item(s):"
-      puts JSON.pretty_generate(diff_id_quantities)
-      raise("costing spreadsheet validation failed")
-    end
-  end
-
-  # Overload the element of operator for database accesses
-  def [](element)
-    @db[element]
-  end
-
-  # Overload the element assignment operator for inputting additional data
-  def []=(element, value)
-    @db[element] = value
-  end
-end