openstudio-standards 0.8.5 → 0.8.7

data/lib/openstudio-standards/btap/utilities/convert_surfaces_to_adiabatic_necb_8426.rb

@@ -1,204 +0,0 @@
-require_relative 'minitest_helper'
-require_relative 'create_doe_prototype_helper'
-require 'json'
-
-$LOAD_PATH.unshift File.expand_path('../../../openstudio-standards/lib', __dir__)
-def run_dir(test_name)
-  # always generate test output in specially named 'output' directory so result files are not made part of the measure
-  "#{File.dirname(__FILE__)}/output/#{test_name}"
-end
-
-def model_out_path(test_name)
-  "#{run_dir(test_name)}/ExampleModel.osm"
-end
-
-def workspace_path(test_name)
-  "#{run_dir(test_name)}/ModelToIdf/in.idf"
-end
-
-def sql_path(test_name)
-  "#{run_dir(test_name)}/ModelToIdf/EnergyPlusPreProcess-0/EnergyPlus-0/eplusout.sql"
-end
-
-def report_path(test_name)
-  "#{run_dir(test_name)}/report.html"
-end
-
-def calculate_max_delta_t(adj_DaySchedule, cur_DaySchedule)
-  max = -999
-  #  #if either one of schedule does not exist then it will return the max of the existing schedule
-  #  if adj_DaySchedule.nil?
-  #    0.upto(23) do |hour|
-  #      time = OpenStudio::Time.new(0,hour,0,0)
-  #      max = cur_DaySchedule.getValue(time) if cur_DaySchedule.getValue(time) > max
-  #    end
-  #  elsif cur_DaySchedule.nil?
-  #    0.upto(23) do |hour|
-  #      time = OpenStudio::Time.new(0,hour,0,0)
-  #      max = adj_DaySchedule.getValue(time) if adj_DaySchedule.getValue(time) > max
-  #    end
-  #  elsif (cur_DaySchedule.nil? and cur_DaySchedule.nil?)
-  #    return nil
-  #  end
-  if cur_DaySchedule.nil? || adj_DaySchedule.nil?
-    raise 'cur_DaySchedule or adj_DaySchedule is nil'
-    return nil
-  end
-
-  0.upto(23) do |hour|
-    time = OpenStudio::Time.new(0, hour, 0, 0)
-    difference = (cur_DaySchedule.getValue(time) - adj_DaySchedule.getValue(time)).abs
-    max = difference if difference > max
-  end
-  return max
-end
-
-# returns -999 if current surface does not have heating OR cooling schedule
-# returns -997 if all adjacent surfaces does not have BOTH heating AND cooling
-# returns nil if the surface does not have adjacent surface
-def get_schedule_max_delta_t(model, surface)
-  # find spaces that share that surface.
-  # load the schedules for every day type of the year. for both spaces. If the space is does not have a heating schedule..assume the temperature is the -10C always for now.
-  # iterate through every hour. and determine delta T
-  # Store the max delta T.
-  # end iteration
-  # return max deltaT
-  cur_space = nil
-  delta_t = -998
-  adjacent_surface_found = false
-  atleast_one_adjacent_surface_has_schedule = false
-  model.getSpaces.each do |space|
-    if space == surface.space.get
-      cur_space = space
-    end
-  end
-  if cur_space.nil?
-    raise "Surface: [#{surface.name}] does not belong to any space"
-  end
-
-  model.getSpaces.each do |space|
-    if space == surface.space.get
-      next
-    end
-
-    space.surfaces.each do |surf|
-      unless surf.adjacentSurface.empty?
-        adj_surface = surf.adjacentSurface.get
-        if adj_surface == surface
-          adjacent_surface_found = true
-          unless space.thermalZone.empty?
-            adj_surface_thermal_zone = space.thermalZone.get
-            cur_surface_thermal_zone = cur_space.thermalZone.get
-            unless adj_surface_thermal_zone.thermostatSetpointDualSetpoint.empty?
-              adj_thermostat = adj_surface_thermal_zone.thermostatSetpointDualSetpoint.get
-              cur_thermostat = cur_surface_thermal_zone.thermostatSetpointDualSetpoint.get
-              # if current surface does not have a thermostat schedule, then it will return -999 instead of nil because nil is reserved for surfaces without adjacent surface
-              if cur_thermostat.getHeatingSchedule.empty? || cur_thermostat.getCoolingSchedule.empty?
-                return -999
-              end
-              # after this point current surface should have BOTH heating and cooling schedule
-              # if adjacent surface does not have a heating OR cooling schedule it will be skipped
-              if adj_thermostat.getHeatingSchedule.empty? || adj_thermostat.getCoolingSchedule.empty?
-                next
-              else
-                atleast_one_adjacent_surface_has_schedule = true
-              end
-
-              startDate = OpenStudio::Date.new(OpenStudio::MonthOfYear.new(1), 1, 2009)
-              endDate = OpenStudio::Date.new(OpenStudio::MonthOfYear.new(1), 7, 2009)
-
-              adj_surface_heating_day_schedule_array = adj_thermostat.getHeatingSchedule.get.to_ScheduleRuleset.get.getDaySchedules(startDate, endDate) unless adj_thermostat.getHeatingSchedule.empty?
-              adj_surface_cooling_day_schedule_array = adj_thermostat.getCoolingSchedule.get.to_ScheduleRuleset.get.getDaySchedules(startDate, endDate) unless adj_thermostat.getCoolingSchedule.empty?
-              cur_surface_heating_day_schedule_array = cur_thermostat.getHeatingSchedule.get.to_ScheduleRuleset.get.getDaySchedules(startDate, endDate) unless cur_thermostat.getHeatingSchedule.empty?
-              cur_surface_cooling_day_schedule_array = cur_thermostat.getCoolingSchedule.get.to_ScheduleRuleset.get.getDaySchedules(startDate, endDate) unless cur_thermostat.getCoolingSchedule.empty?
-              delta_t = -998
-              heating_delta_t = []
-              cooling_delta_t = []
-              1.upto(7) do |i|
-                puts 'mee mee mee'
-                puts calculate_max_delta_t(adj_surface_heating_day_schedule_array[i - 1], cur_surface_heating_day_schedule_array[i - 1])
-                heating_delta_t << calculate_max_delta_t(adj_surface_heating_day_schedule_array[i - 1], cur_surface_heating_day_schedule_array[i - 1])
-                cooling_delta_t << calculate_max_delta_t(adj_surface_cooling_day_schedule_array[i - 1], cur_surface_cooling_day_schedule_array[i - 1])
-              end
-              delta_t = [heating_delta_t.max, cooling_delta_t.max].max
-              puts "delta_t: #{delta_t}"
-            end
-          end
-        end
-      end
-    end
-  end
-  # adjacent_surface_found ? (atleast_one_adjacent_surface_has_schedule ? (return delta_t) : (return -997)) : (return nil)
-  if adjacent_surface_found
-    if atleast_one_adjacent_surface_has_schedule
-      return delta_t
-    else
-      return -997
-    end
-  else
-    return nil
-  end
-end
-# LargeOffice
-class TestNECBSurfaces8426Custom < CreateDOEPrototypeBuildingTest
-  building_types = [
-    'LargeOffice',
-    'LargeHotel',
-    'FullServiceRestaurant',
-    'Outpatient',
-    'PrimarySchool'
-  ]
-
-  templates = ['NECB 2011']
-  climate_zones = ['NECB HDD Method']
-  epw_files = [
-    #  'CAN_BC_Vancouver.718920_CWEC.epw',#  CZ 5 - Gas HDD = 3019
-    #  'CAN_ON_Toronto.716240_CWEC.epw', #CZ 6 - Gas HDD = 4088
-    #  'CAN_PQ_Sherbrooke.716100_CWEC.epw', #CZ 7a - Electric HDD = 5068
-    #  'CAN_YT_Whitehorse.719640_CWEC.epw', #CZ 7b - FuelOil1 HDD = 6946
-    #  'CAN_NU_Resolute.719240_CWEC.epw', # CZ 8  -FuelOil2 HDD = 12570
-    #  'CAN_BC_Prince.George.718960_CWEC.epw',
-    'CAN_QC_Montreal.Intl.AP.716270_CWEC2020.epw'
-  ]
-  building_types.each do |building|
-    epw_files.each do |weather|
-      hash = {}
-      test_name = "#{building}_#{weather}"
-      unless File.exist?(run_dir(test_name))
-        FileUtils.mkdir_p(run_dir(test_name))
-      end
-      # assert(File.exist?(run_dir(test_name)))
-
-      if File.exist?(report_path(test_name))
-        FileUtils.rm(report_path(test_name))
-      end
-
-      # assert(File.exist?(model_in_path))
-
-      if File.exist?(model_out_path(test_name))
-        FileUtils.rm(model_out_path(test_name))
-      end
-      output_folder = "#{File.dirname(__FILE__)}/output/#{test_name}"
-      model = OpenStudio::Model::Model.new
-      model.create_prototype_building(building, 'NECB 2011', 'NECB HDD Method', weather, output_folder)
-      weather_file_path = OpenstudioStandards::Weather.get_standards_weather_file_path(weather)
-      OpenstudioStandards::Weather.model_set_building_location(model, weather_file_path: weather_file_path)
-      model.getSpaces.each do |space|
-        # puts space.name
-        hash[:"Space: #{space.name}"] = {}
-        hash[:"Space: #{space.name}"][:"With Adjacent Surface"] = {}
-        hash[:"Space: #{space.name}"][:"No Adjacent surface"] = []
-        space.surfaces.each do |surface|
-          max_delta_t = get_schedule_max_delta_t(model, surface)
-          if max_delta_t.nil?
-            hash[:"Space: #{space.name}"][:"No Adjacent surface"] << surface.name
-          else
-            hash[:"Space: #{space.name}"][:"With Adjacent Surface"][:"#{surface.name}"] = max_delta_t
-          end
-        end
-      end
-      # model.save(model_out_path(test_name), true)
-      File.open("#{output_folder}/max_delta_t.json", 'w') { |f| f.write(JSON.pretty_generate(hash)) }
-    end
-  end
-end

