openstudio-standards 0.8.5 → 0.8.7

data/lib/openstudio-standards/standards/necb/NECB2020/building_envelope.rb

@@ -1,122 +1,5 @@
-
 class NECB2020
 
-  # Go through the default construction sets and hard-assigned
-  # constructions. Clone the existing constructions and set their
-  # intended surface type and standards construction type per
-  # the PRM.  For some standards, this will involve making
-  # modifications.  For others, it will not.
-  #
-  # 90.1-2007, 90.1-2010, 90.1-2013
-  # @return [Boolean] returns true if successful, false if not
-
-  def apply_standard_construction_properties(model:,
-                                             necb_hdd: true,
-                                             runner: nil,
-                                             # ext surfaces
-                                             ext_wall_cond: nil,
-                                             ext_floor_cond: nil,
-                                             ext_roof_cond: nil,
-                                             # ground surfaces
-                                             ground_wall_cond: nil,
-                                             ground_floor_cond: nil,
-                                             ground_roof_cond: nil,
-                                             # fixed Windows
-                                             fixed_window_cond: nil,
-                                             fixed_wind_solar_trans: nil,
-                                             fixed_wind_vis_trans: nil,
-                                             # operable windows
-                                             operable_wind_solar_trans: nil,
-                                             operable_window_cond: nil,
-                                             operable_wind_vis_trans: nil,
-                                             # glass doors
-                                             glass_door_cond: nil,
-                                             glass_door_solar_trans: nil,
-                                             glass_door_vis_trans: nil,
-                                             # opaque doors
-                                             door_construction_cond: nil,
-                                             overhead_door_cond: nil,
-                                             # skylights
-                                             skylight_cond: nil,
-                                             skylight_solar_trans: nil,
-                                             skylight_vis_trans: nil,
-                                             # tubular daylight dome
-                                             tubular_daylight_dome_cond: nil,
-                                             tubular_daylight_dome_solar_trans: nil,
-                                             tubular_daylight_dome_vis_trans: nil,
-                                             # tubular daylight diffuser
-                                             tubular_daylight_diffuser_cond: nil,
-                                             tubular_daylight_diffuser_solar_trans: nil,
-                                             tubular_daylight_diffuser_vis_trans: nil)
-
-    model.getDefaultConstructionSets.sort.each do |default_surface_construction_set|
-      BTAP.runner_register('Info', 'apply_standard_construction_properties', runner)
-      if model.weatherFile.empty? || model.weatherFile.get.path.empty? || !File.exist?(model.weatherFile.get.path.get.to_s)
-
-        BTAP.runner_register('Error', 'Weather file is not defined. Please ensure the weather file is defined and exists.', runner)
-        return false
-      end
-
-      # hdd required to get correct conductance values from the json file. 
-      hdd = get_necb_hdd18(model: model, necb_hdd: necb_hdd)
-	  
-      # Lambdas are preferred over methods in methods for small utility methods.
-      correct_cond = lambda do |conductivity, surface_type|
-        return conductivity.nil? || conductivity.to_f <= 0.0 || conductivity == "NECB_Default" ? eval(model_find_objects(@standards_data['surface_thermal_transmittance'], surface_type)[0]['formula']) : conductivity.to_f
-      end
-
-      # Converts trans and vis to nil if requesting default.. or casts the string to a float.
-      correct_vis_trans = lambda do |value|
-        return value.nil? || value.to_f <= 0.0 || value == "NECB_Default" ? nil : value.to_f
-      end
-
-      BTAP::Resources::Envelope::ConstructionSets.customize_default_surface_construction_set!(model: model,
-                                                                                              name: "#{default_surface_construction_set.name.get} at hdd = #{hdd}",
-                                                                                              default_surface_construction_set: default_surface_construction_set,
-                                                                                              # ext surfaces
-                                                                                              ext_wall_cond: correct_cond.call(ext_wall_cond, {'boundary_condition' => 'Outdoors', 'surface' => 'Wall'}),
-                                                                                              ext_floor_cond: correct_cond.call(ext_floor_cond, {'boundary_condition' => 'Outdoors', 'surface' => 'Floor'}),
-                                                                                              ext_roof_cond: correct_cond.call(ext_roof_cond, {'boundary_condition' => 'Outdoors', 'surface' => 'RoofCeiling'}),
-                                                                                              # ground surfaces
-                                                                                              ground_wall_cond: correct_cond.call(ground_wall_cond, {'boundary_condition' => 'Ground', 'surface' => 'Wall'}),
-                                                                                              ground_floor_cond: correct_cond.call(ground_floor_cond, {'boundary_condition' => 'Ground', 'surface' => 'Floor'}),
-                                                                                              ground_roof_cond: correct_cond.call(ground_roof_cond, {'boundary_condition' => 'Ground', 'surface' => 'RoofCeiling'}),
-                                                                                              # fixed Windows
-                                                                                              fixed_window_cond: correct_cond.call(fixed_window_cond, {'boundary_condition' => 'Outdoors', 'surface' => 'Window'}),
-                                                                                              fixed_wind_solar_trans: correct_vis_trans.call(fixed_wind_solar_trans),
-                                                                                              fixed_wind_vis_trans: correct_vis_trans.call(fixed_wind_vis_trans),
-                                                                                              # operable windows
-                                                                                              operable_wind_solar_trans: correct_vis_trans.call(operable_wind_solar_trans),
-                                                                                              operable_window_cond: correct_cond.call(fixed_window_cond, {'boundary_condition' => 'Outdoors', 'surface' => 'Window'}),
-                                                                                              operable_wind_vis_trans: correct_vis_trans.call(operable_wind_vis_trans),
-                                                                                              # glass doors
-                                                                                              glass_door_cond: correct_cond.call(glass_door_cond, {'boundary_condition' => 'Outdoors', 'surface' => 'Window'}),
-                                                                                              glass_door_solar_trans: correct_vis_trans.call(glass_door_solar_trans),
-                                                                                              glass_door_vis_trans: correct_vis_trans.call(glass_door_vis_trans),
-                                                                                              # opaque doors
-                                                                                              door_construction_cond: correct_cond.call(door_construction_cond, {'boundary_condition' => 'Outdoors', 'surface' => 'Door'}),
-                                                                                              overhead_door_cond: correct_cond.call(overhead_door_cond, {'boundary_condition' => 'Outdoors', 'surface' => 'Door'}),
-                                                                                              # skylights
-                                                                                              skylight_cond: correct_cond.call(skylight_cond, {'boundary_condition' => 'Outdoors', 'surface' => 'Skylight'}),
-                                                                                              skylight_solar_trans: correct_vis_trans.call(skylight_solar_trans),
-                                                                                              skylight_vis_trans: correct_vis_trans.call(skylight_vis_trans),
-                                                                                              # tubular daylight dome
-                                                                                              tubular_daylight_dome_cond: correct_cond.call(skylight_cond, {'boundary_condition' => 'Outdoors', 'surface' => 'Skylight'}),
-                                                                                              tubular_daylight_dome_solar_trans: correct_vis_trans.call(tubular_daylight_dome_solar_trans),
-                                                                                              tubular_daylight_dome_vis_trans: correct_vis_trans.call(tubular_daylight_dome_vis_trans),
-                                                                                              # tubular daylight diffuser
-                                                                                              tubular_daylight_diffuser_cond: correct_cond.call(skylight_cond, {'boundary_condition' => 'Outdoors', 'surface' => 'Skylight'}),
-                                                                                              tubular_daylight_diffuser_solar_trans: correct_vis_trans.call(tubular_daylight_diffuser_solar_trans),
-                                                                                              tubular_daylight_diffuser_vis_trans: correct_vis_trans.call(tubular_daylight_diffuser_vis_trans)
-      )
-    end
-    # sets all surfaces to use default constructions sets except adiabatic, where it does a hard assignment of the interior wall construction type.
-    model.getPlanarSurfaces.sort.each(&:resetConstruction)
-    # if the default construction set is defined..try to assign the interior wall to the adiabatic surfaces
-    BTAP::Resources::Envelope.assign_interior_surface_construction_to_adiabatic_surfaces(model, nil)
-    BTAP.runner_register('Info', ' apply_standard_construction_properties was sucessful.', runner)
-  end
-
   # Set all external subsurfaces (doors, windows, skylights) to NECB values.
   # @author phylroy.lopez@nrcan.gc.ca
   # @param subsurface [String]

