openstudio-standards 0.8.4 → 0.8.5.rc1

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

@@ -20,6 +20,7 @@ class NECB2020
     else
       capacity_w = capacity_w.get
     end
+    capacity_kw = capacity_w/1000.0
     capacity_btu_per_hr = OpenStudio.convert(capacity_w, 'W', 'Btu/hr').get
     capacity_kbtu_per_hr = OpenStudio.convert(capacity_w, 'W', 'kBtu/hr').get
 
@@ -35,6 +36,7 @@ class NECB2020
     end
     volume_gal = OpenStudio.convert(volume_m3, 'm^3', 'gal').get
     volume_litre = OpenStudio.convert(volume_m3, 'm^3', 'L').get
+    
     # Get the heater fuel type
     fuel_type = water_heater_mixed.heaterFuelType
     unless fuel_type == 'NaturalGas' || fuel_type == 'Electricity' || fuel_type == 'FuelOilNo2'
@@ -47,12 +49,12 @@ class NECB2020
     # From PNNL http://www.energycodes.gov/sites/default/files/documents/PrototypeModelEnhancements_2014_0.pdf
     # Appendix A: Service Water Heating
 	  # and modified by PCF 1630 as noted below.
-
     water_heater_eff = nil
     ua_btu_per_hr_per_f = nil
     sl_btu_per_hr = nil
     q_load_btu_per_hr = nil
     uef = nil
+
     case fuel_type
     when 'Electricity'
       volume_litre_per_s = volume_m3 * 1000
@@ -89,55 +91,57 @@ class NECB2020
       #   AND
       #
       #   PNNL http://www.energycodes.gov/sites/default/files/documents/PrototypeModelEnhancements_2014_0.pdf
+      #
+      # Updated reference links:
+      #  https://www.pnnl.gov/main/publications/external/technical_reports/PNNL-23269.pdf - Equations may have typos, also for EF which is at diff test T.
+      #  https://www.nrel.gov/docs/fy21osti/71633.pdf
+      #  https://ases.org/wp-content/uploads/2021/11/Using-Simple-Algebraic-Models-and-Rating-Test-Data-to-Predict-Water-Heater-Energy-Consumption-Under-Off-Test-Conditions-.pdf
+      #  https://www.ecfr.gov/current/title-10/chapter-II/subchapter-D/part-430/subpart-B/appendix-Appendix%20E%20to%20Subpart%20B%20of%20Part%20430 
+      #  
+
+      # Assume first hour rating.
+      # Rule of thumb is FHR is 70% tank_volume + ~40 Gal
+      #  Ref: https://www.waterheaterpros.com/first-hour-rating#:~:text=To%20find%20a%20water%20heater%27s,can%20deliver%20at%20peak%20hours.
+      fhr_L_per_hr = 0.7*volume_litre + 151.0
 
-      # Assume fhr = peak demand flow
-      tank_param = auto_size_shw_capacity(model:water_heater_mixed.model, shw_scale: 'NECB_Default')
-      fhr_L_per_hr = tank_param['loop_peak_flow_rate_SI']
-      fhr_L_per_hr = fhr_L_per_hr * 3600000
       if capacity_w <= 22000 and volume_litre >= 76 and volume_litre < 208
-        if fhr_L_per_hr < 68
+        if fhr_L_per_hr < 68 # 18 US Gal - UEF draw pattern very small usage
           uef = 0.3456 - 0.00053*volume_litre
-          q_load_btu_per_hr = 5561
-          volume_drawn_gal = 10
-        elsif fhr_L_per_hr >= 68 and fhr_L_per_hr < 193
+          volume_drawn_gal = 10 # 37.85L
+        elsif fhr_L_per_hr >= 68 and fhr_L_per_hr < 193 # 51 US Gal - UEF draw pattern low usage
           uef = 0.5982 - 0.00050*volume_litre