data/lib/openstudio-standards/btap/utilities/generate_space_types.rb

@@ -1,8 +0,0 @@
-require_relative '../../../test/helpers/minitest_helper'
-require_relative '../../../test/helpers/create_doe_prototype_helper'
-
-['NECB2011', 'NECB2015'].each do |template|
-  model = OpenStudio::Model::Model.new
-  Standard.build(template).add_all_spacetypes_to_model(model)
-  BTAP::FileIO.save_osm(model, File.join(File.dirname(__FILE__), 'output', "#{template}_space_types.osm"))
-end

data/lib/openstudio-standards/btap/utilities/necb_to_epw_map.rb

@@ -1,50 +0,0 @@
-require 'json'
-
-def distance(loc1, loc2)
-  rad_per_deg = Math::PI / 180 # PI / 180
-  rkm = 6371 # Earth radius in kilometers
-  rm = rkm * 1000 # Radius in meters
-
-  dlat_rad = (loc2[0] - loc1[0]) * rad_per_deg # Delta, converted to rad
-  dlon_rad = (loc2[1] - loc1[1]) * rad_per_deg
-
-  lat1_rad, lon1_rad = loc1.map { |i| i * rad_per_deg }
-  lat2_rad, lon2_rad = loc2.map { |i| i * rad_per_deg }
-
-  a = Math.sin(dlat_rad / 2)**2 + Math.cos(lat1_rad) * Math.cos(lat2_rad) * Math.sin(dlon_rad / 2)**2
-  c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a))
-  rm * c # Delta in meters
-end
-
-array_of_hashes = []
-necb_data_file_path = "#{File.dirname(__FILE__)}/../standards/necb/NECB2011/data/necb_2015_table_c1.json"
-epw_data_file_path = "#{File.dirname(__FILE__)}/../standards/necb/NECB2011/data/epw_data.json"
-JSON.parse(File.read(epw_data_file_path)).each do |epw|
-  epw['necb_tbl_c_city'] = nil
-  epw['necb_tbl_c_prov'] = nil
-  min_distance = 100000000000000.0
-  necb_closest = nil
-  JSON.parse(File.read(necb_data_file_path))['necb_2015_table_c1']['table'].each do |necb|
-    next if necb['lat_long'].nil?
-
-    d = distance([epw['latitude'].to_f, epw['longitude']], necb['lat_long'])
-    if min_distance > d
-      min_distance = d
-      necb_closest = necb
-    end
-  end
-  array_of_hashes << { 'epw_file' => epw['file'],
-                       'necb_location' => "#{necb_closest['city']},#{necb_closest['province']}",
-                       'hdd_difference' => (epw['hdd18'].to_f - necb_closest['degree_days_below_18_c'].to_f),
-                       'distance_km' => format('%.2f', (min_distance / 1000.0)),
-                       'hdd18' => necb_closest['degree_days_below_18_c'] }
-end
-File.write("#{File.dirname(__FILE__)}/../standards/necb/NECB2011/data/epw_file_to_necb_hdd_map.json", JSON.pretty_generate(array_of_hashes))
-
-# Load NECB Table c
-# Create new EPW to NECB Map
-# iterate thourgh EPW files.
-# Iterate THrough NECB Locations
-# Update distance if distance is less than stored distance.
-# End NECB iteration
-# End EPW Iteration