data/lib/openstudio-standards/standards/necb/NECB2020/data/surface_thermal_transmittance.json

@@ -8,53 +8,84 @@
         "PCF 1537"
       ],
       "units": "W_per_m2_K",
-      "table": [
-        {
-          "boundary_condition": "Outdoors",
-          "surface": "Wall",
-          "formula": "( hdd < 3000) ? 0.290 : ( hdd < 4000) ? 0.265 : ( hdd < 5000 ) ? 0.240 : ( hdd < 6000) ? 0.215 :( hdd < 7000) ? 0.190 : 0.165"
+      "table": {
+        "outdoors": {
+          "wall": {
+            "3000": 0.29,
+            "4000": 0.265,
+            "5000": 0.24,
+            "6000": 0.215,
+            "7000": 0.19,
+            "9999": 0.165
+          },
+          "roofceiling": {
+            "3000": 0.164,
+            "4000": 0.156,
+            "5000": 0.138,
+            "6000": 0.121,
+            "7000": 0.117,
+            "9999": 0.11
+          },
+          "floor": {
+            "3000": 0.193,
+            "4000": 0.175,
+            "5000": 0.156,
+            "6000": 0.138,
+            "7000": 0.121,
+            "9999": 0.117
+          },
+          "window": {
+            "3000": 1.9,
+            "4000": 1.9,
+            "5000": 1.73,
+            "6000": 1.73,
+            "7000": 1.44,
+            "9999": 1.44
+          },
+          "skylight": {
+            "3000": 2.69,
+            "4000": 2.69,
+            "5000": 2.41,
+            "6000": 2.41,
+            "7000": 2.01,
+            "9999": 2.01
+          },
+          "door": {
+            "3000": 2.12,
+            "4000": 1.9,
+            "5000": 1.9,
+            "6000": 1.9,
+            "7000": 1.9,
+            "9999": 1.44
+          }
         },
-        {
-          "boundary_condition": "Outdoors",
-          "surface": "RoofCeiling",
-          "formula": "( hdd < 3000) ? 0.164 : ( hdd < 4000) ? 0.156 : ( hdd < 5000 ) ? 0.138 : ( hdd < 6000) ? 0.121 :( hdd < 7000) ? 0.117 : 0.110"
-        },
-        {
-          "boundary_condition": "Outdoors",
-          "surface": "Floor",
-          "formula": "( hdd < 3000) ? 0.193 : ( hdd < 4000) ? 0.175 : ( hdd < 5000 ) ? 0.156 : ( hdd < 6000) ? 0.138 :( hdd < 7000) ? 0.121 : 0.117"
-        },
-        {
-          "boundary_condition": "Outdoors",
-          "surface": "Window",
-          "formula": "( hdd < 4000) ? 1.90 : ( hdd < 6000) ? 1.730 : 1.440"
-        },
-        {
-          "boundary_condition": "Outdoors",
-          "surface": "Skylight",
-          "formula": "( hdd < 4000) ? 2.690 : ( hdd < 6000) ? 2.410 : 2.010"
-        },
-        {
-          "boundary_condition": "Outdoors",
-          "surface": "Door",
-          "formula": "( hdd < 4000) ? 1.900 : ( hdd < 6000) ? 1.730 : 1.440"
-        },
-        {
-          "boundary_condition": "Ground",
-          "surface": "Wall",
-          "formula": "( hdd < 3000) ? 0.568 : ( hdd < 4000) ? 0.379 : ( hdd < 7000) ? 0.284 : 0.210"
-        },
-        {
-          "boundary_condition": "Ground",
-          "surface": "RoofCeiling",
-          "formula": "( hdd < 3000) ? 0.568 : ( hdd < 4000) ? 0.379 : ( hdd < 7000) ? 0.284 : 0.210"
-        },
-        {
-          "boundary_condition": "Ground",
-          "surface": "Floor",
-          "formula": "( hdd < 7000) ? 0.757 : 0.379"
+        "ground": {
+          "wall": {
+            "3000": 0.568,
+            "4000": 0.379,
+            "5000": 0.284,
+            "6000": 0.284,
+            "7000": 0.284,
+            "9999": 0.21
+          },
+          "roofceiling": {
+            "3000": 0.568,
+            "4000": 0.379,
+            "5000": 0.284,
+            "6000": 0.284,
+            "7000": 0.284,
+            "9999": 0.21
+          },
+          "floor": {
+            "3000": 0.757,
+            "4000": 0.757,
+            "5000": 0.757,
+            "6000": 0.757,
+            "7000": 0.757,
+            "9999": 0.379
+          }
         }
-      ]
+      }
     }
   }
 }