-          q_load_btu_per_hr = 21131
-          volume_drawn_gal = 38
-        elsif fhr_L_per_hr >= 193 and fhr_L_per_hr < 284
+          volume_drawn_gal = 38 # 143.8L
+        elsif fhr_L_per_hr >= 193 and fhr_L_per_hr < 284 # 75 US Gal - UEF draw pattern medium usage
           uef = 0.6483 - 0.00045*volume_litre
-          q_load_btu_per_hr = 30584
-          volume_drawn_gal = 55
-        elsif fhr_L_per_hr >= 284 
+          volume_drawn_gal = 55 # 208.2L
+        elsif fhr_L_per_hr >= 284 # 75 US Gal - UEF draw pattern high usage
           uef = 0.6920 - 0.00034*volume_litre
-          q_load_btu_per_hr = 46710
-          volume_drawn_gal = 84
+          volume_drawn_gal = 84 # 318.0L
         end
 
-        # Assume burner efficiency  (PNNL)
+        # Assume burner efficiency  (PNNL-23269)
         water_heater_eff = 0.82
 
         # Estimate recovery efficiency (RE) and UA (Maguire and Robers, 2020)
-        q_load_btu = volume_drawn_gal*8.30074*0.99826*(125-58) #water properties at 91.5F
+        q_load_btu = volume_drawn_gal*8.30074*0.99826*(125.0-58.0) # water properties at 91.5F; derived from UEF test.
         capacity_btu_per_hr = OpenStudio.convert(capacity_w, 'W', 'Btu/hr').get
+
+        # From PNNL-23269?
         re = water_heater_eff + q_load_btu*(uef-water_heater_eff)/(24*capacity_btu_per_hr*uef)
         ua_btu_per_hr_per_f = (water_heater_eff-re)*capacity_btu_per_hr/(125-67.5)  
 
       elsif capacity_w <= 22000 and volume_litre >= 208 and volume_litre < 380
         if fhr_L_per_hr < 68
           uef = 0.6470 - 0.00016*volume_litre
-          q_load_btu_per_hr = 5561
           volume_drawn_gal = 10
         elsif fhr_L_per_hr >= 68 and fhr_L_per_hr < 193
           uef = 0.7689 - 0.00013*volume_litre
-          q_load_btu_per_hr = 21131
           volume_drawn_gal = 38
         elsif fhr_L_per_hr >= 193 and fhr_L_per_hr < 284
           uef = 0.7897 - 0.00011*volume_litre
-          q_load_btu_per_hr = 30584
           volume_drawn_gal = 55
         elsif fhr_L_per_hr >= 284 
           uef = 0.8072 - 0.00008*volume_litre
-          q_load_btu_per_hr = 46710
           volume_drawn_gal = 84
         end
 
@@ -147,7 +151,8 @@ class NECB2020
         # Estimate recovery efficiency (RE) and UA (Maguire and Robers, 2020)
         q_load_btu = volume_drawn_gal*8.30074*0.99826*(125-58) #water properties at 91.5F
         capacity_btu_per_hr = OpenStudio.convert(capacity_w, 'W', 'Btu/hr').get
-        # Estimate recovery efficiency (RE) and UA (Maguire and Robers, 2020)
+
+        # Estimate recovery efficiency (RE) and UA (Maguire and Robers, 2020); Note tank at 125F for UEF, previously 135F for EF test
         re = water_heater_eff + q_load_btu*(uef-water_heater_eff)/(24*capacity_btu_per_hr*uef)
         ua_btu_per_hr_per_f = (water_heater_eff-re)*capacity_btu_per_hr/(125-67.5)      
 
@@ -163,16 +168,12 @@ class NECB2020
         # Estimate recovery efficiency (RE) and UA (Maguire and Robers, 2020)
         capacity_btu_per_hr = OpenStudio.convert(capacity_w, 'W', 'Btu/hr').get
         if fhr_L_per_hr < 68
-          q_load_btu_per_hr = 5561
           volume_drawn_gal = 10
         elsif fhr_L_per_hr >= 68 and fhr_L_per_hr < 193