data/lib/openstudio-standards/btap/utilities/os_sim_extract.rb

@@ -1,48 +0,0 @@
-require 'json'
-
-class OS_sim_extract
-  # Name of file you want to add template fields to:
-  in_json_file = './simulations.json'
-  # Name of file you want this script to produce:
-  out_json_file = './simulations_out.json'
-  output_array = []
-  file = File.read(in_json_file)
-  data_tables = JSON.parse(file)
-  data_tables.each do |data_table|
-    building_type = nil
-    template_version = nil
-    area_scale_factor = nil
-    epw_file = nil
-    outdoor_air = false
-    data_table['measures'].each do |measure|
-      if measure['name'] == 'btap_create_necb_prototype_building_scale'
-        building_type = measure['arguments']['building_type']
-        template_version = measure['arguments']['template']
-        area_scale_factor = measure['arguments']['area_scale_factor']
-        epw_file = measure['arguments']['epw_file']
-      elsif measure['display_name'] == 'BTAPIdealAirLoadsOptionsEplus'
-        outdoor_air = true
-      end
-    end
-    extract_hash = {
-      conditioned_floor_area: data_table['building']['conditioned_floor_area_m2'],
-      exterior_area: data_table['building']['exterior_area_m2'],
-      volume: data_table['building']['volume'],
-      hdd: data_table['geography']['hdd'],
-      cdd: data_table['geography']['cdd'],
-      heating_gj: data_table['end_uses']['heating_gj'],
-      cooling_gj: data_table['end_uses']['cooling_gj'],
-      ep_conditioned_floor_area_m2: data_table['code_metrics']['ep_conditioned_floor_area_m2'],
-      os_conditioned_floor_area_m2: data_table['code_metrics']['os_conditioned_floor_area_m2'],
-      building_tedi_gj_per_m2: data_table['code_metrics']['building_tedi_gj_per_m2'],
-      building_medi_gj_per_m2: data_table['code_metrics']['building_medi_gj_per_m2'],
-      building_type: building_type,
-      template_version: template_version,
-      epw_file: epw_file,
-      area_scale_factor: area_scale_factor,
-      outdoor_air: outdoor_air
-    }
-    output_array << extract_hash
-  end
-  File.open(out_json_file, 'w') { |each_file| each_file.write(JSON.pretty_generate(output_array)) }
-end