data/lib/openstudio-standards/standards/necb/NECB2020/necb_2020.rb

@@ -140,4 +140,222 @@ class NECB2020 < NECB2017
     infiltration.setSpace(space)
     return true
   end
+
+  # Generate NECB 2020 Performance Path compliance models (proposed and reference)
+  #
+  # This method implements the NECB 2020 Section 8.4 Performance Path by:
+  # 1. Documenting the proposed building characteristics per Section 8.4.3
+  # 2. Generating a reference building with prescriptive requirements per Section 8.4.4
+  # 3. Optionally running simulations and validating compliance per Section 8.4.1
+  # 4. Generating detailed HTML compliance reports with before/after logging
+  #
+  # @param proposed_model [OpenStudio::Model::Model] The proposed building model (input, not modified)
+  # @param epw_file [String] Path to EPW weather file
+  # @param sizing_run_dir [String] Directory for sizing runs (default: current directory)
+  # @param output_dir [String] Directory for output files (default: current directory)
+  # @param run_simulations [Boolean] Whether to run EnergyPlus simulations (default: false)
+  # @param html_report [Boolean] Whether to generate HTML report (default: true)
+  # @return [Hash] Results hash containing:
+  #   - :proposed_model - The input proposed building model (unmodified)
+  #   - :reference_model - Generated reference building model
+  #   - :compliance_log - Structured compliance logger with all changes
+  #   - :proposed_model_path - Path to saved proposed model copy
+  #   - :reference_model_path - Path to saved reference model
+  #   - :html_report_path - Path to HTML compliance report (if html_report: true)
+  #   - :compliance_result - Compliance validation results (if run_simulations: true)
+  #   - :building_energy_target - Building energy target from reference (if run_simulations: true)
+  #   - :climate_zone - Climate zone for the location
+  #   - :hdd18 - Heating degree days (base 18°C)
+  #
+  # @example Basic usage without simulations
+  #   standard = Standard.build('NECB2020')
+  #   result = standard.model_create_necb_2020_performance_compliance(
+  #     proposed_model: model,
+  #     epw_file: 'path/to/weather.epw'
+  #   )
+  #   puts "Reference model: #{result[:reference_model_path]}"
+  #   puts "HTML report: #{result[:html_report_path]}"
+  #
+  # @example With simulations and compliance validation
+  #   result = standard.model_create_necb_2020_performance_compliance(
+  #     proposed_model: model,
+  #     epw_file: 'path/to/weather.epw',
+  #     run_simulations: true
+  #   )
+  #   if result[:compliance_result][:compliant]
+  #     puts "Building is compliant!"
+  #   end
+  #
+  def model_create_necb_2020_performance_compliance(proposed_model:,
+                                                    epw_file:,
+                                                    sizing_run_dir: Dir.pwd,
+                                                    output_dir: Dir.pwd,
+                                                    run_simulations: false,
+                                                    html_report: true)
+
+    # Load required modules
+    require_relative 'performance_compliance/compliance_logger'
+    require_relative 'performance_compliance/proposed_builder'
+    require_relative 'performance_compliance/reference_builder'
+    require_relative 'performance_compliance/reference_hvac_selector'
+    require_relative 'performance_compliance/compliance_validator'
+    require_relative 'performance_compliance/compliance_report'
+
+    # Initialize logger
+    logger = OpenstudioStandards::NECB2020::ComplianceLogger.new
+
+    OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.NECB2020',
+                       'Starting NECB 2020 Performance Path compliance generation')
+
+    # Get climate information
+    hdd18 = get_necb_hdd18(model: proposed_model)
+    climate_zone = get_climate_zone_name(hdd18)
+
+    logger.log_article(
+      article: '8.4.1.1',
+      action: 'Initialized NECB 2020 Performance Path compliance',
+      details: {
+        climate_zone: climate_zone,
+        hdd18: hdd18.round(0),
+        epw_file: File.basename(epw_file)
+      }
+    )
+
+    # Step 1: Document proposed building per Section 8.4.3
+    OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.NECB2020',
+                       'Documenting proposed building characteristics (Section 8.4.3)')
+
+    proposed_builder = OpenstudioStandards::NECB2020::ProposedBuilder.new(proposed_model, logger)
+    proposed_characteristics = proposed_builder.document_all_characteristics
+
+    # Step 2: Generate reference building per Section 8.4.4
+    OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.NECB2020',
+                       'Generating reference building (Section 8.4.4)')
+
+    reference_builder = OpenstudioStandards::NECB2020::ReferenceBuilder.new(
+      self, proposed_model, logger, epw_file
+    )
+    reference_model = reference_builder.generate_reference_building(sizing_run_dir: sizing_run_dir)
+
+    # Step 3: Save models
+    proposed_model_path = File.join(output_dir, 'proposed_building.osm')
+    reference_model_path = File.join(output_dir, 'reference_building.osm')
+
+    BTAP::FileIO.save_osm(proposed_model, proposed_model_path)
+    BTAP::FileIO.save_osm(reference_model, reference_model_path)
+
+    OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.NECB2020',
+                       "Saved proposed model to: #{proposed_model_path}")
+    OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.NECB2020',
+                       "Saved reference model to: #{reference_model_path}")
+
+    # Prepare results
+    results = {
+      proposed_model: proposed_model,
+      reference_model: reference_model,
+      compliance_log: logger,
+      proposed_model_path: proposed_model_path,
+      reference_model_path: reference_model_path,
+      climate_zone: climate_zone,
+      hdd18: hdd18,
+      epw_file: epw_file
+    }
+
+    # Step 4: Optional - Run simulations and validate compliance
+    if run_simulations
+      OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.NECB2020',
+                         'Running simulations and validating compliance (Section 8.4.1)')
+
+      # Run proposed building simulation
+      proposed_sql_path = run_simulation_and_get_sql(
+        proposed_model,
+        epw_file,
+        File.join(output_dir, 'proposed_sim')
+      )
+
+      # Run reference building simulation
+      reference_sql_path = run_simulation_and_get_sql(
+        reference_model,
+        epw_file,
+        File.join(output_dir, 'reference_sim')
+      )
+
+      if proposed_sql_path && reference_sql_path
+        # Load SQL files
+        proposed_sql = OpenStudio::SqlFile.new(proposed_sql_path)
+        reference_sql = OpenStudio::SqlFile.new(reference_sql_path)
+
+        # Validate compliance
+        validator = OpenstudioStandards::NECB2020::ComplianceValidator.new(logger)
+        compliance_result = validator.validate_compliance(proposed_sql, reference_sql)
+
+        results[:compliance_result] = compliance_result
+        results[:building_energy_target] = compliance_result[:annual_energy][:building_energy_target_gj]
+
+        OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.NECB2020',
+                           "Compliance: #{compliance_result[:compliant] ? 'PASS' : 'FAIL'}")
+      else
+        OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.NECB2020',
+                           'Simulations failed - compliance validation not performed')
+      end
+    end
+
+    # Step 5: Generate HTML report
+    if html_report
+      OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.NECB2020',
+                         'Generating HTML compliance report')
+
+      report_data = {
+        climate_zone: climate_zone,
+        hdd18: hdd18,
+        epw_file: epw_file,
+        compliance_result: results[:compliance_result]
+      }
+
+      report_generator = OpenstudioStandards::NECB2020::ComplianceReportGenerator.new(logger, report_data)
+      report_path = File.join(output_dir, 'necb_2020_performance_compliance_report.html')
+      report_generator.save_report(report_path)
+
+      results[:html_report_path] = report_path
+
+      OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.NECB2020',
+                         "Saved HTML report to: #{report_path}")
+    end
+
+    # Final summary
+    summary = logger.get_summary
+    OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.NECB2020',
+                       "Compliance generation complete. Total entries: #{summary[:total_entries]}, " \
+                       "Passed: #{summary[:passed]}, Failed: #{summary[:failed]}")
+
+    results
+  end
+
+  private
+
+  # Run EnergyPlus simulation and return SQL file path
+  #
+  # @param model [OpenStudio::Model::Model] Model to simulate
+  # @param epw_file [String] Weather file path
+  # @param run_dir [String] Directory for simulation files
+  # @return [String, nil] Path to SQL file, or nil if simulation failed
+  def run_simulation_and_get_sql(model, epw_file, run_dir)
+    # Create run directory
+    FileUtils.mkdir_p(run_dir)
+
+    # Save model
+    osm_path = File.join(run_dir, 'in.osm')
+    BTAP::FileIO.save_osm(model, osm_path)
+
+    # Run simulation
+    sql_path = model_run_simulation_and_log_errors(model, run_dir)
+
+    return sql_path if sql_path
+
+    nil
+  rescue StandardError => e
+    OpenStudio.logFree(OpenStudio::Error, 'openstudio.standards.NECB2020',
+                       "Simulation failed: #{e.message}")
+    nil
+  end
 end