-          q_load_btu_per_hr = 21131
           volume_drawn_gal = 38
         elsif fhr_L_per_hr >= 193 and fhr_L_per_hr < 284
-          q_load_btu_per_hr = 30584
           volume_drawn_gal = 55
-        elsif fhr_L_per_hr >= 284 
-          q_load_btu_per_hr = 46710
+        elsif fhr_L_per_hr >= 284
           volume_drawn_gal = 84
         end
         q_load_btu = volume_drawn_gal*8.30074*0.99826*(125-58) #water properties at 91.5F
@@ -182,7 +183,6 @@ class NECB2020
         ua_btu_per_hr_per_f = (water_heater_eff-re)*capacity_btu_per_hr/(125-67.5)      
         
       else # all other water heaters
-        capacity_kw = capacity_w/1000
         capacity_btu_per_hr = OpenStudio.convert(capacity_w, 'W', 'Btu/hr').get
         # thermal efficiency (NECB2020)
         et = 0.9

data/lib/openstudio-standards/standards/necb/common/btap_analysis.rb

@@ -0,0 +1,79 @@
+require 'openstudio'
+
+# BTAP Analysis:
+#   Class to instantiate post-analysis mechanisms like costing or carbon
+#   calculation.
+#   Can be done during a simulation or without one given an OSM file and its SQL
+#   file, along with a few other parameters.
+
+# Abstract class, only instantiate BTAPNoSimAnalysis or BTAPDatapointAnalysis.
+class BTAPAnalysis
+  def initialize(output_folder:, template:)
+    @output_folder = output_folder
+    @template      = template
+    @cp            = CommonPaths.instance
+  end
+
+  def run_costing(costs_csv: @cp.costs_path, factors_csv: @cp.costs_local_factors_path)
+    costing = BTAPCosting.new(costs_csv: costs_csv, factors_csv: factors_csv, attributes: @attributes)
+
+    cost_result, btap_items = costing.cost_audit_all(
+      model: @model,
+      prototype_creator: @standard,
+      template_type: @template)
+
+    if not @qaqc.nil?
+      @qaqc[:costing_information] = cost_result
+    end
+
+    # disable openstudio-version; for debugging only
+    # cost_result["openstudio-version"] = OpenstudioStandards::VERSION
+    File.open(File.join(@output_folder, 'cost_results.json'), 'w') do |f|
+      f.write(JSON.pretty_generate(cost_result, allow_nan: true))
+    end
+    puts "Wrote File cost_results.json in #{@output_folder} "
+
+    return cost_result
+  end
+
+  def run_carbon
+    carbon = BTAPCarbon.new(attributes: @attributes, standards_data: @standard.standards_data)
+    carbon_result = carbon.audit_embodied_carbon
+
+    if not @qaqc.nil?
+      @qaqc[:carbon_information] = carbon_result
+    end
+
+    File.open(File.join(@output_folder, 'carbon_results.json'), 'w') do |f|
+      f.write(JSON.pretty_generate(carbon_result, allow_nan: true))
+    end
+    puts "Wrote File carbon_results.json in #{@output_folder} "
+
+    return carbon_result
+  end
+end
+
+# For a no-simulation run, the SQL file, template, and datapoint ID must be provided.
+class BTAPNoSimAnalysis < BTAPAnalysis
+  def initialize(model_path:, sql_file_path:, output_folder:, template:, datapoint_id:, analysis_id: SecureRandom.uuid)
+    super(output_folder: output_folder, template: template)
+    @model        = BTAP::FileIO.load_osm(model_path)
+    @template     = template
+    @standard     = Standard.build(template)
+    @datapoint_id = datapoint_id
+    @analysis_id  = analysis_id
+    @attributes   = BTAP::Attributes.new(@model, @standard)
+    @model.setSqlFile(OpenStudio::SqlFile.new(sql_file_path))
+    @qaqc = BTAPDatapoint.build_qaqc(@model, @standard, @datapoint_id, @analysis_id)
+  end
+end
+
+class BTAPDatapointAnalysis < BTAPAnalysis
+  def initialize(model:, output_folder:, template:, standard:, qaqc:)
+    super(output_folder: output_folder, template: template)
+    @model      = model
+    @standard   = standard
+    @qaqc       = qaqc
+    @attributes = BTAP::Attributes.new(@model, @standard)
+  end
+end