data/lib/openstudio-standards/btap/utilities/rename_surfaces.rb

@@ -1,24 +0,0 @@
-require 'openstudio'
-require_relative '../../openstudio-standards/btap/btap'
-require_relative '../../openstudio-standards/btap/fileio'
-
-puts "\nenter osm file name (without file extension):\n"
-# osm_infile_name = gets.chomp
-osm_infile_name = 'NECB2011Hospital'
-osm_outfile_name = osm_infile_name.to_s + '_updated.osm'
-
-model = BTAP::FileIO.safe_load_model("#{osm_infile_name}.osm")
-
-spaces = model.getSpaces
-
-spaces.each do |space|
-  surfaces = space.surfaces()
-  surfaces.each_with_index do |surface, index|
-    name = "#{space.nameString}-#{index}-#{surface.surfaceType}"
-    puts name
-    surface.setName(name)
-  end
-end
-
-osm_path = OpenStudio::Path.new(osm_outfile_name.to_s)
-model.save(osm_path, true)

data/lib/openstudio-standards/btap/utilities/round_surf_coords.rb

@@ -1,32 +0,0 @@
-require 'openstudio'
-require_relative '../../openstudio-standards/btap/btap'
-require_relative '../../openstudio-standards/btap/fileio'
-
-puts "\nenter osm file name (without file extension):\n"
-osm_infile_name = gets.chomp
-osm_outfile_name = osm_infile_name.to_s + '_updated.osm'
-
-model = BTAP::FileIO.safe_load_model("#{osm_infile_name}.osm")
-
-surfaces = model.getSurfaces
-
-surfaces.each do |surface|
-  # rem_surf = ['Surface 14', 'Surface 16', 'Surface 75', 'Surface 46']
-  # if rem_surf.include?(surface.name.to_s)
-  #  surface.remove()
-  #  next
-  # end
-  vertex_hash = []
-  surface.vertices.each_with_index do |vertex, index|
-    old = vertex
-    vertex_hash << OpenStudio::Point3d.new(format('%.4f', old.x).to_f, format('%.4f', old.y).to_f, format('%.4f', old.z).to_f)
-    # sprintf('%.4f', old.x.round(4))
-    # puts new_vertex
-  end
-  # puts vertex_hash.join()
-  surface.setVertices(vertex_hash)
-  # puts "\n\n\n\n"
-end
-
-osm_path = OpenStudio::Path.new(osm_outfile_name.to_s)
-model.save(osm_path, true)