data/lib/openstudio-standards/standards/necb/common/construction_defaults.osm

@@ -1344,11 +1344,14 @@ OS:DefaultConstructionSet,
   ,                                       !- Building Shading Construction Name
   ;                                       !- Site Shading Construction Name
 
-OS:Material:NoMass,
+OS:Material,
   {8123ea19-659f-408b-9bbf-9d3d1a8354b5}, !- Handle
   Typical Carpet Pad,                     !- Name
-  Smooth,                                 !- Roughness
-  0.216479986995276,                      !- Thermal Resistance {m2-K/W}
+  VeryRough,                              !- Roughness
+  0.01,                                   !- Thickness {m}
+  0.06,                                   !- Conductivity {W/m-K}
+  200,                                    !- Density {kg/m3}
+  1360,                                   !- Specific Heat {J/kg-K}
   0.9,                                    !- Thermal Absorptance
   0.7,                                    !- Solar Absorptance
   0.8;                                    !- Visible Absorptance
@@ -1399,11 +1402,14 @@ OS:StandardsInformation:Construction,
   InteriorCeiling,                        !- Intended Surface Type
   ;                                       !- Standards Construction Type
 
-OS:Material:NoMass,
+OS:Material,
   {02547311-2903-4271-85c6-5ef37f49a4de}, !- Handle
   Typical Insulation,                     !- Name