data/lib/openstudio-standards/standards/necb/common/btap_data.rb

@@ -5,10 +5,22 @@ class BTAPData
   attr_accessor :sqlite_file
   attr_accessor :btap_data
 
-  def initialize(model:, runner: nil, cost_result:, baseline_cost_equipment_total_cost_per_m_sq: -1.0,
-                 baseline_cost_utility_neb_total_cost_per_m_sq: -1.0, baseline_energy_eui_total_gj_per_m_sq: -1.0, qaqc:,
-                 npv_start_year: 2022, npv_end_year: 2041, npv_discount_rate: 0.03, npv_discount_rate_carbon: 0.03, oerd_utility_pricing: nil,
-                 utility_pricing_year: 2020)
+  def initialize(
+    model:, 
+    runner: nil, 
+    cost_result:, 
+    carbon_result:,
+    baseline_cost_equipment_total_cost_per_m_sq: -1.0,
+    baseline_cost_utility_neb_total_cost_per_m_sq: -1.0, 
+    baseline_energy_eui_total_gj_per_m_sq: -1.0, 
+    qaqc:,
+    npv_start_year: 2022, 
+    npv_end_year: 2041, 
+    npv_discount_rate: 0.03, 
+    npv_discount_rate_carbon: 0.03, 
+    oerd_utility_pricing: nil,
+    utility_pricing_year: 2020)
+
     @model = model
     @error_warning = []
     # sets sql file.

data/lib/openstudio-standards/standards/necb/common/btap_datapoint.rb

@@ -207,30 +207,7 @@ class BTAPDatapoint
         #Check if sql file was create.. if not we can't get much output.
         raise('no sql file found,simulation probably could not start due to error...see error logs.') if model.sqlFile.empty?
         # Create qaqc file and save it.
-        @qaqc = @standard.init_qaqc(model)
-        command = "SELECT Value
-                  FROM TabularDataWithStrings
-                  WHERE ReportName='LEEDsummary'
-                  AND ReportForString='Entire Facility'
-                  AND TableName='Sec1.1A-General Information'
-                  AND RowName = 'Principal Heating Source'
-                  AND ColumnName='Data'"
-        value = model.sqlFile.get.execAndReturnFirstString(command)
-        # make sure all the data are available
-        @qaqc[:building][:principal_heating_source] = 'unknown'
-        unless value.empty?
-          @qaqc[:building][:principal_heating_source] = value.get
-        end
-
-        if @qaqc[:building][:principal_heating_source] == 'Additional Fuel'
-          model.getPlantLoops.sort.each do |iplantloop|
-            boilers = iplantloop.components.select { |icomponent| icomponent.to_BoilerHotWater.is_initialized }
-            @qaqc[:building][:principal_heating_source] = 'FuelOilNo2' unless boilers.select { |boiler| boiler.to_BoilerHotWater.get.fuelType.to_s == 'FuelOilNo2' }.empty?
-          end
-        end
-
-        @qaqc[:aws_datapoint_id] = @options[:datapoint_id]
-        @qaqc[:aws_analysis_id] = @options[:analysis_id]
+        @qaqc = BTAPDatapoint.build_qaqc(model, @standard, @options[:datapoint_id], @options[:analysis_id])
 
         # Load the sql file into model
         sql_path = OpenStudio::Path.new(File.join(@run_dir, 'run/eplusout.sql'))