data/lib/openstudio-standards/btap/utilities/sched_create.rb

@@ -1,145 +0,0 @@
-# Utility which takes schedules from the NECB 2015 tables spreadsheet and puts them into a JSON file which somewhat
-# matches the NECB 2011 schedules.json file.
-
-require 'rubyXL'
-require 'json'
-
-class Sched_create
-  # Set a bunch of variables which generally remain static and are added to the new schedulesNECB2015.json file because
-  # that was how they were in the NECB2011 schedules.json file.
-
-  template = 'NECB2015'
-  name = 'NECB-'
-  name_pre_mod = ['', '', '-Electric', '', '', '', '']
-  name_post_mod = ['', '', '', '', '-Cooling', '-Heating', '']
-  category = ['Occupancy', 'Lighting', 'Equipment', 'Fan', 'Thermostat Setpoint', 'Thermostat Setpoint', 'Service Water Heating']
-  units = ['FRACTION', 'FRACTION', 'FRACTION', 'ON_OFF', 'TEMPERATURE', 'TEMPERATURE', 'FRACTION']
-  day_types = ['Default|Wkdy', 'Sat', 'Sun|Hol']
-  start_date = '2014-01-01T00:00:00+00:00'
-  end_date = '2014-12-31T00:00:00+00:00'
-  type = 'Hourly'
-  notes = nil
-  table_array = []
-  entry_array = []
-  json_array = []
-  refs = ['assumption']
-
-  # Open Excel file containing schdeules and look for the schedlues worksheet.
-
-  workbook = RubyXL::Parser.parse('./NECB2015_tables-171121.xlsx')
-  worksheet = workbook['A-8.4.3.2.(1)']
-
-  # Determine how many rows are used in the schedules worksheet.  Had to do this because there were some nil lines
-  # between each schedule in the worksheet.  This would cause the .each do command to break early.
-
-  sheetlength = worksheet.dimension.ref.row_range.end
-  table_index = 0
-
-  # Start looping through each schedule in the worksheet.  RubyXL reads a few lines after the end of the schedules in
-  # the worksheet.  The -32 is there to make sure that there is actually another schedule (or enough room for one) in
-  # the worksheet thus preventing errors due to manipulating nulls.
-
-  while table_index < (sheetlength - 32)
-    curr_loc = 5
-    cat_index = 0
-
-    # Loop through each category defined above (order of categories should match how they are presented in the worksheet).
-
-    category.each_with_index do |cat, cat_index|
-      # Build the schedule name using the category and some prefixes and suffixes because the nomenclature was not
-      # consistent.  Mostly trying to match what is in the NECB2011 schedules.json file.
-
-      table_name = name + worksheet[table_index + 1][0].value.to_s[-1] + name_pre_mod[cat_index] + '-' + cat + name_post_mod[cat_index]
-
-      # Loop through each day type: Weekdays/default, Saturdays, and Sundays/holidays.
-
-      day_types.each do |day_type|
-        line_values = []
-        values = []
-
-        # Need special if statements to handle Fans which are "On" and "Off" in the workbook but BTAP represents as 1 and 0.
-        # Also need to handle when cooling is "off" in the workbook but which BTAP represents as setting the setpoint
-        # really high.  The normal case (just a fraction) is at the end
-
-        if cat == 'Fan'
-          worksheet[table_index + curr_loc].cells.drop(1).each do |fan_val|
-            if fan_val.value == 'On'
-              line_values << 1.0
-            else
-              line_values << 0.0
-            end
-          end
-        elsif name_post_mod[cat_index] == '-Cooling'
-          worksheet[table_index + curr_loc].cells.drop(1).each do |cool_val|
-            if cool_val.value == 'Off'
-              line_values << 35
-            else
-              line_values << cool_val.value
-            end
-          end
-        else
-          worksheet[table_index + curr_loc].cells.drop(1).each { |col_ref| line_values << col_ref.value }
-        end
-
-        # The workbook lists the schedules started at 1:00 am and ending at 12:00 am (not sure why).  OpenStudio
-        # schedules start at 12:00 am and end at 11:00 pm (which makes more sense to me).  I'm not sure if the to_f
-        # statements need to be there but I added them anyway so all of the values in the .json file would be to at
-        # least 1 decimal place (like the originial NECB2011 schedules.json file).
-
-        values << line_values[23].to_f
-        line_values.each { |ln_value| values << ln_value.to_f }
-        values.pop
-
-        # Put everything for this day in a hash (the order according to the original NECB2011 schedules.json file).
-
-        entry_array = {
-          'template' => template,
-          'name' => table_name,
-          'category' => cat,
-          'units' => units[cat_index],
-          'day_types' => day_type,
-          'start_date' => start_date,
-          'end_date' => end_date,
-          'type' => type,
-          'notes' => notes,
-          'values' => values
-        }
-
-        # Add this day's hash to all of the others (I was calling them arrays but they were hashes).
-
-        json_array << entry_array
-
-        # Go to the next line for the next day.
-
-        curr_loc += 1
-      end
-
-      # Go to the next line for the next category.
-
-      curr_loc += 1
-    end
-
-    # End of the table set the location of the next table (which starts immediately after the preceding one)
-
-    table_index += curr_loc - 1
-  end
-
-  # Add a few hashes to the hash containing all of the schedules in the worksheet.  This is to match the formatting
-  # found in the original NECB2011 schedules.json file.
-
-  table_array = {
-    'tables' => [
-      'name' => 'schedules',
-      'data_type' => 'table',
-      'refs' => refs,
-      'table' => json_array
-    ]
-  }
-
-  # Turn the big hash in memory into a .json format and save it to file.  The pretty part is so the json file is nicely
-  # ordered and relatively easy to follow.
-
-  File.open('./schedulesNECB2015.json', 'w') do |each_file|
-    each_file.write(JSON.pretty_generate(table_array))
-  end
-end