-  Smooth,                                 !- Roughness
-  0.101874652714525,                      !- Thermal Resistance {m2-K/W}
+  MediumSmooth,                           !- Roughness
+  0.005,                                  !- Thickness {m}
+  0.038,                                  !- Conductivity {W/m-K}
+  29,                                     !- Density {kg/m3}
+  1210,                                   !- Specific Heat {J/kg-K}
   0.9,                                    !- Thermal Absorptance
   0.7,                                    !- Solar Absorptance
   0.7;                                    !- Visible Absorptance
@@ -2884,4 +2890,3 @@ OS:Rendering:Color,
   255,                                    !- Rendering Red Value
   140,                                    !- Rendering Green Value
   0;                                      !- Rendering Blue Value
-

data/lib/openstudio-standards/standards/standard.rb

@@ -107,7 +107,7 @@ class Standard
         OpenStudio.logFree(OpenStudio::Debug, 'openstudio.standards.standard', "Loading JSON files from #{data_dir}")
         files = Dir.glob("#{data_dir}/data/*.json").select { |e| File.file? e }
         files.each do |file|
-          data = JSON.parse(File.read(file))
+          data = JSON.parse(File.read(file, encoding: 'UTF-8'))
           data.each_pair do |key, objs|
             # Override the template in inherited files to match the instantiated template
             objs.each do |obj|