@@ -246,18 +223,26 @@ class BTAPDatapoint
         # Attach the sql file from the run to the sizing model
         model.setSqlFile(sql)
 
+        if @options[:enable_costing] or @options[:enable_carbon]
+          @cp = CommonPaths.instance
+          post_analysis = BTAPDatapointAnalysis.new(
+            model: model,
+            output_folder: @dp_temp_folder,
+            template: @options[:template],
+            standard: @standard,
+            qaqc: @qaqc)
+        end
+
         @cost_result = nil
         if @options[:enable_costing]
-          # Perform costing
-          costs_path = File.absolute_path(File.join(__dir__, '..','..','..','btap','costing','common_resources', 'costs.csv'))
-          local_cost_factors_path = File.absolute_path(File.join(__dir__, '..','..','..','btap','costing','common_resources', 'costs_local_factors.csv'))
-          costing = BTAPCosting.new(costs_csv: costs_path, factors_csv: local_cost_factors_path)
-          costing.load_database
-
-          @cost_result, @btap_items = costing.cost_audit_all(model: model, prototype_creator: @standard, template_type: @options[:template])
-          @qaqc[:costing_information] = @cost_result
-          File.open(File.join(@dp_temp_folder, 'cost_results.json'), 'w') { |f| f.write(JSON.pretty_generate(@cost_result, allow_nan: true)) }
-          puts "Wrote File cost_results.json in #{Dir.pwd} "
+          @cost_result = post_analysis.run_costing(
+            costs_csv: @cp.costs_path,
+            factors_csv: @cp.costs_local_factors_path)
+        end
+
+        @carbon_result = nil
+        if @options[:enable_carbon]
+          @carbon_result = post_analysis.run_carbon
         end
 
         @qaqc[:options] = @options # This is options sent on the command line