data/lib/openstudio-standards/btap/utilities/set_mult_to_adiabatic.rb

@@ -1,53 +0,0 @@
-require 'openstudio'
-
-translator = OpenStudio::OSVersion::VersionTranslator.new
-ospath_in = OpenStudio::Path.new('./NECB2011Hospital_4.osm')
-ospath_out = OpenStudio::Path.new('./NECB2011Hospital_4_updated.osm')
-model = translator.loadModel(ospath_in)
-model = model.get
-
-spaces = model.getSpaces
-converted = []
-# loop through space
-spaces.each do |space|
-  # check for multiplier
-  if space.multiplier > 1
-    puts space.name
-    surfaces = space.surfaces
-    # get surfaces of a space
-    surfaces.each do |surface|
-      puts "\t#{surface.name}\n\t\t#{surface.outsideBoundaryCondition}"
-      # convert all surfaces except outdoors BC, and make it adabatic. if that
-      # surface has an adjacent surface, then also convert it to adiabatic
-      if surface.outsideBoundaryCondition.to_s == 'Surface'
-        if !surface.adjacentSurface.nil?
-          adj_surface = surface.adjacentSurface.get
-          adj_surface.setOutsideBoundaryCondition('Adiabatic')
-          converted << adj_surface.name
-        end
-        surface.setOutsideBoundaryCondition('Adiabatic')
-        converted << surface.name
-      # if the surface is already not adiabatic or outdoors, set the BC to adiabatic
-      elsif (surface.outsideBoundaryCondition.to_s != 'Outdoors') && (surface.outsideBoundaryCondition.to_s != 'Adiabatic')
-        surface.setOutsideBoundaryCondition('Adiabatic')
-        converted << surface.name
-      end
-    end
-  end
-end
-
-# ASSUMING THAT ALL ADIABATIC SURFACES ARE NOT SUPPOSED TO BE EXPOSED TO THE WIND AND SUN
-# set adiabatic surface's sun and wind exposure to none
-model.getSurfaces.each  do |surface|
-  if surface.outsideBoundaryCondition.to_s == 'Adiabatic'
-    surface.setWindExposure('NoWind')
-    surface.setSunExposure('NoSun')
-    converted << "#{surface.name} -- NoSun NoWind"
-  end
-end
-
-puts "\n\n"
-puts converted
-puts converted.length
-
-model.save(ospath_out, true)