data/lib/openstudio-standards/version.rb

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

data/lib/openstudio-standards.rb

@@ -141,11 +141,19 @@ module OpenstudioStandards
 
   # BTAP (Natural Resources Canada)
   require_relative 'openstudio-standards/btap/btap'
-  require_relative 'openstudio-standards/btap/common_paths'
+
+  # BTAP QAQC
+  require_relative "openstudio-standards/btap/qaqc/analysis.rb"
+  require_relative "openstudio-standards/btap/qaqc/data.rb"
+  require_relative "openstudio-standards/btap/qaqc/datapoint.rb"
+
+  # BTAP Costing
+  require_relative 'openstudio-standards/btap/costing/database'
   require_relative 'openstudio-standards/btap/costing/btap_costing'
   require_relative 'openstudio-standards/btap/carbon/btap_carbon'
   require_relative 'openstudio-standards/btap/costing/ventilation_costing'
   require_relative 'openstudio-standards/btap/costing/envelope_costing'
+  require_relative 'openstudio-standards/btap/costing/thermal_bridging_costing'
   require_relative 'openstudio-standards/btap/costing/lighting_costing'
   require_relative 'openstudio-standards/btap/costing/heating_cooling_costing'
   require_relative 'openstudio-standards/btap/costing/shw_costing'
@@ -215,9 +223,6 @@ module OpenstudioStandards
   # NECB QAQC
   require_relative "#{stds}/necb/NECB2011/qaqc/necb_qaqc.rb"
   require_relative "#{stds}/necb/NECB2015/qaqc/necb_2015_qaqc.rb"
-  require_relative "#{stds}/necb/common/btap_analysis.rb"
-  require_relative "#{stds}/necb/common/btap_data.rb"
-  require_relative "#{stds}/necb/common/btap_datapoint.rb"
 
   # ECM development
   require_relative "#{stds}/necb/ECMS/ecms.rb"