openstudio-standards 0.8.3 → 0.8.5.rc1

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

@@ -0,0 +1,359 @@
+module BTAPMeasureHelper
+  ###################Helper functions
+
+  # define the arguments that the user will input
+  def arguments(model)
+    args = OpenStudio::Measure::OSArgumentVector.new
+
+    if true == @use_json_package
+      #Set up package version of input.
+      json_default = {}
+      @measure_interface_detailed.each do |argument|
+        json_default[argument['name']] = argument["default_value"]
+      end
+      default = JSON.pretty_generate(json_default)
+      arg = OpenStudio::Ruleset::OSArgument.makeStringArgument('json_input', true)
+      arg.setDisplayName('Contains a json version of the input as a single package.')
+      arg.setDefaultValue(default)
+      args << arg
+    else
+      # Conductances for all surfaces and subsurfaces.
+      @measure_interface_detailed.each do |argument|
+        arg = nil
+        statement = nil
+        case argument['type']
+          when "String"
+            arg = OpenStudio::Ruleset::OSArgument.makeStringArgument(argument['name'], argument['is_required'])
+            arg.setDisplayName(argument['display_name'])
+            arg.setDefaultValue(argument['default_value'].to_s)
+
+          when "Double"
+            arg = OpenStudio::Ruleset::OSArgument.makeDoubleArgument(argument['name'], argument['is_required'])
+            arg.setDisplayName("#{argument['display_name']}")
+            arg.setDefaultValue("#{argument['default_value']}".to_f)
+
+          when "Choice"
+            arg = OpenStudio::Measure::OSArgument.makeChoiceArgument(argument['name'], argument['choices'], argument['is_required'])
+            arg.setDisplayName(argument['display_name'])
+            arg.setDefaultValue(argument['default_value'].to_s)
+            puts arg.defaultValueAsString
+
+          when "Bool"
+            arg = OpenStudio::Measure::OSArgument.makeBoolArgument(argument['name'], argument['is_required'])
+            arg.setDisplayName(argument['display_name'])
+            arg.setDefaultValue(argument['default_value'])
+
+
+          when "StringDouble"
+            if @use_string_double == false
+              arg = OpenStudio::Ruleset::OSArgument.makeDoubleArgument(argument['name'], argument['is_required'])
+              arg.setDefaultValue(argument['default_value'].to_f)
+            else
+              arg = OpenStudio::Ruleset::OSArgument.makeStringArgument(argument['name'], argument['is_required'])
+              arg.setDefaultValue(argument['default_value'].to_s)
+            end
+            arg.setDisplayName(argument['display_name'])
+        end
+        args << arg
+      end
+    end
+    return args
+  end
+
+  #returns a hash of the user inputs for you to use in your measure.
+  def get_hash_of_arguments(user_arguments, runner)
+    values = {}
+    if @use_json_package
+      return JSON.parse(runner.getStringArgumentValue('json_input', user_arguments))
+    else
+
+      @measure_interface_detailed.each do |argument|
+
+        case argument['type']
+          when "String", "Choice"
+            values[argument['name']] = runner.getStringArgumentValue(argument['name'], user_arguments)
+          when "Double"
+            values[argument['name']] = runner.getDoubleArgumentValue(argument['name'], user_arguments)
+          when "Bool"
+            values[argument['name']] = runner.getBoolArgumentValue(argument['name'], user_arguments)
+          when "StringDouble"
+            value = nil
+            if @use_string_double == false
+              value = (runner.getDoubleArgumentValue(argument['name'], user_arguments).to_f)
+            else
+              value = runner.getStringArgumentValue(argument['name'], user_arguments)
+              if valid_float?(value)
+                value = value.to_f
+              end
+            end
+            values[argument['name']] = value
+        end
+      end
+    end
+    return values
+  end
+
+  # boilerplate that validated ranges of inputs.
+  def validate_and_get_arguments_in_hash(model, runner, user_arguments)
+    return_value = true
+    values = get_hash_of_arguments(user_arguments, runner)
+    # use the built-in error checking
+    if !runner.validateUserArguments(arguments(model), user_arguments)
+      runner_register(runner, 'Error', "validateUserArguments failed... Check the argument definition for errors.")
+      return_value = false
+    end
+
+    # Validate arguments
+    errors = ""
+    @measure_interface_detailed.each do |argument|
+      case argument['type']
+        when "Double"
+          value = values[argument['name']]
+          if (not argument["max_double_value"].nil? and value.to_f > argument["max_double_value"].to_f) or
+              (not argument["min_double_value"].nil? and value.to_f < argument["min_double_value"].to_f)
+            error = "#{argument['name']} must be between #{argument["min_double_value"]} and #{argument["max_double_value"]}. You entered #{value.to_f} for this #{argument['name']}.\n Please enter a value withing the expected range.\n"
+            errors << error
+          end
+        when "StringDouble"
+          value = values[argument['name']]
+          if (not argument["valid_strings"].include?(value)) and (not valid_float?(value))
+            error = "#{argument['name']} must be a string that can be converted to a float, or one of these #{argument["valid_strings"]}. You have entered #{value}\n"
+            errors << error
+          elsif (not argument["max_double_value"].nil? and value.to_f > argument["max_double_value"]) or
+              (not argument["min_double_value"].nil? and value.to_f < argument["min_double_value"])
+            error = "#{argument['name']} must be between #{argument["min_double_value"]} and #{argument["max_double_value"]}. You entered #{value} for #{argument['name']}. Please enter a stringdouble value in the expected range.\n"
+            errors << error
+          end
+      end
+    end
+    #If any errors return false, else return the hash of argument values for user to use in measure.
+    if errors != ""
+      runner.registerError(errors)
+      return false
+    end
+    return values
+  end
+
+  # Helper method to see if str is a valid float.
+  def valid_float?(str)
+    !!Float(str) rescue false
+  end
+
+end
+
+module BTAPMeasureTestHelper
+  ##### Helper methods Do notouch unless you know the consequences.
+
+  #Boiler plate to default values and number of arguments against what is in your test's setup method.
+  def test_arguments_and_defaults
+    [true, false].each do |json_input|
+      [true, false].each do |string_double|
+        @use_json_package = json_input
+        @use_string_double = string_double
+
+        # Create an instance of the measure
+        measure = get_measure_object()
+        measure.use_json_package = @use_json_package
+        measure.use_string_double = @use_string_double
+        model = OpenStudio::Model::Model.new
+
+        # Create an instance of a runner
+        runner = OpenStudio::Measure::OSRunner.new(OpenStudio::WorkflowJSON.new)
+
+        # Test arguments and defaults
+        arguments = measure.arguments(model)
+        #convert whatever the input was into a hash. Then test.
+
+        #check number of arguments.
+        if @use_json_package
+          assert_equal(@measure_interface_detailed.size, JSON.parse(arguments[0].defaultValueAsString).size, "The measure should have #{@measure_interface_detailed.size} but actually has #{arguments.size}. Here the the arguement expected #{@measure_interface_detailed} and this is the actual #{arguments}")
+        else
+          assert_equal(@measure_interface_detailed.size, arguments.size, "The measure should have #{@measure_interface_detailed.size} but actually has #{arguments.size}. Here the the arguement expected #{@measure_interface_detailed} and this is the actual #{arguments}")
+          (@measure_interface_detailed).each_with_index do |argument_expected, index|
+            assert_equal(argument_expected['name'], arguments[index].name, "Measure argument name of #{argument_expected['name']} was expected, but got #{arguments[index].name} instead.")
+            assert_equal(argument_expected['display_name'], arguments[index].displayName, "Display name for argument #{argument_expected['name']} was expected to be #{argument_expected['display_name']}, but got #{arguments[index].displayName} instead.")
+            case argument_type(arguments[index])
+              when "String", "Choice"
+                assert_equal(argument_expected['default_value'].to_s, arguments[index].defaultValueAsString, "The default value for argument #{argument_expected['name']} was #{argument_expected['default_value']}, but actual was #{arguments[index].defaultValueAsString}")
+              when "Double", "Integer"
+                assert_equal(argument_expected['default_value'].to_f, arguments[index].defaultValueAsDouble.to_f, "The default value for argument #{argument_expected['name']} was #{argument_expected['default_value']}, but actual was #{arguments[index].defaultValueAsString}")
+              when "Bool"
+                assert_equal(argument_expected['default_value'], arguments[index].defaultValueAsBool, "The default value for argument #{argument_expected['name']} was #{argument_expected['default_value']}, but actual was #{arguments[index].defaultValueAsString}")
+            end
+          end
+        end
+      end
+    end
+  end
+
+  # Test argument ranges.
+  def test_argument_ranges
+    [true, false].each do |json_input|
+      [true, false].each do |string_double|
+        @use_json_package = json_input
+        @use_string_double = string_double
+        (@measure_interface_detailed).each_with_index do |argument|
+          if argument['type'] == 'Double' or argument['type'] == 'StringDouble'
+            puts "testing range for #{argument['name']} "
+            #Check over max
+            if not argument['max_double_value'].nil?
+              puts "testing max limit"
+              model = OpenStudio::Model::Model.new
+              input_arguments = @good_input_arguments.clone
+              over_max_value = argument['max_double_value'].to_f + 1.0
+              over_max_value = over_max_value.to_s if argument['type'].downcase == "StringDouble".downcase
+              input_arguments[argument['name']] = over_max_value
+              puts "Testing argument #{argument['name']} max limit of #{argument['max_double_value']}"
+              input_arguments = {'json_input' => JSON.pretty_generate(input_arguments)} if @use_json_package
+              run_measure(input_arguments, model)
+              runner = run_measure(input_arguments, model)
+              assert(runner.result.value.valueName != 'Success', "Checks did not stop a lower than limit value of #{over_max_value} for #{argument['name']}")
+              puts "Success: Testing argument #{argument['name']} max limit of #{argument['max_double_value']}"
+            end
+            #Check over max
+            if not argument['min_double_value'].nil?
+              puts "testing min limit"
+              model = OpenStudio::Model::Model.new
+              input_arguments = @good_input_arguments.clone
+              over_min_value = argument['min_double_value'].to_f - 1.0
+              over_min_value = over_max_value.to_s if argument['type'].downcase == "StringDouble".downcase
+              input_arguments[argument['name']] = over_min_value
+              puts "Testing argument #{argument['name']} min limit of #{argument['min_double_value']}"
+              input_arguments = {'json_input' => JSON.pretty_generate(input_arguments)} if @use_json_package
+              runner = run_measure(input_arguments, model)
+              assert(runner.result.value.valueName != 'Success', "Checks did not stop a lower than limit value of #{over_min_value} for #{argument['name']}")
+              puts "Success:Testing argument #{argument['name']} min limit of #{argument['min_double_value']}"
+            end
+
+          end
+          if (argument['type'] == 'StringDouble') and (not argument["valid_strings"].nil?) and @use_string_double
+            model = OpenStudio::Model::Model.new
+            input_arguments = @good_input_arguments.clone
+            input_arguments[argument['name']] = SecureRandom.uuid.to_s
+            puts "Testing argument #{argument['name']} min limit of #{argument['min_double_value']}"
+            input_arguments = {'json_input' => JSON.pretty_generate(input_arguments)} if @use_json_package
+            runner = run_measure(input_arguments, model)
+            assert(runner.result.value.valueName != 'Success', "Checks did not stop a lower than limit value of #{over_min_value} for #{argument['name']}")
+          end
+        end
+      end
+    end
+  end
+
+  # helper method to create necb archetype as a starting point for testing.
+  def create_necb_protype_model(building_type, climate_zone, epw_file, template)
+
+    osm_directory = "#{Dir.pwd}/output/#{building_type}-#{template}-#{climate_zone}-#{epw_file}"
+    FileUtils.mkdir_p (osm_directory) unless Dir.exist?(osm_directory)
+    #Get Weather climate zone from lookup
+    weather = BTAP::Environment::WeatherFile.new(epw_file)
+    #create model
+    building_name = "#{template}_#{building_type}"
+
+    prototype_creator = Standard.build(template)
+    model = prototype_creator.model_create_prototype_model(
+        epw_file: epw_file,
+        sizing_run_dir: osm_directory,
+        debug: @debug,
+        template: template,
+        building_type: building_type)
+
+    #set weather file to epw_file passed to model.
+    weather.set_weather_file(model)
+    return model
+  end
+
+  # Custom way to run the measure in the test.
+  def run_measure(input_arguments, model)
+
+    # This will create a instance of the measure you wish to test. It does this based on the test class name.
+    measure = get_measure_object()
+    measure.use_json_package = @use_json_package
+    measure.use_string_double = @use_string_double
+    # Return false if can't
+    return false if false == measure
+    arguments = measure.arguments(model)
+    argument_map = OpenStudio::Measure.convertOSArgumentVectorToMap(arguments)
+    runner = OpenStudio::Measure::OSRunner.new(OpenStudio::WorkflowJSON.new)
+    #Check if
+
+    # Set the arguements in the argument map use json or real arguments.
+    if @use_json_package
+      argument = arguments[0].clone
+      assert(argument.setValue(input_arguments['json_input']), "Could not set value for 'json_input' to #{input_arguments['json_input']}")
+      argument_map['json_input'] = argument
+    else
+      input_arguments.each_with_index do |(key, value), index|
+        argument = arguments[index].clone
+        if argument_type(argument) == "Double"
+          #forces it to a double if it is a double.
+          assert(argument.setValue(value.to_f), "Could not set value for #{key} to #{value}")
+        else
+          assert(argument.setValue(value.to_s), "Could not set value for #{key} to #{value}")
+        end
+        argument_map[key] = argument
+      end
+    end
+    #run the measure
+    measure.run(model, runner, argument_map)
+    runner.result
+    return runner
+  end
+
+
+  #Fancy way of getting the measure object automatically.
+  def get_measure_object()
+    measure_class_name = self.class.name.to_s.match(/(BTAP.*)(\_Test)/i).captures[0]
+    measure = nil
+    eval "measure = #{measure_class_name}.new"
+    if measure.nil?
+      puts "Measure class #{measure_class_name} is invalid. Please ensure the test class name is of the form 'MeasureName_Test' "
+      return false
+    end
+    return measure
+  end
+
+  #Determines the OS argument type dynamically.
+  def argument_type(argument)
+    case argument.type.value
+      when 0
+        return "Bool"
+      when 1 #Double
+        return "Double"
+      when 2 #Quantity
+        return "Quantity"
+      when 3 #Integer
+        return "Integer"
+      when 4
+        return "String"
+      when 5 #Choice
+        return "Choice"
+      when 6 #Path
+        return "Path"
+      when 7 #Separator
+        return "Separator"
+      else
+        return "Blah"
+    end
+  end
+
+  # Valid float helper.
+  def valid_float?(str)
+    !!Float(str) rescue false
+  end
+
+  #Method does a deep copy of a model.
+  def copy_model(model)
+    copy_model = OpenStudio::Model::Model.new
+    # remove existing objects from model
+    handles = OpenStudio::UUIDVector.new
+    copy_model.objects.each do |obj|
+      handles << obj.handle
+    end
+    copy_model.removeObjects(handles)
+    # put contents of new_model into model_to_replace
+    copy_model.addObjects(model.toIdfFile.objects)
+    return copy_model
+  end
+
+end

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

@@ -0,0 +1,117 @@
+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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,136 @@
+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()