data/lib/openstudio-standards/btap/utilities/space_type.rb

@@ -1,78 +0,0 @@
-
-require 'minitest/autorun'
-require 'openstudio'
-
-# if running from openstudio-standards.. load local standards
-os_standards_local_lib_path = '../../../lib/openstudio-standards.rb'
-if Dir.exist?(os_standards_local_lib_path)
-  require_relative os_standards_local_lib_path
-else
-  require 'openstudio-standards'
-end
-
-def read_space_types()
-  path = "/home/osdev/openstudio-standards/lib/openstudio-standards/standards/necb/NECB2011/data/geometry/DND*.osm"
-  spacetype_list = []
-  Dir.glob(path) do |osm_file|
-    model = BTAP::FileIO::load_osm(osm_file)
-    standard = NECB2011.new()
-    model.getSpaces.each do |space|
-      unless space.spaceType.empty?
-        name = space.spaceType.get.name.get
-        bt = space.spaceType.get.standardsBuildingType.get unless space.spaceType.get.standardsBuildingType.empty?
-        st = space.spaceType.get.standardsSpaceType.get unless space.spaceType.get.standardsSpaceType.empty?
-        spacetype_list << {'name': name, 'Original-StandardsBuildingType': bt, 'Original-StandardSpaceType': st}
-
-      end
-    end
-
-  end
-  unique_list = spacetype_list.uniq.sort_by { |st| st[:name] }
-
-
-  CSV.open("data.csv", "wb") do |csv|
-    csv << unique_list.first.keys # adds the attributes name on the first line
-    unique_list.each do |hash|
-      csv << hash.values
-    end
-  end
-
-  standard_space_type_list = Standard.build('NECB2011').standards_data['space_types'].map { |space_types| {'building_type': space_types['building_type'],
-                                                                                                           'space_type': space_types['space_type'],
-                                                                                                           "necb_hvac_system_selection_type": space_types['necb_hvac_system_selection_type'],
-                                                                                                           "necb_schedule_type": space_types['necb_schedule_type']
-
-
-  } }
-  standards_space_type_list.s
-
-  CSV.open("spacetypes.csv", "wb") do |csv|
-    csv << standard_space_type_list.first.keys # adds the attributes name on the first line
-    standard_space_type_list.each do |hash|
-      csv << hash.values
-    end
-  end
-end
-
-def map_spacetypes()
-
-  map_list = CSV.open("cold_lake_map.csv", headers: :first_row).map(&:to_h)
-  path = "/home/osdev/openstudio-standards/lib/openstudio-standards/standards/necb/NECB2011/data/geometry/DND*.osm"
-  Dir.glob(path) do |osm_file|
-    model = BTAP::FileIO::load_osm(osm_file)
-    model.getSpaceTypes.each do |st|
-      map_item = map_list.select { |item| item["Original Spacetype Name"] == st.name.get }
-      unless map_item.empty?
-        new_name = map_item.first()['New-StandardsBuildingType'].to_s + '-'+map_item.first()['New-StandardSpaceType'].to_s
-        st.setName(new_name)
-        st.setStandardsBuildingType(map_item.first()["New-StandardsBuildingType"])
-        st.setStandardsSpaceType(map_item.first()["New-StandardSpaceType"])
-        puts st
-      end
-    end
-    BTAP::FileIO::save_osm(model,File.join(__dir__,File.basename(osm_file)))
-  end
-end
-
-
-map_spacetypes()