@@ -265,6 +250,7 @@ class BTAPDatapoint
         @btap_data = BTAPData.new(model: model,
                                   runner: nil,
                                   cost_result: @cost_result,
+                                  carbon_result: @carbon_result,
                                   qaqc: @qaqc,
                                   npv_start_year: @npv_start_year,
                                   npv_end_year: @npv_end_year,
@@ -309,25 +295,62 @@ class BTAPDatapoint
       # clean temp/cache folder up.
       FileUtils.rm_rf(input_folder_cache)
       FileUtils.rm_rf(@dp_temp_folder)
-      if @failed == true
+      # Do not fail container if running on AWS, handle error on AWS instead to avoid isuses with large analyses.
+      unless @failed == false || (@dp_output_folder.start_with?('s3://'))
+      #if @failed == true
         raise(@bang)
       end
     end
   end
 
+  class << self
+
+    # Initializes the qaqc data structure.
+    # Scoped inside of the class so that it can be used in the intialization of
+    # this class as well as in BTAPAnalysis.
+    def build_qaqc(model, standard, datapoint_id, analysis_id)
+      qaqc = standard.init_qaqc(model)
+      command = "SELECT Value
+                FROM TabularDataWithStrings
+                WHERE ReportName='LEEDsummary'
+                AND ReportForString='Entire Facility'
+                AND TableName='Sec1.1A-General Information'
+                AND RowName = 'Principal Heating Source'
+                AND ColumnName='Data'"
+      value = model.sqlFile.get.execAndReturnFirstString(command)
+      # make sure all the data are available
+      qaqc[:building][:principal_heating_source] = 'unknown'
+      unless value.empty?
+        qaqc[:building][:principal_heating_source] = value.get
+      end
+
+      if qaqc[:building][:principal_heating_source] == 'Additional Fuel'
+        model.getPlantLoops.sort.each do |iplantloop|
+          boilers = iplantloop.components.select { |icomponent| icomponent.to_BoilerHotWater.is_initialized }
+          qaqc[:building][:principal_heating_source] = 'FuelOilNo2' unless boilers.select { |boiler| boiler.to_BoilerHotWater.get.fuelType.to_s == 'FuelOilNo2' }.empty?
+        end
+      end
+
+      qaqc[:aws_datapoint_id] = datapoint_id
+      qaqc[:aws_analysis_id]  = analysis_id
+
+      return qaqc
+    end
+  end
+
   def s3_copy_file_to_s3(bucket_name:, source_file:, target_file:, n: 0)
-    #require 'aws-sdk-core'
-    #require 'aws-sdk-s3'
+    # require 'aws-sdk-core'
+    # require 'aws-sdk-s3'
     Aws.use_bundled_cert!
-    s3_resource = Aws::S3::Resource.new(region: 'ca-central-1')
+    s3_client = Aws::S3::Client.new(region: 'ca-central-1')
+    # Using transfer manager class instead of depricated method
+    transfer_manager = Aws::S3::TransferManager.new(client: s3_client)
 
     puts("Copying File to S3. source_file:#{source_file} bucket:#{bucket_name} target_folder:#{target_file}")
     response = nil
     begin
-      obj = s3_resource.bucket(bucket_name).object(target_file)
-
-      # passing the TempFile object's path is massively faster than passing the TempFile object itself
-      result = obj.upload_file(source_file)
+      # Using upload_file from transfer manager class instead of depricated method from older class structure
+      result = transfer_manager.upload_file(source_file, bucket: bucket_name, key: target_file)
 
       if result == true
         puts "Object '#{source_file}' uploaded to bucket '#{bucket_name}'."

data/lib/openstudio-standards/thermal_zone/{thermal_zone.rb → information.rb}

@@ -75,7 +75,7 @@ module OpenstudioStandards
         space.spaceInfiltrationDesignFlowRates.each do |infil|
           if infil.designFlowRate.is_initialized
             is_vest = true
-            OpenStudio.logFree(OpenStudio::Info, 'OpenstudioStandards::ThermalZone', "For #{thermal_zone.name}: This zone is considered a vestibule.")
+            OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.ThermalZone', "For #{thermal_zone.name}: This zone is considered a vestibule.")
             break
           end
         end
@@ -175,7 +175,7 @@ module OpenstudioStandards
             htd = true
           end
         else
-          OpenStudio.logFree(OpenStudio::Debug, 'OpenstudioStandards::ThermalZone', "Zone #{thermal_zone.name} used an unknown schedule type for the heating setpoint; assuming heated.")
+          OpenStudio.logFree(OpenStudio::Debug, 'openstudio.standards.ThermalZone', "Zone #{thermal_zone.name} used an unknown schedule type for the heating setpoint; assuming heated.")
           htd = true
         end
       end
@@ -211,7 +211,7 @@ module OpenstudioStandards
               htd = true
             end
           else
-            OpenStudio.logFree(OpenStudio::Debug, 'OpenstudioStandards::ThermalZone', "Zone #{thermal_zone.name} used an unknown schedule type for the heating setpoint; assuming heated.")
+            OpenStudio.logFree(OpenStudio::Debug, 'openstudio.standards.ThermalZone', "Zone #{thermal_zone.name} used an unknown schedule type for the heating setpoint; assuming heated.")
             htd = true
           end
         end
@@ -316,7 +316,7 @@ module OpenstudioStandards
             cld = true
           end
         else
-          OpenStudio.logFree(OpenStudio::Debug, 'OpenstudioStandards::ThermalZone', "Zone #{thermal_zone.name} used an unknown schedule type for the cooling setpoint; assuming cooled.")
+          OpenStudio.logFree(OpenStudio::Debug, 'openstudio.standards.ThermalZone', "Zone #{thermal_zone.name} used an unknown schedule type for the cooling setpoint; assuming cooled.")
           cld = true
         end
       end
@@ -352,7 +352,7 @@ module OpenstudioStandards
               cld = true
             end
           else
-            OpenStudio.logFree(OpenStudio::Debug, 'OpenstudioStandards::ThermalZone', "Zone #{thermal_zone.name} used an unknown schedule type for the cooling setpoint; assuming cooled.")
+            OpenStudio.logFree(OpenStudio::Debug, 'openstudio.standards.ThermalZone', "Zone #{thermal_zone.name} used an unknown schedule type for the cooling setpoint; assuming cooled.")
             cld = true
           end
         end
@@ -384,7 +384,7 @@ module OpenstudioStandards
     def self.thermal_zone_electric_heat?(thermal_zone)
       # error if HVACComponent heating fuels method is not available
       if thermal_zone.model.version < OpenStudio::VersionString.new('3.6.0')
-        OpenStudio.logFree(OpenStudio::Error, 'OpenstudioStandards::ThermalZone', 'Required HVACComponent method .heatingFuelTypes is not available in pre-OpenStudio 3.6.0 versions. Use a more recent version of OpenStudio.')
+        OpenStudio.logFree(OpenStudio::Error, 'openstudio.standards.ThermalZone', 'Required HVACComponent method .heatingFuelTypes is not available in pre-OpenStudio 3.6.0 versions. Use a more recent version of OpenStudio.')
       end
 
       # Get an array of the heating fuels used by the zone
@@ -404,7 +404,7 @@ module OpenstudioStandards
     def self.thermal_zone_fossil_heat?(thermal_zone)
       # error if HVACComponent heating fuels method is not available
       if thermal_zone.model.version < OpenStudio::VersionString.new('3.6.0')
-        OpenStudio.logFree(OpenStudio::Error, 'OpenstudioStandards::ThermalZone', 'Required HVACComponent method .heatingFuelTypes is not available in pre-OpenStudio 3.6.0 versions. Use a more recent version of OpenStudio.')
+        OpenStudio.logFree(OpenStudio::Error, 'openstudio.standards.ThermalZone', 'Required HVACComponent method .heatingFuelTypes is not available in pre-OpenStudio 3.6.0 versions. Use a more recent version of OpenStudio.')
       end
 
       is_fossil = false
@@ -438,7 +438,7 @@ module OpenstudioStandards
     def self.thermal_zone_district_heat?(thermal_zone)
       # error if HVACComponent heating fuels method is not available
       if thermal_zone.model.version < OpenStudio::VersionString.new('3.6.0')
-        OpenStudio.logFree(OpenStudio::Error, 'OpenstudioStandards::ThermalZone', 'Required HVACComponent method .heatingFuelTypes is not available in pre-OpenStudio 3.6.0 versions. Use a more recent version of OpenStudio.')
+        OpenStudio.logFree(OpenStudio::Error, 'openstudio.standards.ThermalZone', 'Required HVACComponent method .heatingFuelTypes is not available in pre-OpenStudio 3.6.0 versions. Use a more recent version of OpenStudio.')
       end
 
       is_district = false
@@ -467,39 +467,6 @@ module OpenstudioStandards
       return is_mixed
     end
 
-    # Adds a thermostat that heats the space to 0 F and cools to 120 F.
-    # These numbers are outside of the threshold that is considered heated
-    # or cooled by thermal_zone_cooled?() and thermal_zone_heated?()
-    #
-    # @param thermal_zone [OpenStudio::Model::ThermalZone] OpenStudio ThermalZone object
-    # @return [Boolean] returns true if successful, false if not
-    def self.thermal_zone_add_unconditioned_thermostat(thermal_zone)
-      # Heated to 0F (below thermal_zone_heated?(thermal_zone)  threshold)
-      htg_t_f = 0
-      htg_t_c = OpenStudio.convert(htg_t_f, 'F', 'C').get
-      htg_stpt_sch = OpenStudio::Model::ScheduleRuleset.new(thermal_zone.model)
-      htg_stpt_sch.setName('Unconditioned Minimal Heating')
-      htg_stpt_sch.defaultDaySchedule.setName('Unconditioned Minimal Heating Default')
-      htg_stpt_sch.defaultDaySchedule.addValue(OpenStudio::Time.new(0, 24, 0, 0), htg_t_c)
-
-      # Cooled to 120F (above thermal_zone_cooled?(thermal_zone)  threshold)
-      clg_t_f = 120
-      clg_t_c = OpenStudio.convert(clg_t_f, 'F', 'C').get
-      clg_stpt_sch = OpenStudio::Model::ScheduleRuleset.new(thermal_zone.model)
-      clg_stpt_sch.setName('Unconditioned Minimal Heating')
-      clg_stpt_sch.defaultDaySchedule.setName('Unconditioned Minimal Heating Default')
-      clg_stpt_sch.defaultDaySchedule.addValue(OpenStudio::Time.new(0, 24, 0, 0), clg_t_c)
-
-      # Thermostat
-      thermostat = OpenStudio::Model::ThermostatSetpointDualSetpoint.new(thermal_zone.model)
-      thermostat.setName("#{thermal_zone.name} Unconditioned Thermostat")
-      thermostat.setHeatingSetpointTemperatureSchedule(htg_stpt_sch)
-      thermostat.setCoolingSetpointTemperatureSchedule(clg_stpt_sch)
-      thermal_zone.setThermostatSetpointDualSetpoint(thermostat)
-
-      return true
-    end
-
     # Determine the design internal load (W) for this zone without space multipliers.
     # This include People, Lights, Electric Equipment, and Gas Equipment in all spaces in this zone.
     # It assumes 100% of the wattage is converted to heat, and that the design peak schedule value is 1 (100%).
@@ -569,7 +536,7 @@ module OpenstudioStandards
       building_type = building_type_areas.key(building_type_areas.values.max)
 
       if building_type.nil?
-        OpenStudio.logFree(OpenStudio::Info, 'OpenstudioStandards::ThermalZone', "Thermal zone #{thermal_zone.name} does not have standards building type.")
+        OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.ThermalZone', "Thermal zone #{thermal_zone.name} does not have standards building type.")
       end
 
       return building_type
@@ -687,7 +654,7 @@ module OpenstudioStandards
       # Convert to cfm
       tot_oa_flow_rate_cfm = OpenStudio.convert(tot_oa_flow_rate, 'm^3/s', 'cfm').get
 
-      OpenStudio.logFree(OpenStudio::Debug, 'openstudio.Standards.ThermalZone', "For #{thermal_zone.name}, design min OA = #{tot_oa_flow_rate_cfm.round} cfm.")
+      OpenStudio.logFree(OpenStudio::Debug, 'openstudio.standards.ThermalZone', "For #{thermal_zone.name}, design min OA = #{tot_oa_flow_rate_cfm.round} cfm.")
 
       return tot_oa_flow_rate
     end
@@ -711,7 +678,7 @@ module OpenstudioStandards
       # Calculate the per-area value
       tot_oa_flow_rate_per_area = tot_oa_flow_rate / sum_floor_area
 
-      # OpenStudio::logFree(OpenStudio::Debug, "openstudio.Standards.Model", "For #{self.name}, OA per area = #{tot_oa_flow_rate_per_area.round(8)} m^3/s*m^2.")
+      # OpenStudio::logFree(OpenStudio::Debug, "openstudio.standards.ThermalZone", "For #{self.name}, OA per area = #{tot_oa_flow_rate_per_area.round(8)} m^3/s*m^2.")
 
       return tot_oa_flow_rate_per_area
     end
@@ -776,7 +743,7 @@ module OpenstudioStandards
           new_dsn_oa.setOutdoorAirFlowRateFractionSchedule(oa_sch)
         end
 
-        OpenStudio.logFree(OpenStudio::Info, 'openstudio.Standards.ThermalZone', "For #{thermal_zone.name}: Converted total ventilation requirements to per-area value.")
+        OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.ThermalZone', "For #{thermal_zone.name}: Converted total ventilation requirements to per-area value.")
       end
 
       return true