From 504028fb0bd0f21eb36089a2f6c9d5e08f9f0334 Mon Sep 17 00:00:00 2001 From: KarenWGard <114143532+KarenWGard@users.noreply.github.com> Date: Wed, 29 May 2024 10:58:42 -0400 Subject: [PATCH 01/25] Create Rule_11-10.md --- docs/section11/Rule_11-10.md | 217 +++++++++++++++++++++++++++++++++++ 1 file changed, 217 insertions(+) create mode 100644 docs/section11/Rule_11-10.md diff --git a/docs/section11/Rule_11-10.md b/docs/section11/Rule_11-10.md new file mode 100644 index 0000000000..66ea4d59d7 --- /dev/null +++ b/docs/section11/Rule_11-10.md @@ -0,0 +1,217 @@ +# HVAC_SystemZoneAssignment - Rule 11-10 + +**Schema Version:** 0.0.36 +**Mandatory Rule:** True +**Rule ID:** 11-10 + +**Rule Description:** "The service water heating systems type in the baseline building design shall match the minimum efficiency requirements in Section 7.4.2" + +**Rule Assertion:** Options are PASS/FAIL/NOT_APPLICABLE/UNDETERMINED +**Appendix G Section Reference:** Table G3.1 #11, baseline column, a + b + +**Evaluation Context:** Each SWH bat +**Data Lookup:** +**Function Call:** + +1. get_SHW_equipment_connected_to_use_type() +2. get_SHW_types_and_SHW_use() + +**Applicability Checks:** +- Each SHW use type is applicable if there are SHW loads +- use get_SHW_equipment_associated_with_each_SWH_bat to get the SHW use types and SHW use in the building: `shw_bats_and_equip_dict = get_SHW_equipment_associated_with_each_SWH_bat(B_RMD)` + +- call the function get_SHW_types_and_SHW_use for the proposed: `shw_bat_and_use_dict_p = get_SHW_types_and_SHW_use(P_RMD)` +- look through each of the SHW bats in the building: `for shw_bat in shw_bat_and_use_dict_p:` + - check if there are SHW loads in this use type, continue to rule logic: `if len(shw_bat_and_use_dict_p[shw_bat]) > 0: CONTINUE TO RULE LOGIC` + - otherwise, rule is not applicable for this shw_bat: `else: NOT_APPLICABLE` + + + ## Rule Logic: + - create a value to track the rule status: `rule_status = "FAIL"` + - create a variable to track any notes: `rule_note = """` + - there should be one SHW Equipment for this space type: `if len(shw_types_and_use_dict[shw_bat]["SHWHeatingEq"]) != 1:` + - set rule_note to "more than one ServiceWaterHeatingEquipment" `rule_note = "more than one ServiceWaterHeatingEquipment"` + - otherwise, do the calculations to figure out of the SWH equipment meets the requirements of the rule: `else:` + - get the service water heating equipment id: `service_water_heating_equipment_id = shw_equip_dict[shw_bat]["SHWHeatingEq"]` + - we need to find the following information about the SWH: + - tank_type - (ELECTRIC_RESISTANCE_INSTANTANEOUS, ELECTRIC_RESISTANCE_STORAGE, GAS_STORAGE, OTHER) + - input_capacity (btu/hr) + - storage_volume (gallons) + - draw_pattern (VERY_SMALL, LOW, MEDIUM, or HIGH) + - capacity_per_volume (btu/hr/gallon) + - get the service water heating system: `swh_eq = get_object_by_id(service_water_heating_equipment_id,RMD)` + - get the type of service water heating system: `shw_type = swh_eq.type` + - the type will be one of the ServiceWaterHeaterTankOptions, which are more detailed than the four types we need. Determine our type based on the detailed type. + - set the type to OTHER. If the shw_type is an identifiable type, type will be overwritten to that type: `type = "OTHER"` + - if the shw_type is CONSUMER_INSTANTANEOUS, COMMERCIAL_INSTANTANEOUS, or RESIDENTIAL_DUTY_COMMERCIAL_INSTANTANEOUS, set the type to INSTANTANEOUS: `if shw_type in ["CONSUMER_INSTANTANEOUS", "COMMERCIAL_INSTANTANEOUS", "RESIDENTIAL_DUTY_COMMERCIAL_INSTANTANEOUS"]: type = "INSTANTANEOUS"` + - if the shw_type is CONSUMER_STORAGE or COMMERCIAL_STORAGE, set the type to STORAGE: `if shw_type in ["CONSUMER_STORAGE", "COMMERCIAL_STORAGE"]: type = "STORAGE"` + - get the fuel type of the equipment: `fuel_type = shw_eq.heater_fuel_type` + - set the type based on shw_type and fuel type: `if fuel_type == "ELECTRICITY":` + - `if shw_type == "INSTANTANEOUS": type = "ELECTRIC_RESISTANCE_INSTANTANEOUS"` + - `elsif shw_type == "STORAGE": type = "ELECTRIC_RESISTANCE_STORAGE"` + - `elsif fule_type == "NATURAL_GAS":` + - `if shw_type == "INSTANTANEOUS": type = "GAS_INSTANTANEOUS"` + - `elsif shw_type == "STORAGE": type = "GAS_STORAGE"` + - `elsif fule_type == "FUEL_OIL":` + - `if shw_type == "INSTANTANEOUS": type = "OIL_INSTANTANEOUS"` + - `elsif shw_type == "STORAGE": type = "OIL_STORAGE"` + - if the draw_pattern is given, get the draw pattern: `if shw_eq.draw_pattern != nil: draw_pattern = shw_eq.draw_pattern` + - otherwise, determine the draw pattern based off the first_hour_rating of the shw_eq: `else:` + - First get the first hour rating (gallons): `first_hour_rating = shw_eq.first_hour_rating` + - if the first_hour_rating is less than 18 gallons, draw_pattern is "VERY SMALL": `if first_hour_rating < 18: draw_pattern = "VERY_SMALL"` + - otherwise if the first_hour_rating is less than 51 gallons, draw pattern is LOW: `elsif first_hour_rating < 51: draw_pattern = "LOW"` + - otherwise if the first_hour_rating is less than 75 gallons, draw pattern is MEDIUM: `elsif first_hour_rating < 75: draw_pattern = "MEDIUM"` + - otherwise draw pattern is HIGH: `else: draw_pattern = "HIGH"` + - get the capacity of the SHW system (make sure to convert to btu/hr): `input_capacity = swh_eq.input_power` + - get the volume of the tank (make sure to convert to gallons): `storage_volume = swh_eq.distribution_system.tank.storage_capacity` + - calculate the capacity_per_volume based on the input_capacity and the storage_volume: `capacity_per_volume = shw_eq.rated_capacity / storage_volume` + - get the standby loss (see note 1 for calculation source): `standby_loss = swh_eq.standby_loss_fraction * 8.25 * volume * 70` + - what follows is logic that implements Table 7.8 - this table has multiple criteria, so I think it's simpler to implement with if / else logic than a table lookup + - if the type is OTHER, set rule_note to "Water heater type is not a recognized type": `if type == "OTHER": rule_note = "Water heater type is not a recognized type"` + - otherwise, continue with rule logic: `else:` + - create a boolean has_fault and set it to false: `has_fault = false` + - if the water heater is electric resistance, or storage and the capacity is <= 12kW (40945 btu/hr), then the standard doesn't cover it: `if type in ["ELECTRIC_RESISTANCE_INSTANTANEOUS", "ELECTRIC_RESISTANCE_STORAGE"] && input_capacity <= 40945.7:` + - set rule_note to: `rule_note = "Water heaters or gas pool heaters in this category or subcategory are regulated as consumer products by the USDOE as defined in 10 CFR 430."` + - set rule_status to UNDETERMINED: `rule_status = "UNDETERMINED"` + - otherwise, continue with rule logic: `else:` + - check electric storage water heaters with capacity greater than 12 kW: `if type == "ELECTRIC_RESISTANCE_STORAGE" && input_capacity > 40945.7:` + - check that the capacity_per_volume < 4000 btu/hr/gallon: `if capacity_per_volume < 4000:` + - calculate the standby loss target: `standby_loss_target = 0.3 + (27/swh_eq.distribution_system.tank.storage_volume)` + + - if the standby_loss is less than or equal to the target, set the rule_status to PASS: `if standby_loss <= standby_loss_target: rule_status: "PASS"` + - otherwise: `else:` + - set the note to indicate that the standby_loss is higher than the maximum allowed: `rule_note = "Standby Loss is higher than required by Table 7.8"` + - otherwise: `else:` + - set the note to indicate that the capacity per volume exceeds the limit: `rule_note = "Capacity per volume exceeds the limit of 4000 btu/hr/gallon for Electric Storage Water Heaters` + - check if the water heater is an instantaneous electric resistance: `if type == "ELECTRIC_RESISTANCE_INSTANTANEOUS"` + - check the capacity. If it's less than or equal to 58.6 kW (199951.5 btu/hr), check the other parameters. We don't need to check if the capacity is > 12 kW, because all systems less than 12 kW have already been checked: `if input_capacity <= 199951.5:` + - the storage capacity should be less than or equal to 2 gallons: `if storage_volume > 2:` + - set the note to read "For instantaneous Electric Water heaters, storage volume should be <= 2 gallons. ": `rule_note = "For instantaneous Electric heaters, storage volume should be <= 2 gallons. "` + - set has_fault to true: `has_fault = true` + - the setpoint temperature should be less than or equal to 180F: `if shw_eq.setpoint_temperature > 180:` + - add the following text to the note: "For instantaneous Electric Water heaters, the supply water temperature must be <= 180F": `rule_note += "For instantaneous Electric Water heaters, the supply water temperature must be <= 180F"` + - set has_fault to true: `has_fault = true` + - the capacity per volume should be >= 4000 btu/hr/gallon: `if capacity_per_volume < 4000:` + - add the following text to the note: "For instantaneous Electric Water heaters, the capacity per volume should be greater than 4000 btu/hr/gallon": `rule_note += "For instantaneous Electric Water heaters, the capacity per volume should be greater than 4000 btu/hr/gallon"` + - set has_fault to true: `has_fault = true` + - set the expected thermal efficiency to 0.8: `expected_thermal_efficiency = 0.8` + - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.thermal_efficiency >= expected_thermal_efficiency && !has_faults:` + - set rule_status to "PASS": `rule_status = "PASS"` + - otherwise: `else:` + - create a note indicating that electric resistance water heaters greater than 58.6kW are not covered in table 7.8: `rule_note: "electric resistance water heaters greater than 58.6kW are not covered in table 7.8. "` + - change rule_status to UNDETERMINED: `rule_status = "UNDETERMINED"` + - check if the water heater is gas storage: `if type == "GAS_STORAGE":` + - check if the capacity is <= 75,000 btu/hr: `if input_capacity <= 75000:` + - create a note indicating that gas storage water heaters with a capacity less than 75,000 btu/hr are not covered in table 7.8: `rule_note: "gas storage water heaters with a capacity less than 75,000 btu/hr are not covered in table 7.8. "` + - change rule_status to UNDETERMINED: `rule_status = "UNDETERMINED"` + - check if the capacity <= 105,000 btu/hr: `elsif input_capacity <= 105000:` + - the capacity per volume should be < 4000 btu/hr/gallon: `if capacity_per_volume > 4000:` + - add the following text to the note: "For Gas Storage Water heaters, the capacity per volume should be less than 4000 btu/hr/gallon": `rule_note += "For Gas Storage Water heaters, the capacity per volume should be less than 4000 btu/hr/gallon. "` + - set has_fault to true: `has_fault = true` + - the volume should be <= 120 gallons: `if storage_volume > 120:` + - add the following text to the note: "For Gas Storage Water heaters with capacity less than 105,000 btu/hr, the storage capacity is expected to be less than 120 gallons": `rule_note += "For Gas Storage Water heaters with capacity less than 105,000 btu/hr, the storage capacity is expected to be less than 120 gallons. "` + - set has_fault to true: `has_fault = true` + - the supply water temperature should be <= 180F: `if shw_eq.setpoint_temperature > 180:` + - add the following text to the note: "For Gas Storage Water heaters with capacity less than 105,000 btu/hr, the supply water temperature is expected to be <= 180F": `rule_note += "For Gas Storage Water heaters with capacity less than 105,000 btu/hr, the supply water temperature is expected to be <= 180F. "` + - set has_fault to true: `has_fault = true` + - calculate the expected efficiency for VERY_SMALL draw pattern: `if draw_pattern == "VERY_SMALL": expected_UEF = 0.2674 – (0.0009 * volume)` + - calculate the expected efficiency for LOW draw pattern: `if draw_pattern == "LOW": expected_UEF = 0.5362 – (0.0012 * volume)` + - calculate the expected efficiency for MEDIUM draw pattern: `if draw_pattern == "MEDIUM": expected_UEF = 0.6002 – (0.0011 * volume)` + - calculate the expected efficiency for HIGH draw pattern: `if draw_pattern == "HIGH": expected_UEF = 0.6597 – (0.0009 * volume)` + - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.uniform_energy_factor > expected_UEF && !has_faults:` + - set rule_status to "PASS": `rule_status = "PASS"` + - otherwise the capacity is > 105,000 btu/hr: `else:` + - the capacity per volume should be < 4000 btu/hr/gallon: `if capacity_per_volume > 4000:` + - add the following text to the note: "For Gas Storage Water heaters, the capacity per volume should be less than 4000 btu/hr/gallon": `rule_note += "For Gas Storage Water heaters, the capacity per volume should be less than 4000 btu/hr/gallon. "` + - set has_fault to true: `has_fault = true` + - calculate the expected_thermal_efficiency : `expected_thermal_efficiency = 0.8` + - calculate max_standby_loss (btu/hr): `max_standby_loss = (input_capacity/800 + 110 * sqrt(volume))` + - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.thermal_efficiency >= expected_thermal_efficiency && standby_loss <= max_standby_loss && !has_faults:` + - set rule_status to "PASS": `rule_status = "PASS"` + - check if the water heater is GAS_INSTANTANEOUS: `if type == "GAS_INSTANTANEOUS"` + - if the input capacity <= 200,000 btu/hr, this equipment isn't covered by ASHRAE: `if input_capacity <= 200000:` + - add the following text to the note: "Gas Instantaneous Water heaters with capacity < 200,000 btu/hr are not covered by table 7.8": `rule_note += "Gas Instantaneous Water heaters with capacity < 200,000 btu/hr are not covered by table 7.8. "` + - set rule_status to "UNDETERMINED": `rule_status = "UNDETERMINED"` + - otherwise, if the storage volume is less than 10 gallons: `if volume < 10:` + - set expected thermal efficiency to 80%: `expected_thermal_efficiency = 0.8` + - the capacity per volume should be >= 4000 btu/hr/gallon: `if capacity_per_volume < 4000:` + - add the following text to the note: "For Gas Instantaneous heaters, the capacity per volume should be greater than 4000 btu/hr/gallon": `rule_note += "For Gas Instantaneous Water heaters, the capacity per volume should be greater than 4000 btu/hr/gallon. "` + - set has_fault to true: `has_fault = true` + - if the thermal efficiency is greater than or equal to the expected: `if shw_eq.thermal_efficiency >= expected_thermal_efficiency && !has_faults:` + - set rule_status to "PASS": `rule_status = "PASS"` + - otherwise, the storage volume is greater than 10 gallons: `else:` + - set expected thermal efficiency to 80%: `expected_thermal_efficiency = 0.8` + - calculate the max_standby_loss: `max_standby_loss = (input_capacity/800 + 110 * sqrt(volume))` + - the capacity per volume should be >= 4000 btu/hr/gallon: `if capacity_per_volume < 4000:` + - add the following text to the note: "For Gas Instantaneous heaters, the capacity per volume should be greater than 4000 btu/hr/gallon": `rule_note += "For Gas Instantaneous Water heaters, the capacity per volume should be greater than 4000 btu/hr/gallon. "` + - set has_fault to true: `has_fault = true` + - if the thermal efficiency is greater than or equal to the expected: `if shw_eq.thermal_efficiency >= expected_thermal_efficiency && standby_loss <= max_standby_loss && !has_faults:` + - set rule_status to "PASS": `rule_status = "PASS"` + - check if the water heater is OIL_STORAGE: `elsif type == "OIL_STORAGE` + - if the input capacity < 105,000 btu/hr, this equipment isn't covered by ASHRAE: `if input_capacity < 105000:` + - add the following text to the note: "Oil Storage Water heaters with capacity < 105,000 btu/hr are not covered by table 7.8": `rule_note += "Oil Storage Water heaters with capacity < 105,000 btu/hr are not covered by table 7.8. "` + - set rule_status to "UNDETERMINED": `rule_status = "UNDETERMINED"` + - else if the input capacity is < 140,000 btu/hr: `elif input_capacity < 140000:` + - calculate the expected efficiency for VERY_SMALL draw pattern: `if draw_pattern == "VERY_SMALL": expected_UEF = 0.2932 – (0.0015 * volume)` + - calculate the expected efficiency for LOW draw pattern: `if draw_pattern == "LOW": expected_UEF = 0.5596 – (0.0018 * volume)` + - calculate the expected efficiency for MEDIUM draw pattern: `if draw_pattern == "MEDIUM": expected_UEF = 0.6194 – (0.0016 * volume)` + - calculate the expected efficiency for HIGH draw pattern: `if draw_pattern == "HIGH": expected_UEF = 0.6740 – (0.0013 * volume)` + - check that the storage volume is <= 120 gallons: `if volume > 120 gallons:` + - add the following text to the note: "For Oil Storage heaters, with capacity < 140,000 btu/hr, the storage volume should be <= 120 gallons.": `rule_note += "For Oil Storage heaters, with capacity < 140,000 btu/hr, the storage volume should be <= 120 gallons. "` + - set has_fault to true: `has_fault = true` + - the capacity per volume should be < 4000 btu/hr/gallon: `if capacity_per_volume >= 4000:` + - add the following text to the note: "For Oil Storage heaters, with capacity < 140,000 btu/hr, the capacity per volume should be < 4000 btu/hr/gallon.": `rule_note += "For Oil Storage heaters, with capacity < 140,000 btu/hr, the capacity per volume should be < 4000 btu/hr/gallon. "` + - set has_fault to true: `has_fault = true` + - the setpoint temperature should be less than or equal to 180F: `if shw_eq.setpoint_temperature > 180:` + - add the following text to the note: "For Oil Storage Water heaters, the supply water temperature must be <= 180F": `rule_note += "For Oil Storage Water heaters, the supply water temperature must be <= 180F"` + - set has_fault to true: `has_fault = true` + - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.uniform_energy_factor > expected_UEF && !has_faults:` + - set rule_status to "PASS": `rule_status = "PASS"` + - else the input capacity is >= 140,000 btu/hr: `else:` + - the capacity per volume should be < 4000 btu/hr/gallon: `if capacity_per_volume >= 4000:` + - add the following text to the note: "For Oil Storage heaters, with capacity > 140,000 btu/hr, the capacity per volume should be < 4000 btu/hr/gallon.": `rule_note += "For Oil Storage heaters, with capacity < 140,000 btu/hr, the capacity per volume should be < 4000 btu/hr/gallon. "` + - set has_fault to true: `has_fault = true` + - set the expected thermal efficiency to 0.8: `expected_thermal_efficiency = 0.8` + - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.thermal_efficiency >= expected_thermal_efficiency && !has_faults:` + - set rule_status to "PASS": `rule_status = "PASS"` + - check if the water heater is OIL_INSTANTANEOUS: `elsif type == "OIL_INSTANTANEOUS` + - the capacity per volume should be >= 4000 btu/hr/gallon: `if capacity_per_volume < 4000:` + - add the following text to the note: "For Oil Instantaneous water heaters the capacity per volume should be > 4000 btu/hr/gallon.": `rule_note += "For Oil Instantaneous water heaters the capacity per volume should be > 4000 btu/hr/gallon. "` + - set has_fault to true: `has_fault = true` + - if the input capacity <= 210,000 btu/hr: `if input_capacity <= 210000:` + - check that the storage volume is < 2 gallons: `if volume >= 2 gallons:` + - add the following text to the note: "For Oil Instantaneous Water heaters, with capacity <= 210,000 btu/hr, the storage volume should be < 2 gallons.": `rule_note += "For Oil Instantaneous Water heaters, with capacity <= 210,000 btu/hr, the storage volume should be < 2 gallons. "` + - set has_fault to true: `has_fault = true` + - set the expected thermal efficiency to 0.8: `expected_thermal_efficiency = 0.8` + - calculate the Energy Factor: `expected_energy_factor = 0.59 – 0.0005 * volume` + - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.thermal_efficiency >= expected_thermal_efficiency && shw_eq.energy_factor >= expected_energy_factor && !has_faults:` + - set rule_status to "PASS": `rule_status = "PASS"` + - else the input capacity is > 210,000 btu/hr: `else:` + - if the storage volume is < 10 gallons: `if volume < 10:` + - set the expected thermal efficiency to 0.8: `expected_thermal_efficiency = 0.8` + - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.thermal_efficiency >= expected_thermal_efficiency && !has_faults:` + - set rule_status to "PASS": `rule_status = "PASS"` + - else the storage volume is >= 10 gallons: `else:` + - set the expected thermal efficiency to 0.8: `expected_thermal_efficiency = 0.78` + - calculate max_standby_loss (btu/hr): `max_standby_loss = (input_capacity/800 + 110 * sqrt(volume))` + - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.thermal_efficiency >= expected_thermal_efficiency && standby_loss <= max_standby_loss && !has_faults:` + - set rule_status to "PASS": `rule_status = "PASS"` + + **Rule Assertion - Zone:** + - Case1: rule_status is PASS: `if rule_status == "PASS": PASS`. + - Case2: rule_status is UNDETERMINED, UNDETERMINED & return rule_note: `elsif rule_status == "UNDETERMINED": UNDETERMINED; rule_note` + - Case3: rule_status is FAIL, FAIL & return rule_note: `elsif rule_status == "FAIL": FAIL; rule_note` + + +**Notes:** + +1. standby loss calculated based on https://www.energy.ca.gov/sites/default/files/2021-11/CBECC-Res_UserManual_2019.2.0_ada.pdf 9.6.4.8 +2. what category to use of fuel type is Propane? Gas or Oil? +3. how to calculate the subcategory or rating condition (btu/hr/gallon) to confirm that this requirement is met? +4. draw_pattern - not currently included in the schema, but could be inferred from first_hour_rating based on Table I on page 9: https://www.govinfo.gov/content/pkg/CFR-2016-title10-vol3/pdf/CFR-2016-title10-vol3-part430-subpartB-appE.pdf +5. Would the exception to 7.4.2 ever be applicable to a baseline system? The exceptions is: "All water heaters and hot-water supply boilers having more than 140 gal of storage capacity are not required to meet the standby loss (SL) requirements of Table 7.8 when + 1. the tank surface is thermally insulated to R-12.5, + 2. a standing pilot light is not installed, and + 3. gas- or oil-fired storage water heaters have a flue damper or fan-assisted combustion. + +**[Back](../_toc.md)** From 7f7ebd534e110688bea55bae79ddfd45cb11ef2c Mon Sep 17 00:00:00 2001 From: KarenWGard <114143532+KarenWGard@users.noreply.github.com> Date: Wed, 29 May 2024 15:27:14 -0400 Subject: [PATCH 02/25] Update Rule_11-10.md --- docs/section11/Rule_11-10.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/section11/Rule_11-10.md b/docs/section11/Rule_11-10.md index 66ea4d59d7..850899469d 100644 --- a/docs/section11/Rule_11-10.md +++ b/docs/section11/Rule_11-10.md @@ -209,7 +209,7 @@ 2. what category to use of fuel type is Propane? Gas or Oil? 3. how to calculate the subcategory or rating condition (btu/hr/gallon) to confirm that this requirement is met? 4. draw_pattern - not currently included in the schema, but could be inferred from first_hour_rating based on Table I on page 9: https://www.govinfo.gov/content/pkg/CFR-2016-title10-vol3/pdf/CFR-2016-title10-vol3-part430-subpartB-appE.pdf -5. Would the exception to 7.4.2 ever be applicable to a baseline system? The exceptions is: "All water heaters and hot-water supply boilers having more than 140 gal of storage capacity are not required to meet the standby loss (SL) requirements of Table 7.8 when +5. This question was discussed on 5/29/2024 and agreed that this exception wouldn't be triggered by a baseline system. Original question: Would the exception to 7.4.2 ever be applicable to a baseline system? The exceptions is: "All water heaters and hot-water supply boilers having more than 140 gal of storage capacity are not required to meet the standby loss (SL) requirements of Table 7.8 when 1. the tank surface is thermally insulated to R-12.5, 2. a standing pilot light is not installed, and 3. gas- or oil-fired storage water heaters have a flue damper or fan-assisted combustion. From e3d4e216c55a825ec6129dc410677d2feb9f8508 Mon Sep 17 00:00:00 2001 From: KarenWGard <114143532+KarenWGard@users.noreply.github.com> Date: Wed, 5 Jun 2024 14:10:36 -0400 Subject: [PATCH 03/25] Update Rule_11-10.md --- docs/section11/Rule_11-10.md | 118 +++++++++++++++++++++++++++-------- 1 file changed, 93 insertions(+), 25 deletions(-) diff --git a/docs/section11/Rule_11-10.md b/docs/section11/Rule_11-10.md index 850899469d..0ba48898ab 100644 --- a/docs/section11/Rule_11-10.md +++ b/docs/section11/Rule_11-10.md @@ -35,26 +35,28 @@ - get the service water heating equipment id: `service_water_heating_equipment_id = shw_equip_dict[shw_bat]["SHWHeatingEq"]` - we need to find the following information about the SWH: - tank_type - (ELECTRIC_RESISTANCE_INSTANTANEOUS, ELECTRIC_RESISTANCE_STORAGE, GAS_STORAGE, OTHER) + - swh_type - one of the - input_capacity (btu/hr) - storage_volume (gallons) - draw_pattern (VERY_SMALL, LOW, MEDIUM, or HIGH) - capacity_per_volume (btu/hr/gallon) - get the service water heating system: `swh_eq = get_object_by_id(service_water_heating_equipment_id,RMD)` - - get the type of service water heating system: `shw_type = swh_eq.type` + - get the type of tank: `tank_type = swh_eq.tank.type` + - get the type of heater: `swh_type = swh_eq.heater_type` - the type will be one of the ServiceWaterHeaterTankOptions, which are more detailed than the four types we need. Determine our type based on the detailed type. - - set the type to OTHER. If the shw_type is an identifiable type, type will be overwritten to that type: `type = "OTHER"` - - if the shw_type is CONSUMER_INSTANTANEOUS, COMMERCIAL_INSTANTANEOUS, or RESIDENTIAL_DUTY_COMMERCIAL_INSTANTANEOUS, set the type to INSTANTANEOUS: `if shw_type in ["CONSUMER_INSTANTANEOUS", "COMMERCIAL_INSTANTANEOUS", "RESIDENTIAL_DUTY_COMMERCIAL_INSTANTANEOUS"]: type = "INSTANTANEOUS"` - - if the shw_type is CONSUMER_STORAGE or COMMERCIAL_STORAGE, set the type to STORAGE: `if shw_type in ["CONSUMER_STORAGE", "COMMERCIAL_STORAGE"]: type = "STORAGE"` + - set the type to OTHER. If the tank_type is an identifiable type, type will be overwritten to that type: `type = "OTHER"` + - if the tank_type is CONSUMER_INSTANTANEOUS, COMMERCIAL_INSTANTANEOUS, or RESIDENTIAL_DUTY_COMMERCIAL_INSTANTANEOUS, set the type to INSTANTANEOUS: `if tank_type in ["CONSUMER_INSTANTANEOUS", "COMMERCIAL_INSTANTANEOUS", "RESIDENTIAL_DUTY_COMMERCIAL_INSTANTANEOUS"]: type = "INSTANTANEOUS"` + - if the tank_type is CONSUMER_STORAGE or COMMERCIAL_STORAGE, set the type to STORAGE: `if tank_type in ["CONSUMER_STORAGE", "COMMERCIAL_STORAGE"]: type = "STORAGE"` - get the fuel type of the equipment: `fuel_type = shw_eq.heater_fuel_type` - - set the type based on shw_type and fuel type: `if fuel_type == "ELECTRICITY":` - - `if shw_type == "INSTANTANEOUS": type = "ELECTRIC_RESISTANCE_INSTANTANEOUS"` - - `elsif shw_type == "STORAGE": type = "ELECTRIC_RESISTANCE_STORAGE"` + - set the type based on tank_type and fuel type: `if fuel_type == "ELECTRICITY":` + - `if tank_type == "INSTANTANEOUS": type = "ELECTRIC_RESISTANCE_INSTANTANEOUS"` + - `elsif tank_type == "STORAGE": type = "ELECTRIC_RESISTANCE_STORAGE"` - `elsif fule_type == "NATURAL_GAS":` - - `if shw_type == "INSTANTANEOUS": type = "GAS_INSTANTANEOUS"` - - `elsif shw_type == "STORAGE": type = "GAS_STORAGE"` + - `if tank_type == "INSTANTANEOUS": type = "GAS_INSTANTANEOUS"` + - `elsif tank_type == "STORAGE": type = "GAS_STORAGE"` - `elsif fule_type == "FUEL_OIL":` - - `if shw_type == "INSTANTANEOUS": type = "OIL_INSTANTANEOUS"` - - `elsif shw_type == "STORAGE": type = "OIL_STORAGE"` + - `if tank_type == "INSTANTANEOUS": type = "OIL_INSTANTANEOUS"` + - `elsif tank_type == "STORAGE": type = "OIL_STORAGE"` - if the draw_pattern is given, get the draw pattern: `if shw_eq.draw_pattern != nil: draw_pattern = shw_eq.draw_pattern` - otherwise, determine the draw pattern based off the first_hour_rating of the shw_eq: `else:` - First get the first hour rating (gallons): `first_hour_rating = shw_eq.first_hour_rating` @@ -70,14 +72,26 @@ - if the type is OTHER, set rule_note to "Water heater type is not a recognized type": `if type == "OTHER": rule_note = "Water heater type is not a recognized type"` - otherwise, continue with rule logic: `else:` - create a boolean has_fault and set it to false: `has_fault = false` - - if the water heater is electric resistance, or storage and the capacity is <= 12kW (40945 btu/hr), then the standard doesn't cover it: `if type in ["ELECTRIC_RESISTANCE_INSTANTANEOUS", "ELECTRIC_RESISTANCE_STORAGE"] && input_capacity <= 40945.7:` - - set rule_note to: `rule_note = "Water heaters or gas pool heaters in this category or subcategory are regulated as consumer products by the USDOE as defined in 10 CFR 430."` - - set rule_status to UNDETERMINED: `rule_status = "UNDETERMINED"` + - if the water heater is electric resistance, or storage and the capacity is <= 12kW (40945 btu/hr), look at Appendix F: `if type in ["ELECTRIC_RESISTANCE_INSTANTANEOUS", "ELECTRIC_RESISTANCE_STORAGE"] && input_capacity <= 40945.7:` + - check the size of the storage tank. If it's less than 2 gallons, then it qualifies as an instantaneous electric water heater: `if storage_volume < 2:` + - if the draw pattern is HIGH, the expected UEF is 0.92, for draw all draw patterns other draw patterns, it is 0.91: `if draw_pattern == "HIGH": expected_UEF = 0.92; else: expected_UEF = 0.91` + - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.uniform_energy_factor >= expected_UEF:` + - set rule_status to "PASS": `rule_status = "PASS"` + - otherwise, set rule status to FAIL and provide the note that the expected UEF is less than the required UEF: `else: rule_status = "FAIL"; rule_note = "The modeled Uniform energy Factor (UEF - " + shw_eq.uniform_energy_factor + ") is less than required (" + expected_UEF + ")"` + - else, if the storage tank is is between 20 and 55 gallons, this is considered an electric storage water heater in Appendix F: `elsif storage_volume >= 20 && storage_volume <= 55:` + - determine the UEF based on the draw pattern for VERY_SMALL: `if draw_pattern == "VERY_SMALL": expected_uef = 0.8808 – (0.0008 × storage_volume)` + - determine the UEF based on the draw pattern for LOW: `if draw_pattern == "LOW": expected_uef = 0.9254 – (0.0003 × storage_volume)` + - determine the UEF based on the draw pattern for MEDIUM: `if draw_pattern == "MEDIUM": expected_uef = 0.9307 – (0.0002 × storage_volume)` + - determine the UEF based on the draw pattern for HIGH: `if draw_pattern == "HIGH": expected_uef = 0.9349 – (0.0001 × storage_volume)` + - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.uniform_energy_factor >= expected_UEF:` + - set rule_status to "PASS": `rule_status = "PASS"` + - otherwise, set rule status to FAIL and provide the note that the expected UEF is less than the required UEF: `else: rule_status = "FAIL"; rule_note = "The modeled Uniform energy Factor (UEF - " + shw_eq.uniform_energy_factor + ") is less than required (" + expected_UEF + ")"` + - else, if the storage tank is greater than 55 and less than 100 gallons, Appendix F provides a heat pump efficiency, or the storage volume is between 2 and 20 gallons, in which case there is no rating in APPENDIX F. return UNDETERMINED: `else:` + - set rule_status to UNDETERMINED: `rule_status = "UNDETERMINED"` - otherwise, continue with rule logic: `else:` - check electric storage water heaters with capacity greater than 12 kW: `if type == "ELECTRIC_RESISTANCE_STORAGE" && input_capacity > 40945.7:` - check that the capacity_per_volume < 4000 btu/hr/gallon: `if capacity_per_volume < 4000:` - calculate the standby loss target: `standby_loss_target = 0.3 + (27/swh_eq.distribution_system.tank.storage_volume)` - - if the standby_loss is less than or equal to the target, set the rule_status to PASS: `if standby_loss <= standby_loss_target: rule_status: "PASS"` - otherwise: `else:` - set the note to indicate that the standby_loss is higher than the maximum allowed: `rule_note = "Standby Loss is higher than required by Table 7.8"` @@ -102,8 +116,30 @@ - change rule_status to UNDETERMINED: `rule_status = "UNDETERMINED"` - check if the water heater is gas storage: `if type == "GAS_STORAGE":` - check if the capacity is <= 75,000 btu/hr: `if input_capacity <= 75000:` - - create a note indicating that gas storage water heaters with a capacity less than 75,000 btu/hr are not covered in table 7.8: `rule_note: "gas storage water heaters with a capacity less than 75,000 btu/hr are not covered in table 7.8. "` - - change rule_status to UNDETERMINED: `rule_status = "UNDETERMINED"` + - look to see if the water heater is covered in Appendix F, first look to see if it is an instantaneous water heater (anything less than 2 gallons of storage): `if storage_volume < 2:` + - if the draw pattern is HIGH, the expected UEF is 0.92, for draw all draw patterns other draw patterns, it is 0.91: `if draw_pattern == "HIGH": expected_UEF = 0.92; else: expected_UEF = 0.91` + - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.uniform_energy_factor >= expected_UEF:` + - set rule_status to "PASS": `rule_status = "PASS"` + - otherwise, set rule status to FAIL and provide the note that the expected UEF is less than the required UEF: `else: rule_status = "FAIL"; rule_note = "The modeled Uniform energy Factor (UEF - " + shw_eq.uniform_energy_factor + ") is less than required (" + expected_UEF + ")"` + - otherwise, if the storage volume is between 20 and 55 gallons: `elsif storage_volume >= 20 && storage_volume <= 55:` + - determine the UEF based on the draw pattern for VERY_SMALL: `if draw_pattern == "VERY_SMALL": expected_uef = 0.3456 – (0.0020 × storage_volume)` + - determine the UEF based on the draw pattern for LOW: `if draw_pattern == "LOW": expected_uef = 0.5982 – (0.0019 × storage_volume)` + - determine the UEF based on the draw pattern for MEDIUM: `if draw_pattern == "MEDIUM": expected_uef = 0.6483 – (0.0017 × storage_volume)` + - determine the UEF based on the draw pattern for HIGH: `if draw_pattern == "HIGH": expected_uef = 0.6920 – (0.0013 × storage_volume)` + - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.uniform_energy_factor >= expected_UEF:` + - set rule_status to "PASS": `rule_status = "PASS"` + - otherwise, set rule status to FAIL and provide the note that the expected UEF is less than the required UEF: `else: rule_status = "FAIL"; rule_note = "The modeled Uniform energy Factor (UEF - " + shw_eq.uniform_energy_factor + ") is less than required (" + expected_UEF + ")"` + - otherwise, if the storage volume is between 55 and 100 gallons: `elif storage_volume <= 100:` + - determine the UEF based on the draw pattern for VERY_SMALL: `if draw_pattern == "VERY_SMALL": expected_uef = 0.6470 – (0.0006 × storage_volume)` + - determine the UEF based on the draw pattern for LOW: `if draw_pattern == "LOW": expected_uef = 0.7689 – (0.0005 × storage_volume)` + - determine the UEF based on the draw pattern for MEDIUM: `if draw_pattern == "MEDIUM": expected_uef = 0.7897 – (0.0004 × storage_volume)` + - determine the UEF based on the draw pattern for HIGH: `if draw_pattern == "HIGH": expected_uef = 0.8072 – (0.0003 × storage_volume)` + - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.uniform_energy_factor >= expected_UEF:` + - set rule_status to "PASS": `rule_status = "PASS"` + - otherwise, set rule status to FAIL and provide the note that the expected UEF is less than the required UEF: `else: rule_status = "FAIL"; rule_note = "The modeled Uniform energy Factor (UEF - " + shw_eq.uniform_energy_factor + ") is less than required (" + expected_UEF + ")"` + - otherwise, the storage volume is either greater than 100 gallons, or between 2 and 20, which is not covered by Appendix F: `else:` + - create a note indicating that gas water heaters greater with input capacity < 75,000 btu/hr and the given storage volume are not covered under Appendix F: `rule_note: "Gas water heaters with an input capacity < 75,000 btu/hr and a storage capacity of " + storage_volume + " are not covered under Appendix F"` + - change rule_status to UNDETERMINED: `rule_status = "UNDETERMINED"` - check if the capacity <= 105,000 btu/hr: `elsif input_capacity <= 105000:` - the capacity per volume should be < 4000 btu/hr/gallon: `if capacity_per_volume > 4000:` - add the following text to the note: "For Gas Storage Water heaters, the capacity per volume should be less than 4000 btu/hr/gallon": `rule_note += "For Gas Storage Water heaters, the capacity per volume should be less than 4000 btu/hr/gallon. "` @@ -118,7 +154,7 @@ - calculate the expected efficiency for LOW draw pattern: `if draw_pattern == "LOW": expected_UEF = 0.5362 – (0.0012 * volume)` - calculate the expected efficiency for MEDIUM draw pattern: `if draw_pattern == "MEDIUM": expected_UEF = 0.6002 – (0.0011 * volume)` - calculate the expected efficiency for HIGH draw pattern: `if draw_pattern == "HIGH": expected_UEF = 0.6597 – (0.0009 * volume)` - - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.uniform_energy_factor > expected_UEF && !has_faults:` + - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.uniform_energy_factor >= expected_UEF && !has_faults:` - set rule_status to "PASS": `rule_status = "PASS"` - otherwise the capacity is > 105,000 btu/hr: `else:` - the capacity per volume should be < 4000 btu/hr/gallon: `if capacity_per_volume > 4000:` @@ -129,9 +165,32 @@ - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.thermal_efficiency >= expected_thermal_efficiency && standby_loss <= max_standby_loss && !has_faults:` - set rule_status to "PASS": `rule_status = "PASS"` - check if the water heater is GAS_INSTANTANEOUS: `if type == "GAS_INSTANTANEOUS"` - - if the input capacity <= 200,000 btu/hr, this equipment isn't covered by ASHRAE: `if input_capacity <= 200000:` - - add the following text to the note: "Gas Instantaneous Water heaters with capacity < 200,000 btu/hr are not covered by table 7.8": `rule_note += "Gas Instantaneous Water heaters with capacity < 200,000 btu/hr are not covered by table 7.8. "` - - set rule_status to "UNDETERMINED": `rule_status = "UNDETERMINED"` + - if the input capacity <= 200,000 btu/hr, this equipment is covered in Appendix F: `if input_capacity <= 200000:` + - look to see if the water heater is covered in Appendix F, first look to see if it is an instantaneous water heater (anything less than 2 gallons of storage): `if storage_volume < 2:` + - if the draw pattern is HIGH, the expected UEF is 0.92, for draw all draw patterns other draw patterns, it is 0.91: `if draw_pattern == "HIGH": expected_UEF = 0.92; else: expected_UEF = 0.91` + - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.uniform_energy_factor >= expected_UEF:` + - set rule_status to "PASS": `rule_status = "PASS"` + - otherwise, set rule status to FAIL and provide the note that the expected UEF is less than the required UEF: `else: rule_status = "FAIL"; rule_note = "The modeled Uniform energy Factor (UEF - " + shw_eq.uniform_energy_factor + ") is less than required (" + expected_UEF + ")"` + - otherwise, if the storage volume is between 20 and 55 gallons: `elsif storage_volume >= 20 && storage_volume <= 55:` + - determine the UEF based on the draw pattern for VERY_SMALL: `if draw_pattern == "VERY_SMALL": expected_uef = 0.3456 – (0.0020 × storage_volume)` + - determine the UEF based on the draw pattern for LOW: `if draw_pattern == "LOW": expected_uef = 0.5982 – (0.0019 × storage_volume)` + - determine the UEF based on the draw pattern for MEDIUM: `if draw_pattern == "MEDIUM": expected_uef = 0.6483 – (0.0017 × storage_volume)` + - determine the UEF based on the draw pattern for HIGH: `if draw_pattern == "HIGH": expected_uef = 0.6920 – (0.0013 × storage_volume)` + - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.uniform_energy_factor >= expected_UEF:` + - set rule_status to "PASS": `rule_status = "PASS"` + - otherwise, set rule status to FAIL and provide the note that the expected UEF is less than the required UEF: `else: rule_status = "FAIL"; rule_note = "The modeled Uniform energy Factor (UEF - " + shw_eq.uniform_energy_factor + ") is less than required (" + expected_UEF + ")"` + - otherwise, if the storage volume is between 55 and 100 gallons: `elif storage_volume <= 100:` + - determine the UEF based on the draw pattern for VERY_SMALL: `if draw_pattern == "VERY_SMALL": expected_uef = 0.6470 – (0.0006 × storage_volume)` + - determine the UEF based on the draw pattern for LOW: `if draw_pattern == "LOW": expected_uef = 0.7689 – (0.0005 × storage_volume)` + - determine the UEF based on the draw pattern for MEDIUM: `if draw_pattern == "MEDIUM": expected_uef = 0.7897 – (0.0004 × storage_volume)` + - determine the UEF based on the draw pattern for HIGH: `if draw_pattern == "HIGH": expected_uef = 0.8072 – (0.0003 × storage_volume)` + - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.uniform_energy_factor >= expected_UEF:` + - set rule_status to "PASS": `rule_status = "PASS"` + - otherwise, set rule status to FAIL and provide the note that the expected UEF is less than the required UEF: `else: rule_status = "FAIL"; rule_note = "The modeled Uniform energy Factor (UEF - " + shw_eq.uniform_energy_factor + ") is less than required (" + expected_UEF + ")"` + - otherwise, the storage volume is either greater than 100 gallons, or between 2 and 20, which is not covered by Appendix F: `else:` + - create a note indicating that gas water heaters greater with input capacity < 75,000 btu/hr and the given storage volume are not covered under Appendix F: `rule_note: "Gas water heaters with an input capacity < 75,000 btu/hr and a storage capacity of " + storage_volume + " are not covered under Appendix F"` + - change rule_status to UNDETERMINED: `rule_status = "UNDETERMINED"` + - otherwise, if the storage volume is less than 10 gallons: `if volume < 10:` - set expected thermal efficiency to 80%: `expected_thermal_efficiency = 0.8` - the capacity per volume should be >= 4000 btu/hr/gallon: `if capacity_per_volume < 4000:` @@ -148,9 +207,18 @@ - if the thermal efficiency is greater than or equal to the expected: `if shw_eq.thermal_efficiency >= expected_thermal_efficiency && standby_loss <= max_standby_loss && !has_faults:` - set rule_status to "PASS": `rule_status = "PASS"` - check if the water heater is OIL_STORAGE: `elsif type == "OIL_STORAGE` - - if the input capacity < 105,000 btu/hr, this equipment isn't covered by ASHRAE: `if input_capacity < 105000:` - - add the following text to the note: "Oil Storage Water heaters with capacity < 105,000 btu/hr are not covered by table 7.8": `rule_note += "Oil Storage Water heaters with capacity < 105,000 btu/hr are not covered by table 7.8. "` - - set rule_status to "UNDETERMINED": `rule_status = "UNDETERMINED"` + - if the input capacity < 105,000 btu/hr, this equipment is covered under Appendix F: `if input_capacity < 105000:` + - look to see if the water heater is covered in Appendix F, first look to see if it is an instantaneous water heater (anything less than 50 gallons of storage): `if storage_volume < 50:` + - determine the UEF based on the draw pattern for VERY_SMALL: `if draw_pattern == "VERY_SMALL": expected_uef = 0.2509 – (0.0012 × storage_volume)` + - determine the UEF based on the draw pattern for LOW: `if draw_pattern == "LOW": expected_uef = 0.5330 – (0.0016 × storage_volume)` + - determine the UEF based on the draw pattern for MEDIUM: `if draw_pattern == "MEDIUM": expected_uef = 0.6078 – (0.0016 × storage_volume)` + - determine the UEF based on the draw pattern for HIGH: `if draw_pattern == "HIGH": expected_uef = 0.6815 – (0.0014 × storage_volume)` + - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.uniform_energy_factor >= expected_UEF:` + - set rule_status to "PASS": `rule_status = "PASS"` + - otherwise, set rule status to FAIL and provide the note that the expected UEF is less than the required UEF: `else: rule_status = "FAIL"; rule_note = "The modeled Uniform energy Factor (UEF - " + shw_eq.uniform_energy_factor + ") is less than required (" + expected_UEF + ")"` + - otherwise, the storage volume is greater 50 gallons and is not covered by Appendix F: `else:` + - create a note indicating that gas water heaters with storage volume greater than 50 gallons are not covered under Appendix F: `rule_note: "Gas water heaters with a storage volume greater than 50 gallons are not covered under Appendix F"` + - change rule_status to UNDETERMINED: `rule_status = "UNDETERMINED"` - else if the input capacity is < 140,000 btu/hr: `elif input_capacity < 140000:` - calculate the expected efficiency for VERY_SMALL draw pattern: `if draw_pattern == "VERY_SMALL": expected_UEF = 0.2932 – (0.0015 * volume)` - calculate the expected efficiency for LOW draw pattern: `if draw_pattern == "LOW": expected_UEF = 0.5596 – (0.0018 * volume)` @@ -165,7 +233,7 @@ - the setpoint temperature should be less than or equal to 180F: `if shw_eq.setpoint_temperature > 180:` - add the following text to the note: "For Oil Storage Water heaters, the supply water temperature must be <= 180F": `rule_note += "For Oil Storage Water heaters, the supply water temperature must be <= 180F"` - set has_fault to true: `has_fault = true` - - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.uniform_energy_factor > expected_UEF && !has_faults:` + - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.uniform_energy_factor >= expected_UEF && !has_faults:` - set rule_status to "PASS": `rule_status = "PASS"` - else the input capacity is >= 140,000 btu/hr: `else:` - the capacity per volume should be < 4000 btu/hr/gallon: `if capacity_per_volume >= 4000:` From 8f86edfa7856a91f6ca2735203f8c27e11a92bbb Mon Sep 17 00:00:00 2001 From: KarenWGard <114143532+KarenWGard@users.noreply.github.com> Date: Wed, 19 Jun 2024 14:32:49 -0400 Subject: [PATCH 04/25] Update Rule_11-10.md --- docs/section11/Rule_11-10.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/section11/Rule_11-10.md b/docs/section11/Rule_11-10.md index 0ba48898ab..1bd780b3c2 100644 --- a/docs/section11/Rule_11-10.md +++ b/docs/section11/Rule_11-10.md @@ -1,4 +1,4 @@ -# HVAC_SystemZoneAssignment - Rule 11-10 +s# HVAC_SystemZoneAssignment - Rule 11-10 **Schema Version:** 0.0.36 **Mandatory Rule:** True @@ -29,7 +29,7 @@ ## Rule Logic: - create a value to track the rule status: `rule_status = "FAIL"` - create a variable to track any notes: `rule_note = """` - - there should be one SHW Equipment for this space type: `if len(shw_types_and_use_dict[shw_bat]["SHWHeatingEq"]) != 1:` + - there should be one SHW Equipment for this BAT: `if len(shw_types_and_use_dict[shw_bat]["SHWHeatingEq"]) != 1:` - set rule_note to "more than one ServiceWaterHeatingEquipment" `rule_note = "more than one ServiceWaterHeatingEquipment"` - otherwise, do the calculations to figure out of the SWH equipment meets the requirements of the rule: `else:` - get the service water heating equipment id: `service_water_heating_equipment_id = shw_equip_dict[shw_bat]["SHWHeatingEq"]` From 86a784a299c72374f731c1d4a3c6401947f1cbec Mon Sep 17 00:00:00 2001 From: KarenWGard <114143532+KarenWGard@users.noreply.github.com> Date: Wed, 19 Jun 2024 14:33:48 -0400 Subject: [PATCH 05/25] Update Rule_11-10.md --- docs/section11/Rule_11-10.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/docs/section11/Rule_11-10.md b/docs/section11/Rule_11-10.md index 1bd780b3c2..b69aa4e36b 100644 --- a/docs/section11/Rule_11-10.md +++ b/docs/section11/Rule_11-10.md @@ -17,12 +17,12 @@ s# HVAC_SystemZoneAssignment - Rule 11-10 2. get_SHW_types_and_SHW_use() **Applicability Checks:** -- Each SHW use type is applicable if there are SHW loads -- use get_SHW_equipment_associated_with_each_SWH_bat to get the SHW use types and SHW use in the building: `shw_bats_and_equip_dict = get_SHW_equipment_associated_with_each_SWH_bat(B_RMD)` +- Each SHW BAT is applicable if there are SHW loads +- use get_SHW_equipment_associated_with_each_SWH_bat to get the SHW BATs and SHW use in the building: `shw_bats_and_equip_dict = get_SHW_equipment_associated_with_each_SWH_bat(B_RMD)` - call the function get_SHW_types_and_SHW_use for the proposed: `shw_bat_and_use_dict_p = get_SHW_types_and_SHW_use(P_RMD)` - look through each of the SHW bats in the building: `for shw_bat in shw_bat_and_use_dict_p:` - - check if there are SHW loads in this use type, continue to rule logic: `if len(shw_bat_and_use_dict_p[shw_bat]) > 0: CONTINUE TO RULE LOGIC` + - check if there are SHW loads in this BAT, continue to rule logic: `if len(shw_bat_and_use_dict_p[shw_bat]) > 0: CONTINUE TO RULE LOGIC` - otherwise, rule is not applicable for this shw_bat: `else: NOT_APPLICABLE` From 317213384b7fe706f9a1f1757fd965bb2350aecc Mon Sep 17 00:00:00 2001 From: KarenWGard <114143532+KarenWGard@users.noreply.github.com> Date: Wed, 19 Jun 2024 14:44:28 -0400 Subject: [PATCH 06/25] Update Rule_11-10.md --- docs/section11/Rule_11-10.md | 118 +++++------------------------------ 1 file changed, 15 insertions(+), 103 deletions(-) diff --git a/docs/section11/Rule_11-10.md b/docs/section11/Rule_11-10.md index b69aa4e36b..37d9470454 100644 --- a/docs/section11/Rule_11-10.md +++ b/docs/section11/Rule_11-10.md @@ -31,11 +31,11 @@ s# HVAC_SystemZoneAssignment - Rule 11-10 - create a variable to track any notes: `rule_note = """` - there should be one SHW Equipment for this BAT: `if len(shw_types_and_use_dict[shw_bat]["SHWHeatingEq"]) != 1:` - set rule_note to "more than one ServiceWaterHeatingEquipment" `rule_note = "more than one ServiceWaterHeatingEquipment"` - - otherwise, do the calculations to figure out of the SWH equipment meets the requirements of the rule: `else:` + - otherwise, do the calculations to figure out if the SWH equipment meets the requirements of the rule: `else:` - get the service water heating equipment id: `service_water_heating_equipment_id = shw_equip_dict[shw_bat]["SHWHeatingEq"]` - we need to find the following information about the SWH: - tank_type - (ELECTRIC_RESISTANCE_INSTANTANEOUS, ELECTRIC_RESISTANCE_STORAGE, GAS_STORAGE, OTHER) - - swh_type - one of the + - swh_type - one of the SWH BATs - input_capacity (btu/hr) - storage_volume (gallons) - draw_pattern (VERY_SMALL, LOW, MEDIUM, or HIGH) @@ -45,18 +45,15 @@ s# HVAC_SystemZoneAssignment - Rule 11-10 - get the type of heater: `swh_type = swh_eq.heater_type` - the type will be one of the ServiceWaterHeaterTankOptions, which are more detailed than the four types we need. Determine our type based on the detailed type. - set the type to OTHER. If the tank_type is an identifiable type, type will be overwritten to that type: `type = "OTHER"` - - if the tank_type is CONSUMER_INSTANTANEOUS, COMMERCIAL_INSTANTANEOUS, or RESIDENTIAL_DUTY_COMMERCIAL_INSTANTANEOUS, set the type to INSTANTANEOUS: `if tank_type in ["CONSUMER_INSTANTANEOUS", "COMMERCIAL_INSTANTANEOUS", "RESIDENTIAL_DUTY_COMMERCIAL_INSTANTANEOUS"]: type = "INSTANTANEOUS"` + - if the tank_type is CONSUMER_INSTANTANEOUS, COMMERCIAL_INSTANTANEOUS, or RESIDENTIAL_DUTY_COMMERCIAL_INSTANTANEOUS, set the type to INSTANTANEOUS and go to rule assertion: `if tank_type in ["CONSUMER_INSTANTANEOUS", "COMMERCIAL_INSTANTANEOUS", "RESIDENTIAL_DUTY_COMMERCIAL_INSTANTANEOUS"]: type = "INSTANTANEOUS"`; GO TO RULE_ASSERTION - if the tank_type is CONSUMER_STORAGE or COMMERCIAL_STORAGE, set the type to STORAGE: `if tank_type in ["CONSUMER_STORAGE", "COMMERCIAL_STORAGE"]: type = "STORAGE"` - get the fuel type of the equipment: `fuel_type = shw_eq.heater_fuel_type` - set the type based on tank_type and fuel type: `if fuel_type == "ELECTRICITY":` - - `if tank_type == "INSTANTANEOUS": type = "ELECTRIC_RESISTANCE_INSTANTANEOUS"` - - `elsif tank_type == "STORAGE": type = "ELECTRIC_RESISTANCE_STORAGE"` + - `if tank_type == "STORAGE": type = "ELECTRIC_RESISTANCE_STORAGE"` - `elsif fule_type == "NATURAL_GAS":` - - `if tank_type == "INSTANTANEOUS": type = "GAS_INSTANTANEOUS"` - - `elsif tank_type == "STORAGE": type = "GAS_STORAGE"` + - `if tank_type == "STORAGE": type = "GAS_STORAGE"` - `elsif fule_type == "FUEL_OIL":` - - `if tank_type == "INSTANTANEOUS": type = "OIL_INSTANTANEOUS"` - - `elsif tank_type == "STORAGE": type = "OIL_STORAGE"` + - `if tank_type == "STORAGE": type = "OIL_STORAGE"` - if the draw_pattern is given, get the draw pattern: `if shw_eq.draw_pattern != nil: draw_pattern = shw_eq.draw_pattern` - otherwise, determine the draw pattern based off the first_hour_rating of the shw_eq: `else:` - First get the first hour rating (gallons): `first_hour_rating = shw_eq.first_hour_rating` @@ -72,8 +69,8 @@ s# HVAC_SystemZoneAssignment - Rule 11-10 - if the type is OTHER, set rule_note to "Water heater type is not a recognized type": `if type == "OTHER": rule_note = "Water heater type is not a recognized type"` - otherwise, continue with rule logic: `else:` - create a boolean has_fault and set it to false: `has_fault = false` - - if the water heater is electric resistance, or storage and the capacity is <= 12kW (40945 btu/hr), look at Appendix F: `if type in ["ELECTRIC_RESISTANCE_INSTANTANEOUS", "ELECTRIC_RESISTANCE_STORAGE"] && input_capacity <= 40945.7:` - - check the size of the storage tank. If it's less than 2 gallons, then it qualifies as an instantaneous electric water heater: `if storage_volume < 2:` + - if the water heater is electric resistance, or storage and the capacity is <= 12kW (40945 btu/hr), look at Appendix F: `if type in ["ELECTRIC_RESISTANCE_STORAGE"] && input_capacity <= 40945.7:` + - check the size of the storage tank. If it's less than 2 gallons: `if storage_volume < 2:` - if the draw pattern is HIGH, the expected UEF is 0.92, for draw all draw patterns other draw patterns, it is 0.91: `if draw_pattern == "HIGH": expected_UEF = 0.92; else: expected_UEF = 0.91` - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.uniform_energy_factor >= expected_UEF:` - set rule_status to "PASS": `rule_status = "PASS"` @@ -97,31 +94,9 @@ s# HVAC_SystemZoneAssignment - Rule 11-10 - set the note to indicate that the standby_loss is higher than the maximum allowed: `rule_note = "Standby Loss is higher than required by Table 7.8"` - otherwise: `else:` - set the note to indicate that the capacity per volume exceeds the limit: `rule_note = "Capacity per volume exceeds the limit of 4000 btu/hr/gallon for Electric Storage Water Heaters` - - check if the water heater is an instantaneous electric resistance: `if type == "ELECTRIC_RESISTANCE_INSTANTANEOUS"` - - check the capacity. If it's less than or equal to 58.6 kW (199951.5 btu/hr), check the other parameters. We don't need to check if the capacity is > 12 kW, because all systems less than 12 kW have already been checked: `if input_capacity <= 199951.5:` - - the storage capacity should be less than or equal to 2 gallons: `if storage_volume > 2:` - - set the note to read "For instantaneous Electric Water heaters, storage volume should be <= 2 gallons. ": `rule_note = "For instantaneous Electric heaters, storage volume should be <= 2 gallons. "` - - set has_fault to true: `has_fault = true` - - the setpoint temperature should be less than or equal to 180F: `if shw_eq.setpoint_temperature > 180:` - - add the following text to the note: "For instantaneous Electric Water heaters, the supply water temperature must be <= 180F": `rule_note += "For instantaneous Electric Water heaters, the supply water temperature must be <= 180F"` - - set has_fault to true: `has_fault = true` - - the capacity per volume should be >= 4000 btu/hr/gallon: `if capacity_per_volume < 4000:` - - add the following text to the note: "For instantaneous Electric Water heaters, the capacity per volume should be greater than 4000 btu/hr/gallon": `rule_note += "For instantaneous Electric Water heaters, the capacity per volume should be greater than 4000 btu/hr/gallon"` - - set has_fault to true: `has_fault = true` - - set the expected thermal efficiency to 0.8: `expected_thermal_efficiency = 0.8` - - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.thermal_efficiency >= expected_thermal_efficiency && !has_faults:` - - set rule_status to "PASS": `rule_status = "PASS"` - - otherwise: `else:` - - create a note indicating that electric resistance water heaters greater than 58.6kW are not covered in table 7.8: `rule_note: "electric resistance water heaters greater than 58.6kW are not covered in table 7.8. "` - - change rule_status to UNDETERMINED: `rule_status = "UNDETERMINED"` - check if the water heater is gas storage: `if type == "GAS_STORAGE":` - check if the capacity is <= 75,000 btu/hr: `if input_capacity <= 75000:` - - look to see if the water heater is covered in Appendix F, first look to see if it is an instantaneous water heater (anything less than 2 gallons of storage): `if storage_volume < 2:` - - if the draw pattern is HIGH, the expected UEF is 0.92, for draw all draw patterns other draw patterns, it is 0.91: `if draw_pattern == "HIGH": expected_UEF = 0.92; else: expected_UEF = 0.91` - - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.uniform_energy_factor >= expected_UEF:` - - set rule_status to "PASS": `rule_status = "PASS"` - - otherwise, set rule status to FAIL and provide the note that the expected UEF is less than the required UEF: `else: rule_status = "FAIL"; rule_note = "The modeled Uniform energy Factor (UEF - " + shw_eq.uniform_energy_factor + ") is less than required (" + expected_UEF + ")"` - - otherwise, if the storage volume is between 20 and 55 gallons: `elsif storage_volume >= 20 && storage_volume <= 55:` + - if the storage volume is between 20 and 55 gallons: `if storage_volume >= 20 && storage_volume <= 55:` - determine the UEF based on the draw pattern for VERY_SMALL: `if draw_pattern == "VERY_SMALL": expected_uef = 0.3456 – (0.0020 × storage_volume)` - determine the UEF based on the draw pattern for LOW: `if draw_pattern == "LOW": expected_uef = 0.5982 – (0.0019 × storage_volume)` - determine the UEF based on the draw pattern for MEDIUM: `if draw_pattern == "MEDIUM": expected_uef = 0.6483 – (0.0017 × storage_volume)` @@ -164,51 +139,9 @@ s# HVAC_SystemZoneAssignment - Rule 11-10 - calculate max_standby_loss (btu/hr): `max_standby_loss = (input_capacity/800 + 110 * sqrt(volume))` - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.thermal_efficiency >= expected_thermal_efficiency && standby_loss <= max_standby_loss && !has_faults:` - set rule_status to "PASS": `rule_status = "PASS"` - - check if the water heater is GAS_INSTANTANEOUS: `if type == "GAS_INSTANTANEOUS"` - - if the input capacity <= 200,000 btu/hr, this equipment is covered in Appendix F: `if input_capacity <= 200000:` - - look to see if the water heater is covered in Appendix F, first look to see if it is an instantaneous water heater (anything less than 2 gallons of storage): `if storage_volume < 2:` - - if the draw pattern is HIGH, the expected UEF is 0.92, for draw all draw patterns other draw patterns, it is 0.91: `if draw_pattern == "HIGH": expected_UEF = 0.92; else: expected_UEF = 0.91` - - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.uniform_energy_factor >= expected_UEF:` - - set rule_status to "PASS": `rule_status = "PASS"` - - otherwise, set rule status to FAIL and provide the note that the expected UEF is less than the required UEF: `else: rule_status = "FAIL"; rule_note = "The modeled Uniform energy Factor (UEF - " + shw_eq.uniform_energy_factor + ") is less than required (" + expected_UEF + ")"` - - otherwise, if the storage volume is between 20 and 55 gallons: `elsif storage_volume >= 20 && storage_volume <= 55:` - - determine the UEF based on the draw pattern for VERY_SMALL: `if draw_pattern == "VERY_SMALL": expected_uef = 0.3456 – (0.0020 × storage_volume)` - - determine the UEF based on the draw pattern for LOW: `if draw_pattern == "LOW": expected_uef = 0.5982 – (0.0019 × storage_volume)` - - determine the UEF based on the draw pattern for MEDIUM: `if draw_pattern == "MEDIUM": expected_uef = 0.6483 – (0.0017 × storage_volume)` - - determine the UEF based on the draw pattern for HIGH: `if draw_pattern == "HIGH": expected_uef = 0.6920 – (0.0013 × storage_volume)` - - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.uniform_energy_factor >= expected_UEF:` - - set rule_status to "PASS": `rule_status = "PASS"` - - otherwise, set rule status to FAIL and provide the note that the expected UEF is less than the required UEF: `else: rule_status = "FAIL"; rule_note = "The modeled Uniform energy Factor (UEF - " + shw_eq.uniform_energy_factor + ") is less than required (" + expected_UEF + ")"` - - otherwise, if the storage volume is between 55 and 100 gallons: `elif storage_volume <= 100:` - - determine the UEF based on the draw pattern for VERY_SMALL: `if draw_pattern == "VERY_SMALL": expected_uef = 0.6470 – (0.0006 × storage_volume)` - - determine the UEF based on the draw pattern for LOW: `if draw_pattern == "LOW": expected_uef = 0.7689 – (0.0005 × storage_volume)` - - determine the UEF based on the draw pattern for MEDIUM: `if draw_pattern == "MEDIUM": expected_uef = 0.7897 – (0.0004 × storage_volume)` - - determine the UEF based on the draw pattern for HIGH: `if draw_pattern == "HIGH": expected_uef = 0.8072 – (0.0003 × storage_volume)` - - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.uniform_energy_factor >= expected_UEF:` - - set rule_status to "PASS": `rule_status = "PASS"` - - otherwise, set rule status to FAIL and provide the note that the expected UEF is less than the required UEF: `else: rule_status = "FAIL"; rule_note = "The modeled Uniform energy Factor (UEF - " + shw_eq.uniform_energy_factor + ") is less than required (" + expected_UEF + ")"` - - otherwise, the storage volume is either greater than 100 gallons, or between 2 and 20, which is not covered by Appendix F: `else:` - - create a note indicating that gas water heaters greater with input capacity < 75,000 btu/hr and the given storage volume are not covered under Appendix F: `rule_note: "Gas water heaters with an input capacity < 75,000 btu/hr and a storage capacity of " + storage_volume + " are not covered under Appendix F"` - - change rule_status to UNDETERMINED: `rule_status = "UNDETERMINED"` - - - otherwise, if the storage volume is less than 10 gallons: `if volume < 10:` - - set expected thermal efficiency to 80%: `expected_thermal_efficiency = 0.8` - - the capacity per volume should be >= 4000 btu/hr/gallon: `if capacity_per_volume < 4000:` - - add the following text to the note: "For Gas Instantaneous heaters, the capacity per volume should be greater than 4000 btu/hr/gallon": `rule_note += "For Gas Instantaneous Water heaters, the capacity per volume should be greater than 4000 btu/hr/gallon. "` - - set has_fault to true: `has_fault = true` - - if the thermal efficiency is greater than or equal to the expected: `if shw_eq.thermal_efficiency >= expected_thermal_efficiency && !has_faults:` - - set rule_status to "PASS": `rule_status = "PASS"` - - otherwise, the storage volume is greater than 10 gallons: `else:` - - set expected thermal efficiency to 80%: `expected_thermal_efficiency = 0.8` - - calculate the max_standby_loss: `max_standby_loss = (input_capacity/800 + 110 * sqrt(volume))` - - the capacity per volume should be >= 4000 btu/hr/gallon: `if capacity_per_volume < 4000:` - - add the following text to the note: "For Gas Instantaneous heaters, the capacity per volume should be greater than 4000 btu/hr/gallon": `rule_note += "For Gas Instantaneous Water heaters, the capacity per volume should be greater than 4000 btu/hr/gallon. "` - - set has_fault to true: `has_fault = true` - - if the thermal efficiency is greater than or equal to the expected: `if shw_eq.thermal_efficiency >= expected_thermal_efficiency && standby_loss <= max_standby_loss && !has_faults:` - - set rule_status to "PASS": `rule_status = "PASS"` - check if the water heater is OIL_STORAGE: `elsif type == "OIL_STORAGE` - if the input capacity < 105,000 btu/hr, this equipment is covered under Appendix F: `if input_capacity < 105000:` - - look to see if the water heater is covered in Appendix F, first look to see if it is an instantaneous water heater (anything less than 50 gallons of storage): `if storage_volume < 50:` + - look to see if the water heater is covered in Appendix F, first look to see if it is anything less than 50 gallons of storage: `if storage_volume < 50:` - determine the UEF based on the draw pattern for VERY_SMALL: `if draw_pattern == "VERY_SMALL": expected_uef = 0.2509 – (0.0012 × storage_volume)` - determine the UEF based on the draw pattern for LOW: `if draw_pattern == "LOW": expected_uef = 0.5330 – (0.0016 × storage_volume)` - determine the UEF based on the draw pattern for MEDIUM: `if draw_pattern == "MEDIUM": expected_uef = 0.6078 – (0.0016 × storage_volume)` @@ -242,33 +175,12 @@ s# HVAC_SystemZoneAssignment - Rule 11-10 - set the expected thermal efficiency to 0.8: `expected_thermal_efficiency = 0.8` - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.thermal_efficiency >= expected_thermal_efficiency && !has_faults:` - set rule_status to "PASS": `rule_status = "PASS"` - - check if the water heater is OIL_INSTANTANEOUS: `elsif type == "OIL_INSTANTANEOUS` - - the capacity per volume should be >= 4000 btu/hr/gallon: `if capacity_per_volume < 4000:` - - add the following text to the note: "For Oil Instantaneous water heaters the capacity per volume should be > 4000 btu/hr/gallon.": `rule_note += "For Oil Instantaneous water heaters the capacity per volume should be > 4000 btu/hr/gallon. "` - - set has_fault to true: `has_fault = true` - - if the input capacity <= 210,000 btu/hr: `if input_capacity <= 210000:` - - check that the storage volume is < 2 gallons: `if volume >= 2 gallons:` - - add the following text to the note: "For Oil Instantaneous Water heaters, with capacity <= 210,000 btu/hr, the storage volume should be < 2 gallons.": `rule_note += "For Oil Instantaneous Water heaters, with capacity <= 210,000 btu/hr, the storage volume should be < 2 gallons. "` - - set has_fault to true: `has_fault = true` - - set the expected thermal efficiency to 0.8: `expected_thermal_efficiency = 0.8` - - calculate the Energy Factor: `expected_energy_factor = 0.59 – 0.0005 * volume` - - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.thermal_efficiency >= expected_thermal_efficiency && shw_eq.energy_factor >= expected_energy_factor && !has_faults:` - - set rule_status to "PASS": `rule_status = "PASS"` - - else the input capacity is > 210,000 btu/hr: `else:` - - if the storage volume is < 10 gallons: `if volume < 10:` - - set the expected thermal efficiency to 0.8: `expected_thermal_efficiency = 0.8` - - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.thermal_efficiency >= expected_thermal_efficiency && !has_faults:` - - set rule_status to "PASS": `rule_status = "PASS"` - - else the storage volume is >= 10 gallons: `else:` - - set the expected thermal efficiency to 0.8: `expected_thermal_efficiency = 0.78` - - calculate max_standby_loss (btu/hr): `max_standby_loss = (input_capacity/800 + 110 * sqrt(volume))` - - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.thermal_efficiency >= expected_thermal_efficiency && standby_loss <= max_standby_loss && !has_faults:` - - set rule_status to "PASS": `rule_status = "PASS"` - + **Rule Assertion - Zone:** - - Case1: rule_status is PASS: `if rule_status == "PASS": PASS`. - - Case2: rule_status is UNDETERMINED, UNDETERMINED & return rule_note: `elsif rule_status == "UNDETERMINED": UNDETERMINED; rule_note` - - Case3: rule_status is FAIL, FAIL & return rule_note: `elsif rule_status == "FAIL": FAIL; rule_note` + - Case1: type is INSTANTANEOUS - there is no baseline instantaneous water heater types: `if type == "INSTANTANEOUS": UNDETERMINED; rule_node = "There baseline water heater is of an Instantaneous type. There are no acceptable instantaneous baseline water heaters in Table G3.1.1-2." + - Case2: rule_status is PASS: `if rule_status == "PASS": PASS`. + - Case3: rule_status is UNDETERMINED, UNDETERMINED & return rule_note: `elsif rule_status == "UNDETERMINED": UNDETERMINED; rule_note` + - Case4: rule_status is FAIL, FAIL & return rule_note: `elsif rule_status == "FAIL": FAIL; rule_note` **Notes:** From 93cc6d2105f626f001bb7ed7b617a03a2c4930ab Mon Sep 17 00:00:00 2001 From: KarenWGard <114143532+KarenWGard@users.noreply.github.com> Date: Wed, 19 Jun 2024 15:53:40 -0400 Subject: [PATCH 07/25] Update Rule_11-10.md tank_type --- docs/section11/Rule_11-10.md | 34 ++++++++++++++++------------------ 1 file changed, 16 insertions(+), 18 deletions(-) diff --git a/docs/section11/Rule_11-10.md b/docs/section11/Rule_11-10.md index 37d9470454..ca7afa7697 100644 --- a/docs/section11/Rule_11-10.md +++ b/docs/section11/Rule_11-10.md @@ -4,16 +4,16 @@ s# HVAC_SystemZoneAssignment - Rule 11-10 **Mandatory Rule:** True **Rule ID:** 11-10 -**Rule Description:** "The service water heating systems type in the baseline building design shall match the minimum efficiency requirements in Section 7.4.2" +**Rule Description:** "The service water heating system type in the baseline building design shall match the minimum efficiency requirements in Section 7.4.2" **Rule Assertion:** Options are PASS/FAIL/NOT_APPLICABLE/UNDETERMINED **Appendix G Section Reference:** Table G3.1 #11, baseline column, a + b -**Evaluation Context:** Each SWH bat +**Evaluation Context:** Each ServiceWaterHeatingEquipment **Data Lookup:** **Function Call:** -1. get_SHW_equipment_connected_to_use_type() +1. get_SHW_equipment_associated_with_each_SWH_bat() 2. get_SHW_types_and_SHW_use() **Applicability Checks:** @@ -34,7 +34,7 @@ s# HVAC_SystemZoneAssignment - Rule 11-10 - otherwise, do the calculations to figure out if the SWH equipment meets the requirements of the rule: `else:` - get the service water heating equipment id: `service_water_heating_equipment_id = shw_equip_dict[shw_bat]["SHWHeatingEq"]` - we need to find the following information about the SWH: - - tank_type - (ELECTRIC_RESISTANCE_INSTANTANEOUS, ELECTRIC_RESISTANCE_STORAGE, GAS_STORAGE, OTHER) + - type - (ELECTRIC_RESISTANCE_INSTANTANEOUS, ELECTRIC_RESISTANCE_STORAGE, GAS_STORAGE, OTHER) - swh_type - one of the SWH BATs - input_capacity (btu/hr) - storage_volume (gallons) @@ -46,20 +46,18 @@ s# HVAC_SystemZoneAssignment - Rule 11-10 - the type will be one of the ServiceWaterHeaterTankOptions, which are more detailed than the four types we need. Determine our type based on the detailed type. - set the type to OTHER. If the tank_type is an identifiable type, type will be overwritten to that type: `type = "OTHER"` - if the tank_type is CONSUMER_INSTANTANEOUS, COMMERCIAL_INSTANTANEOUS, or RESIDENTIAL_DUTY_COMMERCIAL_INSTANTANEOUS, set the type to INSTANTANEOUS and go to rule assertion: `if tank_type in ["CONSUMER_INSTANTANEOUS", "COMMERCIAL_INSTANTANEOUS", "RESIDENTIAL_DUTY_COMMERCIAL_INSTANTANEOUS"]: type = "INSTANTANEOUS"`; GO TO RULE_ASSERTION - - if the tank_type is CONSUMER_STORAGE or COMMERCIAL_STORAGE, set the type to STORAGE: `if tank_type in ["CONSUMER_STORAGE", "COMMERCIAL_STORAGE"]: type = "STORAGE"` + - get the fuel type of the equipment: `fuel_type = shw_eq.heater_fuel_type` - - set the type based on tank_type and fuel type: `if fuel_type == "ELECTRICITY":` - - `if tank_type == "STORAGE": type = "ELECTRIC_RESISTANCE_STORAGE"` - - `elsif fule_type == "NATURAL_GAS":` - - `if tank_type == "STORAGE": type = "GAS_STORAGE"` - - `elsif fule_type == "FUEL_OIL":` - - `if tank_type == "STORAGE": type = "OIL_STORAGE"` + - if the tank_type is CONSUMER_STORAGE or COMMERCIAL_STORAGE, set the type to STORAGE for the fuel type: `if tank_type in ["CONSUMER_STORAGE", "COMMERCIAL_STORAGE"]:` + - set the type based on tank_type and fuel type: `if fuel_type == "ELECTRICITY": type = "ELECTRIC_RESISTANCE_STORAGE` + - `elif fuel_type == "NATURAL_GAS": type = "GAS_STORAGE` + - `elif fuel_type == "FUEL_OIL": type = "OIL_STORAGE` - if the draw_pattern is given, get the draw pattern: `if shw_eq.draw_pattern != nil: draw_pattern = shw_eq.draw_pattern` - otherwise, determine the draw pattern based off the first_hour_rating of the shw_eq: `else:` - First get the first hour rating (gallons): `first_hour_rating = shw_eq.first_hour_rating` - if the first_hour_rating is less than 18 gallons, draw_pattern is "VERY SMALL": `if first_hour_rating < 18: draw_pattern = "VERY_SMALL"` - - otherwise if the first_hour_rating is less than 51 gallons, draw pattern is LOW: `elsif first_hour_rating < 51: draw_pattern = "LOW"` - - otherwise if the first_hour_rating is less than 75 gallons, draw pattern is MEDIUM: `elsif first_hour_rating < 75: draw_pattern = "MEDIUM"` + - otherwise if the first_hour_rating is less than 51 gallons, draw pattern is LOW: `elif first_hour_rating < 51: draw_pattern = "LOW"` + - otherwise if the first_hour_rating is less than 75 gallons, draw pattern is MEDIUM: `elif first_hour_rating < 75: draw_pattern = "MEDIUM"` - otherwise draw pattern is HIGH: `else: draw_pattern = "HIGH"` - get the capacity of the SHW system (make sure to convert to btu/hr): `input_capacity = swh_eq.input_power` - get the volume of the tank (make sure to convert to gallons): `storage_volume = swh_eq.distribution_system.tank.storage_capacity` @@ -75,7 +73,7 @@ s# HVAC_SystemZoneAssignment - Rule 11-10 - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.uniform_energy_factor >= expected_UEF:` - set rule_status to "PASS": `rule_status = "PASS"` - otherwise, set rule status to FAIL and provide the note that the expected UEF is less than the required UEF: `else: rule_status = "FAIL"; rule_note = "The modeled Uniform energy Factor (UEF - " + shw_eq.uniform_energy_factor + ") is less than required (" + expected_UEF + ")"` - - else, if the storage tank is is between 20 and 55 gallons, this is considered an electric storage water heater in Appendix F: `elsif storage_volume >= 20 && storage_volume <= 55:` + - else, if the storage tank is is between 20 and 55 gallons, this is considered an electric storage water heater in Appendix F: `elif storage_volume >= 20 && storage_volume <= 55:` - determine the UEF based on the draw pattern for VERY_SMALL: `if draw_pattern == "VERY_SMALL": expected_uef = 0.8808 – (0.0008 × storage_volume)` - determine the UEF based on the draw pattern for LOW: `if draw_pattern == "LOW": expected_uef = 0.9254 – (0.0003 × storage_volume)` - determine the UEF based on the draw pattern for MEDIUM: `if draw_pattern == "MEDIUM": expected_uef = 0.9307 – (0.0002 × storage_volume)` @@ -115,7 +113,7 @@ s# HVAC_SystemZoneAssignment - Rule 11-10 - otherwise, the storage volume is either greater than 100 gallons, or between 2 and 20, which is not covered by Appendix F: `else:` - create a note indicating that gas water heaters greater with input capacity < 75,000 btu/hr and the given storage volume are not covered under Appendix F: `rule_note: "Gas water heaters with an input capacity < 75,000 btu/hr and a storage capacity of " + storage_volume + " are not covered under Appendix F"` - change rule_status to UNDETERMINED: `rule_status = "UNDETERMINED"` - - check if the capacity <= 105,000 btu/hr: `elsif input_capacity <= 105000:` + - check if the capacity <= 105,000 btu/hr: `elif input_capacity <= 105000:` - the capacity per volume should be < 4000 btu/hr/gallon: `if capacity_per_volume > 4000:` - add the following text to the note: "For Gas Storage Water heaters, the capacity per volume should be less than 4000 btu/hr/gallon": `rule_note += "For Gas Storage Water heaters, the capacity per volume should be less than 4000 btu/hr/gallon. "` - set has_fault to true: `has_fault = true` @@ -139,7 +137,7 @@ s# HVAC_SystemZoneAssignment - Rule 11-10 - calculate max_standby_loss (btu/hr): `max_standby_loss = (input_capacity/800 + 110 * sqrt(volume))` - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.thermal_efficiency >= expected_thermal_efficiency && standby_loss <= max_standby_loss && !has_faults:` - set rule_status to "PASS": `rule_status = "PASS"` - - check if the water heater is OIL_STORAGE: `elsif type == "OIL_STORAGE` + - check if the water heater is OIL_STORAGE: `elif type == "OIL_STORAGE` - if the input capacity < 105,000 btu/hr, this equipment is covered under Appendix F: `if input_capacity < 105000:` - look to see if the water heater is covered in Appendix F, first look to see if it is anything less than 50 gallons of storage: `if storage_volume < 50:` - determine the UEF based on the draw pattern for VERY_SMALL: `if draw_pattern == "VERY_SMALL": expected_uef = 0.2509 – (0.0012 × storage_volume)` @@ -179,8 +177,8 @@ s# HVAC_SystemZoneAssignment - Rule 11-10 **Rule Assertion - Zone:** - Case1: type is INSTANTANEOUS - there is no baseline instantaneous water heater types: `if type == "INSTANTANEOUS": UNDETERMINED; rule_node = "There baseline water heater is of an Instantaneous type. There are no acceptable instantaneous baseline water heaters in Table G3.1.1-2." - Case2: rule_status is PASS: `if rule_status == "PASS": PASS`. - - Case3: rule_status is UNDETERMINED, UNDETERMINED & return rule_note: `elsif rule_status == "UNDETERMINED": UNDETERMINED; rule_note` - - Case4: rule_status is FAIL, FAIL & return rule_note: `elsif rule_status == "FAIL": FAIL; rule_note` + - Case3: rule_status is UNDETERMINED, UNDETERMINED & return rule_note: `elif rule_status == "UNDETERMINED": UNDETERMINED; rule_note` + - Case4: rule_status is FAIL, FAIL & return rule_note: `elif rule_status == "FAIL": FAIL; rule_note` **Notes:** From de246e995e9db7ce7f9512a44ee272e80ee23f8a Mon Sep 17 00:00:00 2001 From: KarenWGard <114143532+KarenWGard@users.noreply.github.com> Date: Wed, 19 Jun 2024 15:57:52 -0400 Subject: [PATCH 08/25] Update Rule_11-10.md change evaluation context --- docs/section11/Rule_11-10.md | 294 +++++++++++++++++------------------ 1 file changed, 143 insertions(+), 151 deletions(-) diff --git a/docs/section11/Rule_11-10.md b/docs/section11/Rule_11-10.md index ca7afa7697..90e05ae78e 100644 --- a/docs/section11/Rule_11-10.md +++ b/docs/section11/Rule_11-10.md @@ -14,171 +14,163 @@ s# HVAC_SystemZoneAssignment - Rule 11-10 **Function Call:** 1. get_SHW_equipment_associated_with_each_SWH_bat() -2. get_SHW_types_and_SHW_use() **Applicability Checks:** -- Each SHW BAT is applicable if there are SHW loads +- Each SHW Equipment is applicable - use get_SHW_equipment_associated_with_each_SWH_bat to get the SHW BATs and SHW use in the building: `shw_bats_and_equip_dict = get_SHW_equipment_associated_with_each_SWH_bat(B_RMD)` - -- call the function get_SHW_types_and_SHW_use for the proposed: `shw_bat_and_use_dict_p = get_SHW_types_and_SHW_use(P_RMD)` -- look through each of the SHW bats in the building: `for shw_bat in shw_bat_and_use_dict_p:` - - check if there are SHW loads in this BAT, continue to rule logic: `if len(shw_bat_and_use_dict_p[shw_bat]) > 0: CONTINUE TO RULE LOGIC` - - otherwise, rule is not applicable for this shw_bat: `else: NOT_APPLICABLE` +- look through each of the SHW bats in the building: `for shw_bat in shw_bats_and_equip_dict:` + - look through each SHW Equipment: `for service_water_heating_equipment_id in shw_bats_and_equip_dict[shw_bat]: CONTINUE TO RULE LOGIC` ## Rule Logic: - create a value to track the rule status: `rule_status = "FAIL"` - create a variable to track any notes: `rule_note = """` - - there should be one SHW Equipment for this BAT: `if len(shw_types_and_use_dict[shw_bat]["SHWHeatingEq"]) != 1:` - - set rule_note to "more than one ServiceWaterHeatingEquipment" `rule_note = "more than one ServiceWaterHeatingEquipment"` - - otherwise, do the calculations to figure out if the SWH equipment meets the requirements of the rule: `else:` - - get the service water heating equipment id: `service_water_heating_equipment_id = shw_equip_dict[shw_bat]["SHWHeatingEq"]` - - we need to find the following information about the SWH: - - type - (ELECTRIC_RESISTANCE_INSTANTANEOUS, ELECTRIC_RESISTANCE_STORAGE, GAS_STORAGE, OTHER) - - swh_type - one of the SWH BATs - - input_capacity (btu/hr) - - storage_volume (gallons) - - draw_pattern (VERY_SMALL, LOW, MEDIUM, or HIGH) - - capacity_per_volume (btu/hr/gallon) - - get the service water heating system: `swh_eq = get_object_by_id(service_water_heating_equipment_id,RMD)` - - get the type of tank: `tank_type = swh_eq.tank.type` - - get the type of heater: `swh_type = swh_eq.heater_type` - - the type will be one of the ServiceWaterHeaterTankOptions, which are more detailed than the four types we need. Determine our type based on the detailed type. - - set the type to OTHER. If the tank_type is an identifiable type, type will be overwritten to that type: `type = "OTHER"` - - if the tank_type is CONSUMER_INSTANTANEOUS, COMMERCIAL_INSTANTANEOUS, or RESIDENTIAL_DUTY_COMMERCIAL_INSTANTANEOUS, set the type to INSTANTANEOUS and go to rule assertion: `if tank_type in ["CONSUMER_INSTANTANEOUS", "COMMERCIAL_INSTANTANEOUS", "RESIDENTIAL_DUTY_COMMERCIAL_INSTANTANEOUS"]: type = "INSTANTANEOUS"`; GO TO RULE_ASSERTION + - we need to find the following information about the SWH: + - type - (ELECTRIC_RESISTANCE_INSTANTANEOUS, ELECTRIC_RESISTANCE_STORAGE, GAS_STORAGE, OTHER) + - swh_type - one of the SWH BATs + - input_capacity (btu/hr) + - storage_volume (gallons) + - draw_pattern (VERY_SMALL, LOW, MEDIUM, or HIGH) + - capacity_per_volume (btu/hr/gallon) + - get the service water heating system: `swh_eq = get_object_by_id(service_water_heating_equipment_id,RMD)` + - get the type of tank: `tank_type = swh_eq.tank.type` + - get the type of heater: `swh_type = swh_eq.heater_type` + - the type will be one of the ServiceWaterHeaterTankOptions, which are more detailed than the four types we need. Determine our type based on the detailed type. + - set the type to OTHER. If the tank_type is an identifiable type, type will be overwritten to that type: `type = "OTHER"` + - if the tank_type is CONSUMER_INSTANTANEOUS, COMMERCIAL_INSTANTANEOUS, or RESIDENTIAL_DUTY_COMMERCIAL_INSTANTANEOUS, set the type to INSTANTANEOUS and go to rule assertion: `if tank_type in ["CONSUMER_INSTANTANEOUS", "COMMERCIAL_INSTANTANEOUS", "RESIDENTIAL_DUTY_COMMERCIAL_INSTANTANEOUS"]: type = "INSTANTANEOUS"`; GO TO RULE_ASSERTION - - get the fuel type of the equipment: `fuel_type = shw_eq.heater_fuel_type` - - if the tank_type is CONSUMER_STORAGE or COMMERCIAL_STORAGE, set the type to STORAGE for the fuel type: `if tank_type in ["CONSUMER_STORAGE", "COMMERCIAL_STORAGE"]:` - - set the type based on tank_type and fuel type: `if fuel_type == "ELECTRICITY": type = "ELECTRIC_RESISTANCE_STORAGE` - - `elif fuel_type == "NATURAL_GAS": type = "GAS_STORAGE` - - `elif fuel_type == "FUEL_OIL": type = "OIL_STORAGE` - - if the draw_pattern is given, get the draw pattern: `if shw_eq.draw_pattern != nil: draw_pattern = shw_eq.draw_pattern` - - otherwise, determine the draw pattern based off the first_hour_rating of the shw_eq: `else:` - - First get the first hour rating (gallons): `first_hour_rating = shw_eq.first_hour_rating` - - if the first_hour_rating is less than 18 gallons, draw_pattern is "VERY SMALL": `if first_hour_rating < 18: draw_pattern = "VERY_SMALL"` - - otherwise if the first_hour_rating is less than 51 gallons, draw pattern is LOW: `elif first_hour_rating < 51: draw_pattern = "LOW"` - - otherwise if the first_hour_rating is less than 75 gallons, draw pattern is MEDIUM: `elif first_hour_rating < 75: draw_pattern = "MEDIUM"` - - otherwise draw pattern is HIGH: `else: draw_pattern = "HIGH"` - - get the capacity of the SHW system (make sure to convert to btu/hr): `input_capacity = swh_eq.input_power` - - get the volume of the tank (make sure to convert to gallons): `storage_volume = swh_eq.distribution_system.tank.storage_capacity` - - calculate the capacity_per_volume based on the input_capacity and the storage_volume: `capacity_per_volume = shw_eq.rated_capacity / storage_volume` - - get the standby loss (see note 1 for calculation source): `standby_loss = swh_eq.standby_loss_fraction * 8.25 * volume * 70` - - what follows is logic that implements Table 7.8 - this table has multiple criteria, so I think it's simpler to implement with if / else logic than a table lookup - - if the type is OTHER, set rule_note to "Water heater type is not a recognized type": `if type == "OTHER": rule_note = "Water heater type is not a recognized type"` + - get the fuel type of the equipment: `fuel_type = shw_eq.heater_fuel_type` + - if the tank_type is CONSUMER_STORAGE or COMMERCIAL_STORAGE, set the type to STORAGE for the fuel type: `if tank_type in ["CONSUMER_STORAGE", "COMMERCIAL_STORAGE"]:` + - set the type based on tank_type and fuel type: `if fuel_type == "ELECTRICITY": type = "ELECTRIC_RESISTANCE_STORAGE` + - `elif fuel_type == "NATURAL_GAS": type = "GAS_STORAGE` + - `elif fuel_type == "FUEL_OIL": type = "OIL_STORAGE` + - if the draw_pattern is given, get the draw pattern: `if shw_eq.draw_pattern != nil: draw_pattern = shw_eq.draw_pattern` + - otherwise, determine the draw pattern based off the first_hour_rating of the shw_eq: `else:` + - First get the first hour rating (gallons): `first_hour_rating = shw_eq.first_hour_rating` + - if the first_hour_rating is less than 18 gallons, draw_pattern is "VERY SMALL": `if first_hour_rating < 18: draw_pattern = "VERY_SMALL"` + - otherwise if the first_hour_rating is less than 51 gallons, draw pattern is LOW: `elif first_hour_rating < 51: draw_pattern = "LOW"` + - otherwise if the first_hour_rating is less than 75 gallons, draw pattern is MEDIUM: `elif first_hour_rating < 75: draw_pattern = "MEDIUM"` + - otherwise draw pattern is HIGH: `else: draw_pattern = "HIGH"` + - get the capacity of the SHW system (make sure to convert to btu/hr): `input_capacity = swh_eq.input_power` + - get the volume of the tank (make sure to convert to gallons): `storage_volume = swh_eq.distribution_system.tank.storage_capacity` + - calculate the capacity_per_volume based on the input_capacity and the storage_volume: `capacity_per_volume = shw_eq.rated_capacity / storage_volume` + - get the standby loss (see note 1 for calculation source): `standby_loss = swh_eq.standby_loss_fraction * 8.25 * volume * 70` + - what follows is logic that implements Table 7.8 - this table has multiple criteria, so I think it's simpler to implement with if / else logic than a table lookup + - if the type is OTHER, set rule_note to "Water heater type is not a recognized type": `if type == "OTHER": rule_note = "Water heater type is not a recognized type"` + - otherwise, continue with rule logic: `else:` + - create a boolean has_fault and set it to false: `has_fault = false` + - if the water heater is electric resistance, or storage and the capacity is <= 12kW (40945 btu/hr), look at Appendix F: `if type in ["ELECTRIC_RESISTANCE_STORAGE"] && input_capacity <= 40945.7:` + - check the size of the storage tank. If it's less than 2 gallons: `if storage_volume < 2:` + - if the draw pattern is HIGH, the expected UEF is 0.92, for draw all draw patterns other draw patterns, it is 0.91: `if draw_pattern == "HIGH": expected_UEF = 0.92; else: expected_UEF = 0.91` + - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.uniform_energy_factor >= expected_UEF:` + - set rule_status to "PASS": `rule_status = "PASS"` + - otherwise, set rule status to FAIL and provide the note that the expected UEF is less than the required UEF: `else: rule_status = "FAIL"; rule_note = "The modeled Uniform energy Factor (UEF - " + shw_eq.uniform_energy_factor + ") is less than required (" + expected_UEF + ")"` + - else, if the storage tank is is between 20 and 55 gallons, this is considered an electric storage water heater in Appendix F: `elif storage_volume >= 20 && storage_volume <= 55:` + - determine the UEF based on the draw pattern for VERY_SMALL: `if draw_pattern == "VERY_SMALL": expected_uef = 0.8808 – (0.0008 × storage_volume)` + - determine the UEF based on the draw pattern for LOW: `if draw_pattern == "LOW": expected_uef = 0.9254 – (0.0003 × storage_volume)` + - determine the UEF based on the draw pattern for MEDIUM: `if draw_pattern == "MEDIUM": expected_uef = 0.9307 – (0.0002 × storage_volume)` + - determine the UEF based on the draw pattern for HIGH: `if draw_pattern == "HIGH": expected_uef = 0.9349 – (0.0001 × storage_volume)` + - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.uniform_energy_factor >= expected_UEF:` + - set rule_status to "PASS": `rule_status = "PASS"` + - otherwise, set rule status to FAIL and provide the note that the expected UEF is less than the required UEF: `else: rule_status = "FAIL"; rule_note = "The modeled Uniform energy Factor (UEF - " + shw_eq.uniform_energy_factor + ") is less than required (" + expected_UEF + ")"` + - else, if the storage tank is greater than 55 and less than 100 gallons, Appendix F provides a heat pump efficiency, or the storage volume is between 2 and 20 gallons, in which case there is no rating in APPENDIX F. return UNDETERMINED: `else:` + - set rule_status to UNDETERMINED: `rule_status = "UNDETERMINED"` - otherwise, continue with rule logic: `else:` - - create a boolean has_fault and set it to false: `has_fault = false` - - if the water heater is electric resistance, or storage and the capacity is <= 12kW (40945 btu/hr), look at Appendix F: `if type in ["ELECTRIC_RESISTANCE_STORAGE"] && input_capacity <= 40945.7:` - - check the size of the storage tank. If it's less than 2 gallons: `if storage_volume < 2:` - - if the draw pattern is HIGH, the expected UEF is 0.92, for draw all draw patterns other draw patterns, it is 0.91: `if draw_pattern == "HIGH": expected_UEF = 0.92; else: expected_UEF = 0.91` - - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.uniform_energy_factor >= expected_UEF:` - - set rule_status to "PASS": `rule_status = "PASS"` - - otherwise, set rule status to FAIL and provide the note that the expected UEF is less than the required UEF: `else: rule_status = "FAIL"; rule_note = "The modeled Uniform energy Factor (UEF - " + shw_eq.uniform_energy_factor + ") is less than required (" + expected_UEF + ")"` - - else, if the storage tank is is between 20 and 55 gallons, this is considered an electric storage water heater in Appendix F: `elif storage_volume >= 20 && storage_volume <= 55:` - - determine the UEF based on the draw pattern for VERY_SMALL: `if draw_pattern == "VERY_SMALL": expected_uef = 0.8808 – (0.0008 × storage_volume)` - - determine the UEF based on the draw pattern for LOW: `if draw_pattern == "LOW": expected_uef = 0.9254 – (0.0003 × storage_volume)` - - determine the UEF based on the draw pattern for MEDIUM: `if draw_pattern == "MEDIUM": expected_uef = 0.9307 – (0.0002 × storage_volume)` - - determine the UEF based on the draw pattern for HIGH: `if draw_pattern == "HIGH": expected_uef = 0.9349 – (0.0001 × storage_volume)` - - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.uniform_energy_factor >= expected_UEF:` - - set rule_status to "PASS": `rule_status = "PASS"` - - otherwise, set rule status to FAIL and provide the note that the expected UEF is less than the required UEF: `else: rule_status = "FAIL"; rule_note = "The modeled Uniform energy Factor (UEF - " + shw_eq.uniform_energy_factor + ") is less than required (" + expected_UEF + ")"` - - else, if the storage tank is greater than 55 and less than 100 gallons, Appendix F provides a heat pump efficiency, or the storage volume is between 2 and 20 gallons, in which case there is no rating in APPENDIX F. return UNDETERMINED: `else:` - - set rule_status to UNDETERMINED: `rule_status = "UNDETERMINED"` - - otherwise, continue with rule logic: `else:` - - check electric storage water heaters with capacity greater than 12 kW: `if type == "ELECTRIC_RESISTANCE_STORAGE" && input_capacity > 40945.7:` - - check that the capacity_per_volume < 4000 btu/hr/gallon: `if capacity_per_volume < 4000:` - - calculate the standby loss target: `standby_loss_target = 0.3 + (27/swh_eq.distribution_system.tank.storage_volume)` - - if the standby_loss is less than or equal to the target, set the rule_status to PASS: `if standby_loss <= standby_loss_target: rule_status: "PASS"` - - otherwise: `else:` - - set the note to indicate that the standby_loss is higher than the maximum allowed: `rule_note = "Standby Loss is higher than required by Table 7.8"` + - check electric storage water heaters with capacity greater than 12 kW: `if type == "ELECTRIC_RESISTANCE_STORAGE" && input_capacity > 40945.7:` + - check that the capacity_per_volume < 4000 btu/hr/gallon: `if capacity_per_volume < 4000:` + - calculate the standby loss target: `standby_loss_target = 0.3 + (27/swh_eq.distribution_system.tank.storage_volume)` + - if the standby_loss is less than or equal to the target, set the rule_status to PASS: `if standby_loss <= standby_loss_target: rule_status: "PASS"` - otherwise: `else:` - - set the note to indicate that the capacity per volume exceeds the limit: `rule_note = "Capacity per volume exceeds the limit of 4000 btu/hr/gallon for Electric Storage Water Heaters` - - check if the water heater is gas storage: `if type == "GAS_STORAGE":` - - check if the capacity is <= 75,000 btu/hr: `if input_capacity <= 75000:` - - if the storage volume is between 20 and 55 gallons: `if storage_volume >= 20 && storage_volume <= 55:` - - determine the UEF based on the draw pattern for VERY_SMALL: `if draw_pattern == "VERY_SMALL": expected_uef = 0.3456 – (0.0020 × storage_volume)` - - determine the UEF based on the draw pattern for LOW: `if draw_pattern == "LOW": expected_uef = 0.5982 – (0.0019 × storage_volume)` - - determine the UEF based on the draw pattern for MEDIUM: `if draw_pattern == "MEDIUM": expected_uef = 0.6483 – (0.0017 × storage_volume)` - - determine the UEF based on the draw pattern for HIGH: `if draw_pattern == "HIGH": expected_uef = 0.6920 – (0.0013 × storage_volume)` - - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.uniform_energy_factor >= expected_UEF:` - - set rule_status to "PASS": `rule_status = "PASS"` - - otherwise, set rule status to FAIL and provide the note that the expected UEF is less than the required UEF: `else: rule_status = "FAIL"; rule_note = "The modeled Uniform energy Factor (UEF - " + shw_eq.uniform_energy_factor + ") is less than required (" + expected_UEF + ")"` - - otherwise, if the storage volume is between 55 and 100 gallons: `elif storage_volume <= 100:` - - determine the UEF based on the draw pattern for VERY_SMALL: `if draw_pattern == "VERY_SMALL": expected_uef = 0.6470 – (0.0006 × storage_volume)` - - determine the UEF based on the draw pattern for LOW: `if draw_pattern == "LOW": expected_uef = 0.7689 – (0.0005 × storage_volume)` - - determine the UEF based on the draw pattern for MEDIUM: `if draw_pattern == "MEDIUM": expected_uef = 0.7897 – (0.0004 × storage_volume)` - - determine the UEF based on the draw pattern for HIGH: `if draw_pattern == "HIGH": expected_uef = 0.8072 – (0.0003 × storage_volume)` - - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.uniform_energy_factor >= expected_UEF:` - - set rule_status to "PASS": `rule_status = "PASS"` - - otherwise, set rule status to FAIL and provide the note that the expected UEF is less than the required UEF: `else: rule_status = "FAIL"; rule_note = "The modeled Uniform energy Factor (UEF - " + shw_eq.uniform_energy_factor + ") is less than required (" + expected_UEF + ")"` - - otherwise, the storage volume is either greater than 100 gallons, or between 2 and 20, which is not covered by Appendix F: `else:` - - create a note indicating that gas water heaters greater with input capacity < 75,000 btu/hr and the given storage volume are not covered under Appendix F: `rule_note: "Gas water heaters with an input capacity < 75,000 btu/hr and a storage capacity of " + storage_volume + " are not covered under Appendix F"` - - change rule_status to UNDETERMINED: `rule_status = "UNDETERMINED"` - - check if the capacity <= 105,000 btu/hr: `elif input_capacity <= 105000:` - - the capacity per volume should be < 4000 btu/hr/gallon: `if capacity_per_volume > 4000:` - - add the following text to the note: "For Gas Storage Water heaters, the capacity per volume should be less than 4000 btu/hr/gallon": `rule_note += "For Gas Storage Water heaters, the capacity per volume should be less than 4000 btu/hr/gallon. "` - - set has_fault to true: `has_fault = true` - - the volume should be <= 120 gallons: `if storage_volume > 120:` - - add the following text to the note: "For Gas Storage Water heaters with capacity less than 105,000 btu/hr, the storage capacity is expected to be less than 120 gallons": `rule_note += "For Gas Storage Water heaters with capacity less than 105,000 btu/hr, the storage capacity is expected to be less than 120 gallons. "` - - set has_fault to true: `has_fault = true` - - the supply water temperature should be <= 180F: `if shw_eq.setpoint_temperature > 180:` - - add the following text to the note: "For Gas Storage Water heaters with capacity less than 105,000 btu/hr, the supply water temperature is expected to be <= 180F": `rule_note += "For Gas Storage Water heaters with capacity less than 105,000 btu/hr, the supply water temperature is expected to be <= 180F. "` - - set has_fault to true: `has_fault = true` - - calculate the expected efficiency for VERY_SMALL draw pattern: `if draw_pattern == "VERY_SMALL": expected_UEF = 0.2674 – (0.0009 * volume)` - - calculate the expected efficiency for LOW draw pattern: `if draw_pattern == "LOW": expected_UEF = 0.5362 – (0.0012 * volume)` - - calculate the expected efficiency for MEDIUM draw pattern: `if draw_pattern == "MEDIUM": expected_UEF = 0.6002 – (0.0011 * volume)` - - calculate the expected efficiency for HIGH draw pattern: `if draw_pattern == "HIGH": expected_UEF = 0.6597 – (0.0009 * volume)` - - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.uniform_energy_factor >= expected_UEF && !has_faults:` - - set rule_status to "PASS": `rule_status = "PASS"` - - otherwise the capacity is > 105,000 btu/hr: `else:` - - the capacity per volume should be < 4000 btu/hr/gallon: `if capacity_per_volume > 4000:` - - add the following text to the note: "For Gas Storage Water heaters, the capacity per volume should be less than 4000 btu/hr/gallon": `rule_note += "For Gas Storage Water heaters, the capacity per volume should be less than 4000 btu/hr/gallon. "` - - set has_fault to true: `has_fault = true` - - calculate the expected_thermal_efficiency : `expected_thermal_efficiency = 0.8` - - calculate max_standby_loss (btu/hr): `max_standby_loss = (input_capacity/800 + 110 * sqrt(volume))` - - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.thermal_efficiency >= expected_thermal_efficiency && standby_loss <= max_standby_loss && !has_faults:` + - set the note to indicate that the standby_loss is higher than the maximum allowed: `rule_note = "Standby Loss is higher than required by Table 7.8"` + - otherwise: `else:` + - set the note to indicate that the capacity per volume exceeds the limit: `rule_note = "Capacity per volume exceeds the limit of 4000 btu/hr/gallon for Electric Storage Water Heaters` + - check if the water heater is gas storage: `if type == "GAS_STORAGE":` + - check if the capacity is <= 75,000 btu/hr: `if input_capacity <= 75000:` + - if the storage volume is between 20 and 55 gallons: `if storage_volume >= 20 && storage_volume <= 55:` + - determine the UEF based on the draw pattern for VERY_SMALL: `if draw_pattern == "VERY_SMALL": expected_uef = 0.3456 – (0.0020 × storage_volume)` + - determine the UEF based on the draw pattern for LOW: `if draw_pattern == "LOW": expected_uef = 0.5982 – (0.0019 × storage_volume)` + - determine the UEF based on the draw pattern for MEDIUM: `if draw_pattern == "MEDIUM": expected_uef = 0.6483 – (0.0017 × storage_volume)` + - determine the UEF based on the draw pattern for HIGH: `if draw_pattern == "HIGH": expected_uef = 0.6920 – (0.0013 × storage_volume)` + - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.uniform_energy_factor >= expected_UEF:` - set rule_status to "PASS": `rule_status = "PASS"` - - check if the water heater is OIL_STORAGE: `elif type == "OIL_STORAGE` - - if the input capacity < 105,000 btu/hr, this equipment is covered under Appendix F: `if input_capacity < 105000:` - - look to see if the water heater is covered in Appendix F, first look to see if it is anything less than 50 gallons of storage: `if storage_volume < 50:` - - determine the UEF based on the draw pattern for VERY_SMALL: `if draw_pattern == "VERY_SMALL": expected_uef = 0.2509 – (0.0012 × storage_volume)` - - determine the UEF based on the draw pattern for LOW: `if draw_pattern == "LOW": expected_uef = 0.5330 – (0.0016 × storage_volume)` - - determine the UEF based on the draw pattern for MEDIUM: `if draw_pattern == "MEDIUM": expected_uef = 0.6078 – (0.0016 × storage_volume)` - - determine the UEF based on the draw pattern for HIGH: `if draw_pattern == "HIGH": expected_uef = 0.6815 – (0.0014 × storage_volume)` - - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.uniform_energy_factor >= expected_UEF:` - - set rule_status to "PASS": `rule_status = "PASS"` - - otherwise, set rule status to FAIL and provide the note that the expected UEF is less than the required UEF: `else: rule_status = "FAIL"; rule_note = "The modeled Uniform energy Factor (UEF - " + shw_eq.uniform_energy_factor + ") is less than required (" + expected_UEF + ")"` - - otherwise, the storage volume is greater 50 gallons and is not covered by Appendix F: `else:` - - create a note indicating that gas water heaters with storage volume greater than 50 gallons are not covered under Appendix F: `rule_note: "Gas water heaters with a storage volume greater than 50 gallons are not covered under Appendix F"` - - change rule_status to UNDETERMINED: `rule_status = "UNDETERMINED"` - - else if the input capacity is < 140,000 btu/hr: `elif input_capacity < 140000:` - - calculate the expected efficiency for VERY_SMALL draw pattern: `if draw_pattern == "VERY_SMALL": expected_UEF = 0.2932 – (0.0015 * volume)` - - calculate the expected efficiency for LOW draw pattern: `if draw_pattern == "LOW": expected_UEF = 0.5596 – (0.0018 * volume)` - - calculate the expected efficiency for MEDIUM draw pattern: `if draw_pattern == "MEDIUM": expected_UEF = 0.6194 – (0.0016 * volume)` - - calculate the expected efficiency for HIGH draw pattern: `if draw_pattern == "HIGH": expected_UEF = 0.6740 – (0.0013 * volume)` - - check that the storage volume is <= 120 gallons: `if volume > 120 gallons:` - - add the following text to the note: "For Oil Storage heaters, with capacity < 140,000 btu/hr, the storage volume should be <= 120 gallons.": `rule_note += "For Oil Storage heaters, with capacity < 140,000 btu/hr, the storage volume should be <= 120 gallons. "` - - set has_fault to true: `has_fault = true` - - the capacity per volume should be < 4000 btu/hr/gallon: `if capacity_per_volume >= 4000:` - - add the following text to the note: "For Oil Storage heaters, with capacity < 140,000 btu/hr, the capacity per volume should be < 4000 btu/hr/gallon.": `rule_note += "For Oil Storage heaters, with capacity < 140,000 btu/hr, the capacity per volume should be < 4000 btu/hr/gallon. "` - - set has_fault to true: `has_fault = true` - - the setpoint temperature should be less than or equal to 180F: `if shw_eq.setpoint_temperature > 180:` - - add the following text to the note: "For Oil Storage Water heaters, the supply water temperature must be <= 180F": `rule_note += "For Oil Storage Water heaters, the supply water temperature must be <= 180F"` - - set has_fault to true: `has_fault = true` - - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.uniform_energy_factor >= expected_UEF && !has_faults:` + - otherwise, set rule status to FAIL and provide the note that the expected UEF is less than the required UEF: `else: rule_status = "FAIL"; rule_note = "The modeled Uniform energy Factor (UEF - " + shw_eq.uniform_energy_factor + ") is less than required (" + expected_UEF + ")"` + - otherwise, if the storage volume is between 55 and 100 gallons: `elif storage_volume <= 100:` + - determine the UEF based on the draw pattern for VERY_SMALL: `if draw_pattern == "VERY_SMALL": expected_uef = 0.6470 – (0.0006 × storage_volume)` + - determine the UEF based on the draw pattern for LOW: `if draw_pattern == "LOW": expected_uef = 0.7689 – (0.0005 × storage_volume)` + - determine the UEF based on the draw pattern for MEDIUM: `if draw_pattern == "MEDIUM": expected_uef = 0.7897 – (0.0004 × storage_volume)` + - determine the UEF based on the draw pattern for HIGH: `if draw_pattern == "HIGH": expected_uef = 0.8072 – (0.0003 × storage_volume)` + - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.uniform_energy_factor >= expected_UEF:` - set rule_status to "PASS": `rule_status = "PASS"` - - else the input capacity is >= 140,000 btu/hr: `else:` - - the capacity per volume should be < 4000 btu/hr/gallon: `if capacity_per_volume >= 4000:` - - add the following text to the note: "For Oil Storage heaters, with capacity > 140,000 btu/hr, the capacity per volume should be < 4000 btu/hr/gallon.": `rule_note += "For Oil Storage heaters, with capacity < 140,000 btu/hr, the capacity per volume should be < 4000 btu/hr/gallon. "` - - set has_fault to true: `has_fault = true` - - set the expected thermal efficiency to 0.8: `expected_thermal_efficiency = 0.8` - - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.thermal_efficiency >= expected_thermal_efficiency && !has_faults:` + - otherwise, set rule status to FAIL and provide the note that the expected UEF is less than the required UEF: `else: rule_status = "FAIL"; rule_note = "The modeled Uniform energy Factor (UEF - " + shw_eq.uniform_energy_factor + ") is less than required (" + expected_UEF + ")"` + - otherwise, the storage volume is either greater than 100 gallons, or between 2 and 20, which is not covered by Appendix F: `else:` + - create a note indicating that gas water heaters greater with input capacity < 75,000 btu/hr and the given storage volume are not covered under Appendix F: `rule_note: "Gas water heaters with an input capacity < 75,000 btu/hr and a storage capacity of " + storage_volume + " are not covered under Appendix F"` + - change rule_status to UNDETERMINED: `rule_status = "UNDETERMINED"` + - check if the capacity <= 105,000 btu/hr: `elif input_capacity <= 105000:` + - the capacity per volume should be < 4000 btu/hr/gallon: `if capacity_per_volume > 4000:` + - add the following text to the note: "For Gas Storage Water heaters, the capacity per volume should be less than 4000 btu/hr/gallon": `rule_note += "For Gas Storage Water heaters, the capacity per volume should be less than 4000 btu/hr/gallon. "` + - set has_fault to true: `has_fault = true` + - the volume should be <= 120 gallons: `if storage_volume > 120:` + - add the following text to the note: "For Gas Storage Water heaters with capacity less than 105,000 btu/hr, the storage capacity is expected to be less than 120 gallons": `rule_note += "For Gas Storage Water heaters with capacity less than 105,000 btu/hr, the storage capacity is expected to be less than 120 gallons. "` + - set has_fault to true: `has_fault = true` + - the supply water temperature should be <= 180F: `if shw_eq.setpoint_temperature > 180:` + - add the following text to the note: "For Gas Storage Water heaters with capacity less than 105,000 btu/hr, the supply water temperature is expected to be <= 180F": `rule_note += "For Gas Storage Water heaters with capacity less than 105,000 btu/hr, the supply water temperature is expected to be <= 180F. "` + - set has_fault to true: `has_fault = true` + - calculate the expected efficiency for VERY_SMALL draw pattern: `if draw_pattern == "VERY_SMALL": expected_UEF = 0.2674 – (0.0009 * volume)` + - calculate the expected efficiency for LOW draw pattern: `if draw_pattern == "LOW": expected_UEF = 0.5362 – (0.0012 * volume)` + - calculate the expected efficiency for MEDIUM draw pattern: `if draw_pattern == "MEDIUM": expected_UEF = 0.6002 – (0.0011 * volume)` + - calculate the expected efficiency for HIGH draw pattern: `if draw_pattern == "HIGH": expected_UEF = 0.6597 – (0.0009 * volume)` + - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.uniform_energy_factor >= expected_UEF && !has_faults:` + - set rule_status to "PASS": `rule_status = "PASS"` + - otherwise the capacity is > 105,000 btu/hr: `else:` + - the capacity per volume should be < 4000 btu/hr/gallon: `if capacity_per_volume > 4000:` + - add the following text to the note: "For Gas Storage Water heaters, the capacity per volume should be less than 4000 btu/hr/gallon": `rule_note += "For Gas Storage Water heaters, the capacity per volume should be less than 4000 btu/hr/gallon. "` + - set has_fault to true: `has_fault = true` + - calculate the expected_thermal_efficiency : `expected_thermal_efficiency = 0.8` + - calculate max_standby_loss (btu/hr): `max_standby_loss = (input_capacity/800 + 110 * sqrt(volume))` + - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.thermal_efficiency >= expected_thermal_efficiency && standby_loss <= max_standby_loss && !has_faults:` + - set rule_status to "PASS": `rule_status = "PASS"` + - check if the water heater is OIL_STORAGE: `elif type == "OIL_STORAGE` + - if the input capacity < 105,000 btu/hr, this equipment is covered under Appendix F: `if input_capacity < 105000:` + - look to see if the water heater is covered in Appendix F, first look to see if it is anything less than 50 gallons of storage: `if storage_volume < 50:` + - determine the UEF based on the draw pattern for VERY_SMALL: `if draw_pattern == "VERY_SMALL": expected_uef = 0.2509 – (0.0012 × storage_volume)` + - determine the UEF based on the draw pattern for LOW: `if draw_pattern == "LOW": expected_uef = 0.5330 – (0.0016 × storage_volume)` + - determine the UEF based on the draw pattern for MEDIUM: `if draw_pattern == "MEDIUM": expected_uef = 0.6078 – (0.0016 × storage_volume)` + - determine the UEF based on the draw pattern for HIGH: `if draw_pattern == "HIGH": expected_uef = 0.6815 – (0.0014 × storage_volume)` + - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.uniform_energy_factor >= expected_UEF:` - set rule_status to "PASS": `rule_status = "PASS"` - - **Rule Assertion - Zone:** - - Case1: type is INSTANTANEOUS - there is no baseline instantaneous water heater types: `if type == "INSTANTANEOUS": UNDETERMINED; rule_node = "There baseline water heater is of an Instantaneous type. There are no acceptable instantaneous baseline water heaters in Table G3.1.1-2." - - Case2: rule_status is PASS: `if rule_status == "PASS": PASS`. - - Case3: rule_status is UNDETERMINED, UNDETERMINED & return rule_note: `elif rule_status == "UNDETERMINED": UNDETERMINED; rule_note` - - Case4: rule_status is FAIL, FAIL & return rule_note: `elif rule_status == "FAIL": FAIL; rule_note` + - otherwise, set rule status to FAIL and provide the note that the expected UEF is less than the required UEF: `else: rule_status = "FAIL"; rule_note = "The modeled Uniform energy Factor (UEF - " + shw_eq.uniform_energy_factor + ") is less than required (" + expected_UEF + ")"` + - otherwise, the storage volume is greater 50 gallons and is not covered by Appendix F: `else:` + - create a note indicating that gas water heaters with storage volume greater than 50 gallons are not covered under Appendix F: `rule_note: "Gas water heaters with a storage volume greater than 50 gallons are not covered under Appendix F"` + - change rule_status to UNDETERMINED: `rule_status = "UNDETERMINED"` + - else if the input capacity is < 140,000 btu/hr: `elif input_capacity < 140000:` + - calculate the expected efficiency for VERY_SMALL draw pattern: `if draw_pattern == "VERY_SMALL": expected_UEF = 0.2932 – (0.0015 * volume)` + - calculate the expected efficiency for LOW draw pattern: `if draw_pattern == "LOW": expected_UEF = 0.5596 – (0.0018 * volume)` + - calculate the expected efficiency for MEDIUM draw pattern: `if draw_pattern == "MEDIUM": expected_UEF = 0.6194 – (0.0016 * volume)` + - calculate the expected efficiency for HIGH draw pattern: `if draw_pattern == "HIGH": expected_UEF = 0.6740 – (0.0013 * volume)` + - check that the storage volume is <= 120 gallons: `if volume > 120 gallons:` + - add the following text to the note: "For Oil Storage heaters, with capacity < 140,000 btu/hr, the storage volume should be <= 120 gallons.": `rule_note += "For Oil Storage heaters, with capacity < 140,000 btu/hr, the storage volume should be <= 120 gallons. "` + - set has_fault to true: `has_fault = true` + - the capacity per volume should be < 4000 btu/hr/gallon: `if capacity_per_volume >= 4000:` + - add the following text to the note: "For Oil Storage heaters, with capacity < 140,000 btu/hr, the capacity per volume should be < 4000 btu/hr/gallon.": `rule_note += "For Oil Storage heaters, with capacity < 140,000 btu/hr, the capacity per volume should be < 4000 btu/hr/gallon. "` + - set has_fault to true: `has_fault = true` + - the setpoint temperature should be less than or equal to 180F: `if shw_eq.setpoint_temperature > 180:` + - add the following text to the note: "For Oil Storage Water heaters, the supply water temperature must be <= 180F": `rule_note += "For Oil Storage Water heaters, the supply water temperature must be <= 180F"` + - set has_fault to true: `has_fault = true` + - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.uniform_energy_factor >= expected_UEF && !has_faults:` + - set rule_status to "PASS": `rule_status = "PASS"` + - else the input capacity is >= 140,000 btu/hr: `else:` + - the capacity per volume should be < 4000 btu/hr/gallon: `if capacity_per_volume >= 4000:` + - add the following text to the note: "For Oil Storage heaters, with capacity > 140,000 btu/hr, the capacity per volume should be < 4000 btu/hr/gallon.": `rule_note += "For Oil Storage heaters, with capacity < 140,000 btu/hr, the capacity per volume should be < 4000 btu/hr/gallon. "` + - set has_fault to true: `has_fault = true` + - set the expected thermal efficiency to 0.8: `expected_thermal_efficiency = 0.8` + - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.thermal_efficiency >= expected_thermal_efficiency && !has_faults:` + - set rule_status to "PASS": `rule_status = "PASS"` + + **Rule Assertion - Zone:** + - Case1: type is INSTANTANEOUS - there is no baseline instantaneous water heater types: `if type == "INSTANTANEOUS": UNDETERMINED; rule_node = "There baseline water heater is of an Instantaneous type. There are no acceptable instantaneous baseline water heaters in Table G3.1.1-2." + - Case2: rule_status is PASS: `if rule_status == "PASS": PASS`. + - Case3: rule_status is UNDETERMINED, UNDETERMINED & return rule_note: `elif rule_status == "UNDETERMINED": UNDETERMINED; rule_note` + - Case4: rule_status is FAIL, FAIL & return rule_note: `elif rule_status == "FAIL": FAIL; rule_note` **Notes:** From 8a3728719292f54cffc706d8ca4a7ee023999455 Mon Sep 17 00:00:00 2001 From: KarenWGard <114143532+KarenWGard@users.noreply.github.com> Date: Wed, 19 Jun 2024 16:05:47 -0400 Subject: [PATCH 09/25] Update Rule_11-10.md --- docs/section11/Rule_11-10.md | 42 ++++++++++++++++++------------------ 1 file changed, 21 insertions(+), 21 deletions(-) diff --git a/docs/section11/Rule_11-10.md b/docs/section11/Rule_11-10.md index 90e05ae78e..8b81defb04 100644 --- a/docs/section11/Rule_11-10.md +++ b/docs/section11/Rule_11-10.md @@ -1,6 +1,6 @@ s# HVAC_SystemZoneAssignment - Rule 11-10 -**Schema Version:** 0.0.36 +**Schema Version:** 0.0.37 **Mandatory Rule:** True **Rule ID:** 11-10 @@ -26,7 +26,7 @@ s# HVAC_SystemZoneAssignment - Rule 11-10 - create a value to track the rule status: `rule_status = "FAIL"` - create a variable to track any notes: `rule_note = """` - we need to find the following information about the SWH: - - type - (ELECTRIC_RESISTANCE_INSTANTANEOUS, ELECTRIC_RESISTANCE_STORAGE, GAS_STORAGE, OTHER) + - swh_type - (ELECTRIC_RESISTANCE_INSTANTANEOUS, ELECTRIC_RESISTANCE_STORAGE, GAS_STORAGE, OTHER) - swh_type - one of the SWH BATs - input_capacity (btu/hr) - storage_volume (gallons) @@ -36,14 +36,14 @@ s# HVAC_SystemZoneAssignment - Rule 11-10 - get the type of tank: `tank_type = swh_eq.tank.type` - get the type of heater: `swh_type = swh_eq.heater_type` - the type will be one of the ServiceWaterHeaterTankOptions, which are more detailed than the four types we need. Determine our type based on the detailed type. - - set the type to OTHER. If the tank_type is an identifiable type, type will be overwritten to that type: `type = "OTHER"` - - if the tank_type is CONSUMER_INSTANTANEOUS, COMMERCIAL_INSTANTANEOUS, or RESIDENTIAL_DUTY_COMMERCIAL_INSTANTANEOUS, set the type to INSTANTANEOUS and go to rule assertion: `if tank_type in ["CONSUMER_INSTANTANEOUS", "COMMERCIAL_INSTANTANEOUS", "RESIDENTIAL_DUTY_COMMERCIAL_INSTANTANEOUS"]: type = "INSTANTANEOUS"`; GO TO RULE_ASSERTION + - set the swh_type to OTHER. If the tank_type is an identifiable type, swh_type will be overwritten to that type: `swh_type = "OTHER"` + - if the tank_type is CONSUMER_INSTANTANEOUS, COMMERCIAL_INSTANTANEOUS, or RESIDENTIAL_DUTY_COMMERCIAL_INSTANTANEOUS, set the swh_type to INSTANTANEOUS and go to rule assertion: `if tank_type in ["CONSUMER_INSTANTANEOUS", "COMMERCIAL_INSTANTANEOUS", "RESIDENTIAL_DUTY_COMMERCIAL_INSTANTANEOUS"]: swh_type = "INSTANTANEOUS"`; GO TO RULE_ASSERTION - get the fuel type of the equipment: `fuel_type = shw_eq.heater_fuel_type` - - if the tank_type is CONSUMER_STORAGE or COMMERCIAL_STORAGE, set the type to STORAGE for the fuel type: `if tank_type in ["CONSUMER_STORAGE", "COMMERCIAL_STORAGE"]:` - - set the type based on tank_type and fuel type: `if fuel_type == "ELECTRICITY": type = "ELECTRIC_RESISTANCE_STORAGE` - - `elif fuel_type == "NATURAL_GAS": type = "GAS_STORAGE` - - `elif fuel_type == "FUEL_OIL": type = "OIL_STORAGE` + - if the tank_type is CONSUMER_STORAGE or COMMERCIAL_STORAGE, set the swh_type to STORAGE for the fuel type: `if tank_type in ["CONSUMER_STORAGE", "COMMERCIAL_STORAGE"]:` + - set the swh_type based on tank_type and fuel type: `if fuel_type == "ELECTRICITY": swh_type = "ELECTRIC_RESISTANCE_STORAGE` + - `elif fuel_type == "NATURAL_GAS": swh_type = "GAS_STORAGE` + - `elif fuel_type == "FUEL_OIL": swh_type = "OIL_STORAGE` - if the draw_pattern is given, get the draw pattern: `if shw_eq.draw_pattern != nil: draw_pattern = shw_eq.draw_pattern` - otherwise, determine the draw pattern based off the first_hour_rating of the shw_eq: `else:` - First get the first hour rating (gallons): `first_hour_rating = shw_eq.first_hour_rating` @@ -56,10 +56,10 @@ s# HVAC_SystemZoneAssignment - Rule 11-10 - calculate the capacity_per_volume based on the input_capacity and the storage_volume: `capacity_per_volume = shw_eq.rated_capacity / storage_volume` - get the standby loss (see note 1 for calculation source): `standby_loss = swh_eq.standby_loss_fraction * 8.25 * volume * 70` - what follows is logic that implements Table 7.8 - this table has multiple criteria, so I think it's simpler to implement with if / else logic than a table lookup - - if the type is OTHER, set rule_note to "Water heater type is not a recognized type": `if type == "OTHER": rule_note = "Water heater type is not a recognized type"` + - if the swh_type is OTHER, set rule_note to "Water heater type is not a recognized type": `if swh_type == "OTHER": rule_note = "Water heater type is not a recognized type"` - otherwise, continue with rule logic: `else:` - create a boolean has_fault and set it to false: `has_fault = false` - - if the water heater is electric resistance, or storage and the capacity is <= 12kW (40945 btu/hr), look at Appendix F: `if type in ["ELECTRIC_RESISTANCE_STORAGE"] && input_capacity <= 40945.7:` + - if the water heater is electric resistance, or storage and the capacity is <= 12kW (40945 btu/hr), look at Appendix F: `if swh_type in ["ELECTRIC_RESISTANCE_STORAGE"] && input_capacity <= 40945.7:` - check the size of the storage tank. If it's less than 2 gallons: `if storage_volume < 2:` - if the draw pattern is HIGH, the expected UEF is 0.92, for draw all draw patterns other draw patterns, it is 0.91: `if draw_pattern == "HIGH": expected_UEF = 0.92; else: expected_UEF = 0.91` - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.uniform_energy_factor >= expected_UEF:` @@ -76,7 +76,7 @@ s# HVAC_SystemZoneAssignment - Rule 11-10 - else, if the storage tank is greater than 55 and less than 100 gallons, Appendix F provides a heat pump efficiency, or the storage volume is between 2 and 20 gallons, in which case there is no rating in APPENDIX F. return UNDETERMINED: `else:` - set rule_status to UNDETERMINED: `rule_status = "UNDETERMINED"` - otherwise, continue with rule logic: `else:` - - check electric storage water heaters with capacity greater than 12 kW: `if type == "ELECTRIC_RESISTANCE_STORAGE" && input_capacity > 40945.7:` + - check electric storage water heaters with capacity greater than 12 kW: `if swh_type == "ELECTRIC_RESISTANCE_STORAGE" && input_capacity > 40945.7:` - check that the capacity_per_volume < 4000 btu/hr/gallon: `if capacity_per_volume < 4000:` - calculate the standby loss target: `standby_loss_target = 0.3 + (27/swh_eq.distribution_system.tank.storage_volume)` - if the standby_loss is less than or equal to the target, set the rule_status to PASS: `if standby_loss <= standby_loss_target: rule_status: "PASS"` @@ -84,7 +84,7 @@ s# HVAC_SystemZoneAssignment - Rule 11-10 - set the note to indicate that the standby_loss is higher than the maximum allowed: `rule_note = "Standby Loss is higher than required by Table 7.8"` - otherwise: `else:` - set the note to indicate that the capacity per volume exceeds the limit: `rule_note = "Capacity per volume exceeds the limit of 4000 btu/hr/gallon for Electric Storage Water Heaters` - - check if the water heater is gas storage: `if type == "GAS_STORAGE":` + - check if the water heater is gas storage: `if swh_type == "GAS_STORAGE":` - check if the capacity is <= 75,000 btu/hr: `if input_capacity <= 75000:` - if the storage volume is between 20 and 55 gallons: `if storage_volume >= 20 && storage_volume <= 55:` - determine the UEF based on the draw pattern for VERY_SMALL: `if draw_pattern == "VERY_SMALL": expected_uef = 0.3456 – (0.0020 × storage_volume)` @@ -106,7 +106,7 @@ s# HVAC_SystemZoneAssignment - Rule 11-10 - create a note indicating that gas water heaters greater with input capacity < 75,000 btu/hr and the given storage volume are not covered under Appendix F: `rule_note: "Gas water heaters with an input capacity < 75,000 btu/hr and a storage capacity of " + storage_volume + " are not covered under Appendix F"` - change rule_status to UNDETERMINED: `rule_status = "UNDETERMINED"` - check if the capacity <= 105,000 btu/hr: `elif input_capacity <= 105000:` - - the capacity per volume should be < 4000 btu/hr/gallon: `if capacity_per_volume > 4000:` + - the capacity per volume should be < 4000 btu/hr/gallon: `if capacity_per_volume >= 4000:` - add the following text to the note: "For Gas Storage Water heaters, the capacity per volume should be less than 4000 btu/hr/gallon": `rule_note += "For Gas Storage Water heaters, the capacity per volume should be less than 4000 btu/hr/gallon. "` - set has_fault to true: `has_fault = true` - the volume should be <= 120 gallons: `if storage_volume > 120:` @@ -122,15 +122,15 @@ s# HVAC_SystemZoneAssignment - Rule 11-10 - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.uniform_energy_factor >= expected_UEF && !has_faults:` - set rule_status to "PASS": `rule_status = "PASS"` - otherwise the capacity is > 105,000 btu/hr: `else:` - - the capacity per volume should be < 4000 btu/hr/gallon: `if capacity_per_volume > 4000:` + - the capacity per volume should be < 4000 btu/hr/gallon: `if capacity_per_volume >= 4000:` - add the following text to the note: "For Gas Storage Water heaters, the capacity per volume should be less than 4000 btu/hr/gallon": `rule_note += "For Gas Storage Water heaters, the capacity per volume should be less than 4000 btu/hr/gallon. "` - set has_fault to true: `has_fault = true` - calculate the expected_thermal_efficiency : `expected_thermal_efficiency = 0.8` - calculate max_standby_loss (btu/hr): `max_standby_loss = (input_capacity/800 + 110 * sqrt(volume))` - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.thermal_efficiency >= expected_thermal_efficiency && standby_loss <= max_standby_loss && !has_faults:` - set rule_status to "PASS": `rule_status = "PASS"` - - check if the water heater is OIL_STORAGE: `elif type == "OIL_STORAGE` - - if the input capacity < 105,000 btu/hr, this equipment is covered under Appendix F: `if input_capacity < 105000:` + - check if the water heater is OIL_STORAGE: `elif swh_type == "OIL_STORAGE` + - if the input capacity <= 105,000 btu/hr, this equipment is covered under Appendix F: `if input_capacity <= 105000:` - look to see if the water heater is covered in Appendix F, first look to see if it is anything less than 50 gallons of storage: `if storage_volume < 50:` - determine the UEF based on the draw pattern for VERY_SMALL: `if draw_pattern == "VERY_SMALL": expected_uef = 0.2509 – (0.0012 × storage_volume)` - determine the UEF based on the draw pattern for LOW: `if draw_pattern == "LOW": expected_uef = 0.5330 – (0.0016 × storage_volume)` @@ -142,16 +142,16 @@ s# HVAC_SystemZoneAssignment - Rule 11-10 - otherwise, the storage volume is greater 50 gallons and is not covered by Appendix F: `else:` - create a note indicating that gas water heaters with storage volume greater than 50 gallons are not covered under Appendix F: `rule_note: "Gas water heaters with a storage volume greater than 50 gallons are not covered under Appendix F"` - change rule_status to UNDETERMINED: `rule_status = "UNDETERMINED"` - - else if the input capacity is < 140,000 btu/hr: `elif input_capacity < 140000:` + - else if the input capacity is <= 140,000 btu/hr: `elif input_capacity <= 140000:` - calculate the expected efficiency for VERY_SMALL draw pattern: `if draw_pattern == "VERY_SMALL": expected_UEF = 0.2932 – (0.0015 * volume)` - calculate the expected efficiency for LOW draw pattern: `if draw_pattern == "LOW": expected_UEF = 0.5596 – (0.0018 * volume)` - calculate the expected efficiency for MEDIUM draw pattern: `if draw_pattern == "MEDIUM": expected_UEF = 0.6194 – (0.0016 * volume)` - calculate the expected efficiency for HIGH draw pattern: `if draw_pattern == "HIGH": expected_UEF = 0.6740 – (0.0013 * volume)` - check that the storage volume is <= 120 gallons: `if volume > 120 gallons:` - - add the following text to the note: "For Oil Storage heaters, with capacity < 140,000 btu/hr, the storage volume should be <= 120 gallons.": `rule_note += "For Oil Storage heaters, with capacity < 140,000 btu/hr, the storage volume should be <= 120 gallons. "` + - add the following text to the note: "For Oil Storage heaters, with capacity <= 140,000 btu/hr, the storage volume should be <= 120 gallons.": `rule_note += "For Oil Storage heaters, with capacity <= 140,000 btu/hr, the storage volume should be <= 120 gallons. "` - set has_fault to true: `has_fault = true` - the capacity per volume should be < 4000 btu/hr/gallon: `if capacity_per_volume >= 4000:` - - add the following text to the note: "For Oil Storage heaters, with capacity < 140,000 btu/hr, the capacity per volume should be < 4000 btu/hr/gallon.": `rule_note += "For Oil Storage heaters, with capacity < 140,000 btu/hr, the capacity per volume should be < 4000 btu/hr/gallon. "` + - add the following text to the note: "For Oil Storage heaters, with capacity <= 140,000 btu/hr, the capacity per volume should be < 4000 btu/hr/gallon.": `rule_note += "For Oil Storage heaters, with capacity <= 140,000 btu/hr, the capacity per volume should be < 4000 btu/hr/gallon. "` - set has_fault to true: `has_fault = true` - the setpoint temperature should be less than or equal to 180F: `if shw_eq.setpoint_temperature > 180:` - add the following text to the note: "For Oil Storage Water heaters, the supply water temperature must be <= 180F": `rule_note += "For Oil Storage Water heaters, the supply water temperature must be <= 180F"` @@ -160,14 +160,14 @@ s# HVAC_SystemZoneAssignment - Rule 11-10 - set rule_status to "PASS": `rule_status = "PASS"` - else the input capacity is >= 140,000 btu/hr: `else:` - the capacity per volume should be < 4000 btu/hr/gallon: `if capacity_per_volume >= 4000:` - - add the following text to the note: "For Oil Storage heaters, with capacity > 140,000 btu/hr, the capacity per volume should be < 4000 btu/hr/gallon.": `rule_note += "For Oil Storage heaters, with capacity < 140,000 btu/hr, the capacity per volume should be < 4000 btu/hr/gallon. "` + - add the following text to the note: "For Oil Storage heaters, with capacity > 140,000 btu/hr, the capacity per volume should be < 4000 btu/hr/gallon.": `rule_note += "For Oil Storage heaters, with capacity <= 140,000 btu/hr, the capacity per volume should be < 4000 btu/hr/gallon. "` - set has_fault to true: `has_fault = true` - set the expected thermal efficiency to 0.8: `expected_thermal_efficiency = 0.8` - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.thermal_efficiency >= expected_thermal_efficiency && !has_faults:` - set rule_status to "PASS": `rule_status = "PASS"` **Rule Assertion - Zone:** - - Case1: type is INSTANTANEOUS - there is no baseline instantaneous water heater types: `if type == "INSTANTANEOUS": UNDETERMINED; rule_node = "There baseline water heater is of an Instantaneous type. There are no acceptable instantaneous baseline water heaters in Table G3.1.1-2." + - Case1: swh_type is INSTANTANEOUS - there is no baseline instantaneous water heater types: `if swh_type == "INSTANTANEOUS": UNDETERMINED; rule_node = "There baseline water heater is of an Instantaneous type. There are no acceptable instantaneous baseline water heaters in Table G3.1.1-2."` - Case2: rule_status is PASS: `if rule_status == "PASS": PASS`. - Case3: rule_status is UNDETERMINED, UNDETERMINED & return rule_note: `elif rule_status == "UNDETERMINED": UNDETERMINED; rule_note` - Case4: rule_status is FAIL, FAIL & return rule_note: `elif rule_status == "FAIL": FAIL; rule_note` From 9a198dd07ef44664eb1aa28a77a6b5fc68e68620 Mon Sep 17 00:00:00 2001 From: KarenWGard <114143532+KarenWGard@users.noreply.github.com> Date: Wed, 30 Oct 2024 15:45:57 -0400 Subject: [PATCH 10/25] Update Rule_11-10.md --- docs/section11/Rule_11-10.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/section11/Rule_11-10.md b/docs/section11/Rule_11-10.md index 8b81defb04..31c93a4bf8 100644 --- a/docs/section11/Rule_11-10.md +++ b/docs/section11/Rule_11-10.md @@ -167,7 +167,7 @@ s# HVAC_SystemZoneAssignment - Rule 11-10 - set rule_status to "PASS": `rule_status = "PASS"` **Rule Assertion - Zone:** - - Case1: swh_type is INSTANTANEOUS - there is no baseline instantaneous water heater types: `if swh_type == "INSTANTANEOUS": UNDETERMINED; rule_node = "There baseline water heater is of an Instantaneous type. There are no acceptable instantaneous baseline water heaters in Table G3.1.1-2."` + - Case1: swh_type is INSTANTANEOUS - there is no baseline instantaneous water heater types: `if swh_type == "INSTANTANEOUS": UNDETERMINED; rule_note = "There baseline water heater is of an Instantaneous type. There are no acceptable instantaneous baseline water heaters in Table G3.1.1-2."` - Case2: rule_status is PASS: `if rule_status == "PASS": PASS`. - Case3: rule_status is UNDETERMINED, UNDETERMINED & return rule_note: `elif rule_status == "UNDETERMINED": UNDETERMINED; rule_note` - Case4: rule_status is FAIL, FAIL & return rule_note: `elif rule_status == "FAIL": FAIL; rule_note` From c6100ca67973558ab08a8d9a3a1160a3e9c3e45f Mon Sep 17 00:00:00 2001 From: KarenWGard <114143532+KarenWGard@users.noreply.github.com> Date: Wed, 13 Nov 2024 15:53:18 -0500 Subject: [PATCH 11/25] Update Rule_11-10.md --- docs/section11/Rule_11-10.md | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) diff --git a/docs/section11/Rule_11-10.md b/docs/section11/Rule_11-10.md index 31c93a4bf8..ff76d87d17 100644 --- a/docs/section11/Rule_11-10.md +++ b/docs/section11/Rule_11-10.md @@ -61,7 +61,7 @@ s# HVAC_SystemZoneAssignment - Rule 11-10 - create a boolean has_fault and set it to false: `has_fault = false` - if the water heater is electric resistance, or storage and the capacity is <= 12kW (40945 btu/hr), look at Appendix F: `if swh_type in ["ELECTRIC_RESISTANCE_STORAGE"] && input_capacity <= 40945.7:` - check the size of the storage tank. If it's less than 2 gallons: `if storage_volume < 2:` - - if the draw pattern is HIGH, the expected UEF is 0.92, for draw all draw patterns other draw patterns, it is 0.91: `if draw_pattern == "HIGH": expected_UEF = 0.92; else: expected_UEF = 0.91` + - if the draw pattern is HIGH, the expected UEF is 0.92, for draw all other draw patterns, it is 0.91: `if draw_pattern == "HIGH": expected_UEF = 0.92; else: expected_UEF = 0.91` - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.uniform_energy_factor >= expected_UEF:` - set rule_status to "PASS": `rule_status = "PASS"` - otherwise, set rule status to FAIL and provide the note that the expected UEF is less than the required UEF: `else: rule_status = "FAIL"; rule_note = "The modeled Uniform energy Factor (UEF - " + shw_eq.uniform_energy_factor + ") is less than required (" + expected_UEF + ")"` @@ -73,12 +73,17 @@ s# HVAC_SystemZoneAssignment - Rule 11-10 - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.uniform_energy_factor >= expected_UEF:` - set rule_status to "PASS": `rule_status = "PASS"` - otherwise, set rule status to FAIL and provide the note that the expected UEF is less than the required UEF: `else: rule_status = "FAIL"; rule_note = "The modeled Uniform energy Factor (UEF - " + shw_eq.uniform_energy_factor + ") is less than required (" + expected_UEF + ")"` - - else, if the storage tank is greater than 55 and less than 100 gallons, Appendix F provides a heat pump efficiency, or the storage volume is between 2 and 20 gallons, in which case there is no rating in APPENDIX F. return UNDETERMINED: `else:` + - else, if the storage tank is greater than 55 and less than 100 gallons, Appendix F provides a heat pump efficiency, which may be an error. return UNDETERMINED: `elif storage_volume <=100 and storage_volume > 55:` - set rule_status to UNDETERMINED: `rule_status = "UNDETERMINED"` + - include a note: `rule_note = "The storage tank is between 55 and 100 gallons with a capacity <= 12kW (40945 btu/hr). Appendix F provides a heat pump efficiency for water heaters in this capacity range, but the RCT does not have a way to verify this efficiency." + - else if the storage volume is between 2 and 20 gallons, in which case there is no rating in APPENDIX F. set rule status to UNDETERMINED: `elif storage_volume < 20:` + - set the rule status to UNDETERMINED: `rule_status = "UNDETERMINED"` + - add a note: `rule_note = "The storage tank is between 2 and 20 gallons. Appendix F doesn't provide an efficiency for this water heaters of this size." - otherwise, continue with rule logic: `else:` - check electric storage water heaters with capacity greater than 12 kW: `if swh_type == "ELECTRIC_RESISTANCE_STORAGE" && input_capacity > 40945.7:` - check that the capacity_per_volume < 4000 btu/hr/gallon: `if capacity_per_volume < 4000:` - - calculate the standby loss target: `standby_loss_target = 0.3 + (27/swh_eq.distribution_system.tank.storage_volume)` + - calculate the standby loss target: `standby_loss_target = 0.3 + (27/swh_eq.distribution_system.tank.storage_volume)` + - - if the standby_loss is less than or equal to the target, set the rule_status to PASS: `if standby_loss <= standby_loss_target: rule_status: "PASS"` - otherwise: `else:` - set the note to indicate that the standby_loss is higher than the maximum allowed: `rule_note = "Standby Loss is higher than required by Table 7.8"` From ff33f1360230757c218c0e0aa85337dc41ec6209 Mon Sep 17 00:00:00 2001 From: KarenWGard <114143532+KarenWGard@users.noreply.github.com> Date: Wed, 13 Nov 2024 16:48:07 -0500 Subject: [PATCH 12/25] Update Rule_11-10.md --- docs/section11/Rule_11-10.md | 85 ++++++++++++++++++++++++------------ 1 file changed, 57 insertions(+), 28 deletions(-) diff --git a/docs/section11/Rule_11-10.md b/docs/section11/Rule_11-10.md index ff76d87d17..fa78a3aa47 100644 --- a/docs/section11/Rule_11-10.md +++ b/docs/section11/Rule_11-10.md @@ -54,7 +54,11 @@ s# HVAC_SystemZoneAssignment - Rule 11-10 - get the capacity of the SHW system (make sure to convert to btu/hr): `input_capacity = swh_eq.input_power` - get the volume of the tank (make sure to convert to gallons): `storage_volume = swh_eq.distribution_system.tank.storage_capacity` - calculate the capacity_per_volume based on the input_capacity and the storage_volume: `capacity_per_volume = shw_eq.rated_capacity / storage_volume` - - get the standby loss (see note 1 for calculation source): `standby_loss = swh_eq.standby_loss_fraction * 8.25 * volume * 70` + - get the efficiency metric values: `efficiency_metric_values = swh_eq.efficiency_metric_values` + - get the efficiency metric types: `efficiency_metric_types = swh_eq.efficiency_metric_types` + - create a dictionary of the efficiency data: `efficiency_metric_dict = dict(zip(efficiency_metric_types, efficiency_metric_values)) + - get the thermal efficiency: `thermal_efficiency = efficiency_metric_dict["THERMAL_EFFICIENCY"]` + - get the uniform energy factor: `uniform_energy_factor = efficiency_metric_dict["UNIFORM_ENERGY_FACTOR"]` - what follows is logic that implements Table 7.8 - this table has multiple criteria, so I think it's simpler to implement with if / else logic than a table lookup - if the swh_type is OTHER, set rule_note to "Water heater type is not a recognized type": `if swh_type == "OTHER": rule_note = "Water heater type is not a recognized type"` - otherwise, continue with rule logic: `else:` @@ -62,17 +66,21 @@ s# HVAC_SystemZoneAssignment - Rule 11-10 - if the water heater is electric resistance, or storage and the capacity is <= 12kW (40945 btu/hr), look at Appendix F: `if swh_type in ["ELECTRIC_RESISTANCE_STORAGE"] && input_capacity <= 40945.7:` - check the size of the storage tank. If it's less than 2 gallons: `if storage_volume < 2:` - if the draw pattern is HIGH, the expected UEF is 0.92, for draw all other draw patterns, it is 0.91: `if draw_pattern == "HIGH": expected_UEF = 0.92; else: expected_UEF = 0.91` - - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.uniform_energy_factor >= expected_UEF:` - - set rule_status to "PASS": `rule_status = "PASS"` - - otherwise, set rule status to FAIL and provide the note that the expected UEF is less than the required UEF: `else: rule_status = "FAIL"; rule_note = "The modeled Uniform energy Factor (UEF - " + shw_eq.uniform_energy_factor + ") is less than required (" + expected_UEF + ")"` + - check whether the uniform_energy_factor is valid: `if uniform_energy_factor != NULL + - check if the actual uniform_energy_factor is >= to the expected: `if uniform_energy_factor >= expected_UEF:` + - set rule_status to "PASS": `rule_status = "PASS"` + - otherwise, set rule status to FAIL and provide the note that the expected UEF is less than the required UEF: `else: rule_status = "FAIL"; rule_note = "The modeled Uniform energy Factor (UEF - " + uniform_energy_factor + ") is less than required (" + expected_UEF + ")"` + - otherwise, set rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note = "Uniform Energy Factor is required but not provided"` - else, if the storage tank is is between 20 and 55 gallons, this is considered an electric storage water heater in Appendix F: `elif storage_volume >= 20 && storage_volume <= 55:` - determine the UEF based on the draw pattern for VERY_SMALL: `if draw_pattern == "VERY_SMALL": expected_uef = 0.8808 – (0.0008 × storage_volume)` - determine the UEF based on the draw pattern for LOW: `if draw_pattern == "LOW": expected_uef = 0.9254 – (0.0003 × storage_volume)` - determine the UEF based on the draw pattern for MEDIUM: `if draw_pattern == "MEDIUM": expected_uef = 0.9307 – (0.0002 × storage_volume)` - - determine the UEF based on the draw pattern for HIGH: `if draw_pattern == "HIGH": expected_uef = 0.9349 – (0.0001 × storage_volume)` - - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.uniform_energy_factor >= expected_UEF:` - - set rule_status to "PASS": `rule_status = "PASS"` - - otherwise, set rule status to FAIL and provide the note that the expected UEF is less than the required UEF: `else: rule_status = "FAIL"; rule_note = "The modeled Uniform energy Factor (UEF - " + shw_eq.uniform_energy_factor + ") is less than required (" + expected_UEF + ")"` + - determine the UEF based on the draw pattern for HIGH: `if draw_pattern == "HIGH": expected_uef = 0.9349 – (0.0001 × storage_volume)` + - check whether the uniform_energy_factor is valid: `if uniform_energy_factor != NULL + - check if the actual uniform_energy_factor is >= to the expected: `if uniform_energy_factor >= expected_UEF:` + - set rule_status to "PASS": `rule_status = "PASS"` + - otherwise, set rule status to FAIL and provide the note that the expected UEF is less than the required UEF: `else: rule_status = "FAIL"; rule_note = "The modeled Uniform energy Factor (UEF - " + uniform_energy_factor + ") is less than required (" + expected_UEF + ")"` + - otherwise, set rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note = "Uniform Energy Factor is required but not provided"` - else, if the storage tank is greater than 55 and less than 100 gallons, Appendix F provides a heat pump efficiency, which may be an error. return UNDETERMINED: `elif storage_volume <=100 and storage_volume > 55:` - set rule_status to UNDETERMINED: `rule_status = "UNDETERMINED"` - include a note: `rule_note = "The storage tank is between 55 and 100 gallons with a capacity <= 12kW (40945 btu/hr). Appendix F provides a heat pump efficiency for water heaters in this capacity range, but the RCT does not have a way to verify this efficiency." @@ -95,18 +103,22 @@ s# HVAC_SystemZoneAssignment - Rule 11-10 - determine the UEF based on the draw pattern for VERY_SMALL: `if draw_pattern == "VERY_SMALL": expected_uef = 0.3456 – (0.0020 × storage_volume)` - determine the UEF based on the draw pattern for LOW: `if draw_pattern == "LOW": expected_uef = 0.5982 – (0.0019 × storage_volume)` - determine the UEF based on the draw pattern for MEDIUM: `if draw_pattern == "MEDIUM": expected_uef = 0.6483 – (0.0017 × storage_volume)` - - determine the UEF based on the draw pattern for HIGH: `if draw_pattern == "HIGH": expected_uef = 0.6920 – (0.0013 × storage_volume)` - - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.uniform_energy_factor >= expected_UEF:` - - set rule_status to "PASS": `rule_status = "PASS"` - - otherwise, set rule status to FAIL and provide the note that the expected UEF is less than the required UEF: `else: rule_status = "FAIL"; rule_note = "The modeled Uniform energy Factor (UEF - " + shw_eq.uniform_energy_factor + ") is less than required (" + expected_UEF + ")"` + - determine the UEF based on the draw pattern for HIGH: `if draw_pattern == "HIGH": expected_uef = 0.6920 – (0.0013 × storage_volume)` + - check whether the uniform_energy_factor is valid: `if uniform_energy_factor != NULL + - check if the actual uniform_energy_factor is >= to the expected: `if uniform_energy_factor >= expected_UEF:` + - set rule_status to "PASS": `rule_status = "PASS"` + - otherwise, set rule status to FAIL and provide the note that the expected UEF is less than the required UEF: `else: rule_status = "FAIL"; rule_note = "The modeled Uniform energy Factor (UEF - " + uniform_energy_factor + ") is less than required (" + expected_UEF + ")"` + - otherwise, set rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note = "Uniform Energy Factor is required but not provided"` - otherwise, if the storage volume is between 55 and 100 gallons: `elif storage_volume <= 100:` - determine the UEF based on the draw pattern for VERY_SMALL: `if draw_pattern == "VERY_SMALL": expected_uef = 0.6470 – (0.0006 × storage_volume)` - determine the UEF based on the draw pattern for LOW: `if draw_pattern == "LOW": expected_uef = 0.7689 – (0.0005 × storage_volume)` - determine the UEF based on the draw pattern for MEDIUM: `if draw_pattern == "MEDIUM": expected_uef = 0.7897 – (0.0004 × storage_volume)` - - determine the UEF based on the draw pattern for HIGH: `if draw_pattern == "HIGH": expected_uef = 0.8072 – (0.0003 × storage_volume)` - - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.uniform_energy_factor >= expected_UEF:` - - set rule_status to "PASS": `rule_status = "PASS"` - - otherwise, set rule status to FAIL and provide the note that the expected UEF is less than the required UEF: `else: rule_status = "FAIL"; rule_note = "The modeled Uniform energy Factor (UEF - " + shw_eq.uniform_energy_factor + ") is less than required (" + expected_UEF + ")"` + - determine the UEF based on the draw pattern for HIGH: `if draw_pattern == "HIGH": expected_uef = 0.8072 – (0.0003 × storage_volume)` + - check whether the uniform_energy_factor is valid: `if uniform_energy_factor != NULL + - check if the actual uniform_energy_factor is >= to the expected: `if uniform_energy_factor >= expected_UEF:` + - set rule_status to "PASS": `rule_status = "PASS"` + - otherwise, set rule status to FAIL and provide the note that the expected UEF is less than the required UEF: `else: rule_status = "FAIL"; rule_note = "The modeled Uniform energy Factor (UEF - " + uniform_energy_factor + ") is less than required (" + expected_UEF + ")"` + - otherwise, set rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note = "Uniform Energy Factor is required but not provided"` - otherwise, the storage volume is either greater than 100 gallons, or between 2 and 20, which is not covered by Appendix F: `else:` - create a note indicating that gas water heaters greater with input capacity < 75,000 btu/hr and the given storage volume are not covered under Appendix F: `rule_note: "Gas water heaters with an input capacity < 75,000 btu/hr and a storage capacity of " + storage_volume + " are not covered under Appendix F"` - change rule_status to UNDETERMINED: `rule_status = "UNDETERMINED"` @@ -124,26 +136,34 @@ s# HVAC_SystemZoneAssignment - Rule 11-10 - calculate the expected efficiency for LOW draw pattern: `if draw_pattern == "LOW": expected_UEF = 0.5362 – (0.0012 * volume)` - calculate the expected efficiency for MEDIUM draw pattern: `if draw_pattern == "MEDIUM": expected_UEF = 0.6002 – (0.0011 * volume)` - calculate the expected efficiency for HIGH draw pattern: `if draw_pattern == "HIGH": expected_UEF = 0.6597 – (0.0009 * volume)` - - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.uniform_energy_factor >= expected_UEF && !has_faults:` - - set rule_status to "PASS": `rule_status = "PASS"` + - check whether the uniform_energy_factor is valid: `if uniform_energy_factor != NULL + - check if the actual uniform_energy_factor is >= to the expected: `if uniform_energy_factor >= expected_UEF && !has_faults:` + - set rule_status to "PASS": `rule_status = "PASS"` + - otherwise, set rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note = "Uniform Energy Factor is required but not provided"` - otherwise the capacity is > 105,000 btu/hr: `else:` - the capacity per volume should be < 4000 btu/hr/gallon: `if capacity_per_volume >= 4000:` - add the following text to the note: "For Gas Storage Water heaters, the capacity per volume should be less than 4000 btu/hr/gallon": `rule_note += "For Gas Storage Water heaters, the capacity per volume should be less than 4000 btu/hr/gallon. "` - set has_fault to true: `has_fault = true` - calculate the expected_thermal_efficiency : `expected_thermal_efficiency = 0.8` - calculate max_standby_loss (btu/hr): `max_standby_loss = (input_capacity/800 + 110 * sqrt(volume))` - - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.thermal_efficiency >= expected_thermal_efficiency && standby_loss <= max_standby_loss && !has_faults:` - - set rule_status to "PASS": `rule_status = "PASS"` + - make sure that the thermal efficiency is not NULL: `if thermal_efficiency != NULL:` + - check whether the uniform_energy_factor is valid: `if uniform_energy_factor != NULL` + - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.thermal_efficiency >= expected_thermal_efficiency && standby_loss <= max_standby_loss && !has_faults:` + - set rule_status to "PASS": `rule_status = "PASS"` + - otherwise, set rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note = "Uniform Energy Factor is required but not provided"` + - otherwise set the rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note = "No thermal efficiency provided. Expected thermal efficiency is: " + expected_thermal_efficiency` - check if the water heater is OIL_STORAGE: `elif swh_type == "OIL_STORAGE` - if the input capacity <= 105,000 btu/hr, this equipment is covered under Appendix F: `if input_capacity <= 105000:` - look to see if the water heater is covered in Appendix F, first look to see if it is anything less than 50 gallons of storage: `if storage_volume < 50:` - determine the UEF based on the draw pattern for VERY_SMALL: `if draw_pattern == "VERY_SMALL": expected_uef = 0.2509 – (0.0012 × storage_volume)` - determine the UEF based on the draw pattern for LOW: `if draw_pattern == "LOW": expected_uef = 0.5330 – (0.0016 × storage_volume)` - determine the UEF based on the draw pattern for MEDIUM: `if draw_pattern == "MEDIUM": expected_uef = 0.6078 – (0.0016 × storage_volume)` - - determine the UEF based on the draw pattern for HIGH: `if draw_pattern == "HIGH": expected_uef = 0.6815 – (0.0014 × storage_volume)` - - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.uniform_energy_factor >= expected_UEF:` - - set rule_status to "PASS": `rule_status = "PASS"` - - otherwise, set rule status to FAIL and provide the note that the expected UEF is less than the required UEF: `else: rule_status = "FAIL"; rule_note = "The modeled Uniform energy Factor (UEF - " + shw_eq.uniform_energy_factor + ") is less than required (" + expected_UEF + ")"` + - determine the UEF based on the draw pattern for HIGH: `if draw_pattern == "HIGH": expected_uef = 0.6815 – (0.0014 × storage_volume)` + - check whether the uniform_energy_factor is valid: `if uniform_energy_factor != NULL` + - check if the actual uniform_energy_factor is >= to the expected: `if uniform_energy_factor >= expected_UEF:` + - set rule_status to "PASS": `rule_status = "PASS"` + - otherwise, set rule status to FAIL and provide the note that the expected UEF is less than the required UEF: `else: rule_status = "FAIL"; rule_note = "The modeled Uniform energy Factor (UEF - " + uniform_energy_factor + ") is less than required (" + expected_UEF + ")"` + - otherwise, set rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note = "Uniform Energy Factor is required but not provided"` - otherwise, the storage volume is greater 50 gallons and is not covered by Appendix F: `else:` - create a note indicating that gas water heaters with storage volume greater than 50 gallons are not covered under Appendix F: `rule_note: "Gas water heaters with a storage volume greater than 50 gallons are not covered under Appendix F"` - change rule_status to UNDETERMINED: `rule_status = "UNDETERMINED"` @@ -161,15 +181,21 @@ s# HVAC_SystemZoneAssignment - Rule 11-10 - the setpoint temperature should be less than or equal to 180F: `if shw_eq.setpoint_temperature > 180:` - add the following text to the note: "For Oil Storage Water heaters, the supply water temperature must be <= 180F": `rule_note += "For Oil Storage Water heaters, the supply water temperature must be <= 180F"` - set has_fault to true: `has_fault = true` - - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.uniform_energy_factor >= expected_UEF && !has_faults:` - - set rule_status to "PASS": `rule_status = "PASS"` + - check whether the uniform_energy_factor is valid: `if uniform_energy_factor != NULL` + - check if the actual uniform_energy_factor is >= to the expected: `if uniform_energy_factor >= expected_UEF && !has_faults:` + - set rule_status to "PASS": `rule_status = "PASS"` + - otherwise, set rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note = "Uniform Energy Factor is required but not provided"` - else the input capacity is >= 140,000 btu/hr: `else:` - the capacity per volume should be < 4000 btu/hr/gallon: `if capacity_per_volume >= 4000:` - add the following text to the note: "For Oil Storage heaters, with capacity > 140,000 btu/hr, the capacity per volume should be < 4000 btu/hr/gallon.": `rule_note += "For Oil Storage heaters, with capacity <= 140,000 btu/hr, the capacity per volume should be < 4000 btu/hr/gallon. "` - set has_fault to true: `has_fault = true` - set the expected thermal efficiency to 0.8: `expected_thermal_efficiency = 0.8` - - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.thermal_efficiency >= expected_thermal_efficiency && !has_faults:` - - set rule_status to "PASS": `rule_status = "PASS"` + - make sure that the thermal efficiency is not NULL: `if thermal_efficiency != NULL:` + - check whether the uniform_energy_factor is valid: `if uniform_energy_factor != NULL` + - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.thermal_efficiency >= expected_thermal_efficiency && !has_faults:` + - set rule_status to "PASS": `rule_status = "PASS"` + - otherwise, set rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note = "Uniform Energy Factor is required but not provided"` + - otherwise set the rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note = "No thermal efficiency provided. Expected thermal efficiency is: " + expected_thermal_efficiency` **Rule Assertion - Zone:** - Case1: swh_type is INSTANTANEOUS - there is no baseline instantaneous water heater types: `if swh_type == "INSTANTANEOUS": UNDETERMINED; rule_note = "There baseline water heater is of an Instantaneous type. There are no acceptable instantaneous baseline water heaters in Table G3.1.1-2."` @@ -188,5 +214,8 @@ s# HVAC_SystemZoneAssignment - Rule 11-10 1. the tank surface is thermally insulated to R-12.5, 2. a standing pilot light is not installed, and 3. gas- or oil-fired storage water heaters have a flue damper or fan-assisted combustion. +6. Written assuming the issue: https://github.com/open229/ruleset-model-description-schema/issues/287 will be accepted as part of the schema + +- get the standby loss (see note 1 for calculation source): `standby_loss = swh_eq.standby_loss_fraction * 8.25 * volume * 70` **[Back](../_toc.md)** From f42492af0c32605946af12b0e089915dfaea81bb Mon Sep 17 00:00:00 2001 From: KarenWGard <114143532+KarenWGard@users.noreply.github.com> Date: Wed, 4 Dec 2024 10:40:39 -0500 Subject: [PATCH 13/25] Update Rule_11-10.md --- docs/section11/Rule_11-10.md | 263 +++++++++++++++++------------------ 1 file changed, 129 insertions(+), 134 deletions(-) diff --git a/docs/section11/Rule_11-10.md b/docs/section11/Rule_11-10.md index fa78a3aa47..01aad32917 100644 --- a/docs/section11/Rule_11-10.md +++ b/docs/section11/Rule_11-10.md @@ -1,10 +1,10 @@ -s# HVAC_SystemZoneAssignment - Rule 11-10 +# HVAC_SystemZoneAssignment - Rule 11-10 **Schema Version:** 0.0.37 **Mandatory Rule:** True **Rule ID:** 11-10 -**Rule Description:** "The service water heating system type in the baseline building design shall match the minimum efficiency requirements in Section 7.4.2" +**Rule Description:** The service water heating system type in the baseline building design shall match the minimum efficiency requirements in Section 7.4.2 **Rule Assertion:** Options are PASS/FAIL/NOT_APPLICABLE/UNDETERMINED **Appendix G Section Reference:** Table G3.1 #11, baseline column, a + b @@ -26,7 +26,7 @@ s# HVAC_SystemZoneAssignment - Rule 11-10 - create a value to track the rule status: `rule_status = "FAIL"` - create a variable to track any notes: `rule_note = """` - we need to find the following information about the SWH: - - swh_type - (ELECTRIC_RESISTANCE_INSTANTANEOUS, ELECTRIC_RESISTANCE_STORAGE, GAS_STORAGE, OTHER) + - swh_heater_type - (ELECTRIC_RESISTANCE_INSTANTANEOUS, ELECTRIC_RESISTANCE_STORAGE, GAS_STORAGE, OTHER) - swh_type - one of the SWH BATs - input_capacity (btu/hr) - storage_volume (gallons) @@ -34,9 +34,9 @@ s# HVAC_SystemZoneAssignment - Rule 11-10 - capacity_per_volume (btu/hr/gallon) - get the service water heating system: `swh_eq = get_object_by_id(service_water_heating_equipment_id,RMD)` - get the type of tank: `tank_type = swh_eq.tank.type` - - get the type of heater: `swh_type = swh_eq.heater_type` - - the type will be one of the ServiceWaterHeaterTankOptions, which are more detailed than the four types we need. Determine our type based on the detailed type. - - set the swh_type to OTHER. If the tank_type is an identifiable type, swh_type will be overwritten to that type: `swh_type = "OTHER"` + - get the type of heater: `swh_heater_type = swh_eq.heater_type` + - the swh_type will be one of the ServiceWaterHeaterTankOptions, which are more detailed than the four types we need. Determine our type based on the detailed type. + - the default value of swh_type is OTHER. If the swh_type can be identified, the value will be changed in the logic below: `swh_type = "OTHER"` - if the tank_type is CONSUMER_INSTANTANEOUS, COMMERCIAL_INSTANTANEOUS, or RESIDENTIAL_DUTY_COMMERCIAL_INSTANTANEOUS, set the swh_type to INSTANTANEOUS and go to rule assertion: `if tank_type in ["CONSUMER_INSTANTANEOUS", "COMMERCIAL_INSTANTANEOUS", "RESIDENTIAL_DUTY_COMMERCIAL_INSTANTANEOUS"]: swh_type = "INSTANTANEOUS"`; GO TO RULE_ASSERTION - get the fuel type of the equipment: `fuel_type = shw_eq.heater_fuel_type` @@ -44,7 +44,7 @@ s# HVAC_SystemZoneAssignment - Rule 11-10 - set the swh_type based on tank_type and fuel type: `if fuel_type == "ELECTRICITY": swh_type = "ELECTRIC_RESISTANCE_STORAGE` - `elif fuel_type == "NATURAL_GAS": swh_type = "GAS_STORAGE` - `elif fuel_type == "FUEL_OIL": swh_type = "OIL_STORAGE` - - if the draw_pattern is given, get the draw pattern: `if shw_eq.draw_pattern != nil: draw_pattern = shw_eq.draw_pattern` + - if the draw_pattern is given, get the draw pattern: `if shw_eq.draw_pattern != null: draw_pattern = shw_eq.draw_pattern` - otherwise, determine the draw pattern based off the first_hour_rating of the shw_eq: `else:` - First get the first hour rating (gallons): `first_hour_rating = shw_eq.first_hour_rating` - if the first_hour_rating is less than 18 gallons, draw_pattern is "VERY SMALL": `if first_hour_rating < 18: draw_pattern = "VERY_SMALL"` @@ -60,142 +60,137 @@ s# HVAC_SystemZoneAssignment - Rule 11-10 - get the thermal efficiency: `thermal_efficiency = efficiency_metric_dict["THERMAL_EFFICIENCY"]` - get the uniform energy factor: `uniform_energy_factor = efficiency_metric_dict["UNIFORM_ENERGY_FACTOR"]` - what follows is logic that implements Table 7.8 - this table has multiple criteria, so I think it's simpler to implement with if / else logic than a table lookup - - if the swh_type is OTHER, set rule_note to "Water heater type is not a recognized type": `if swh_type == "OTHER": rule_note = "Water heater type is not a recognized type"` + - if the swh_type is OTHER, set rule_note to "Water heater type is not a recognized type", and continue to rule assertion: `if swh_type == "OTHER": rule_note = "Water heater type is not a recognized type"; GO TO RULE ASSERTION` + - create a boolean has_fault and set it to false: `has_fault = false` + - if the water heater is electric resistance, or storage and the capacity is <= 12kW (40945 btu/hr), look at Appendix F: `if swh_type in ["ELECTRIC_RESISTANCE_STORAGE"] and input_capacity <= 40945.7:` + - check the size of the storage tank. If it's less than 2 gallons, provide a note, and continue to rule assertion: `if storage_volume < 2: rule_note = "The storage volume is not consistent with an electric storage water heater as it is less than 20 gallons."; GO TO RULE ASSERTION` + - else, if the storage tank is is between 20 and 55 gallons, this is considered an electric storage water heater in Appendix F: `elif storage_volume >= 20 and storage_volume <= 55:` + - determine the UEF based on the draw pattern for VERY_SMALL: `if draw_pattern == "VERY_SMALL": expected_uef = 0.8808 – (0.0008 × storage_volume)` + - determine the UEF based on the draw pattern for LOW: `if draw_pattern == "LOW": expected_uef = 0.9254 – (0.0003 × storage_volume)` + - determine the UEF based on the draw pattern for MEDIUM: `if draw_pattern == "MEDIUM": expected_uef = 0.9307 – (0.0002 × storage_volume)` + - determine the UEF based on the draw pattern for HIGH: `if draw_pattern == "HIGH": expected_uef = 0.9349 – (0.0001 × storage_volume)` + - check whether the uniform_energy_factor is valid: `if uniform_energy_factor != NULL + - check if the actual uniform_energy_factor equals the expected: `if uniform_energy_factor == expected_UEF:` + - set rule_status to "PASS": `rule_status = "PASS"` + - otherwise, set rule status to FAIL and provide the note that the expected UEF is less than the required UEF: `else: rule_status = "FAIL"; rule_note = "The modeled Uniform energy Factor (UEF - " + uniform_energy_factor + ") does not equal required (" + expected_UEF + ")"` + - otherwise, set rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note = "Uniform Energy Factor is required but not provided"` + - else, if the storage tank is greater than 55 and less than 100 gallons, Appendix F provides a heat pump efficiency, which may be an error. return UNDETERMINED: `elif storage_volume <=100 and storage_volume > 55:` + - set rule_status to UNDETERMINED: `rule_status = "UNDETERMINED"` + - include a note: `rule_note = "The storage tank is between 2 and 20 gallons and based on the size categories in ASHRAE 90.1 Table 7.8 and Appendix F it would not be classified as an electric storage water heater. Consequently, this rule was not able to be assessed for this service water heater."` + - go to rule assertion: `GO TO RULE ASSERTION` + - else if the storage volume is between 2 and 20 gallons, in which case there is no rating in APPENDIX F. set rule status to UNDETERMINED: `elif storage_volume < 20:` + - set the rule status to UNDETERMINED: `rule_status = "UNDETERMINED"` + - add a note: `rule_note = "The storage tank is between 2 and 20 gallons. Appendix F doesn't provide an efficiency for water heaters of this size."` + - go to rule assertion: `GO TO RULE ASSERTION` - otherwise, continue with rule logic: `else:` - - create a boolean has_fault and set it to false: `has_fault = false` - - if the water heater is electric resistance, or storage and the capacity is <= 12kW (40945 btu/hr), look at Appendix F: `if swh_type in ["ELECTRIC_RESISTANCE_STORAGE"] && input_capacity <= 40945.7:` - - check the size of the storage tank. If it's less than 2 gallons: `if storage_volume < 2:` - - if the draw pattern is HIGH, the expected UEF is 0.92, for draw all other draw patterns, it is 0.91: `if draw_pattern == "HIGH": expected_UEF = 0.92; else: expected_UEF = 0.91` - - check whether the uniform_energy_factor is valid: `if uniform_energy_factor != NULL - - check if the actual uniform_energy_factor is >= to the expected: `if uniform_energy_factor >= expected_UEF:` - - set rule_status to "PASS": `rule_status = "PASS"` - - otherwise, set rule status to FAIL and provide the note that the expected UEF is less than the required UEF: `else: rule_status = "FAIL"; rule_note = "The modeled Uniform energy Factor (UEF - " + uniform_energy_factor + ") is less than required (" + expected_UEF + ")"` - - otherwise, set rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note = "Uniform Energy Factor is required but not provided"` - - else, if the storage tank is is between 20 and 55 gallons, this is considered an electric storage water heater in Appendix F: `elif storage_volume >= 20 && storage_volume <= 55:` - - determine the UEF based on the draw pattern for VERY_SMALL: `if draw_pattern == "VERY_SMALL": expected_uef = 0.8808 – (0.0008 × storage_volume)` - - determine the UEF based on the draw pattern for LOW: `if draw_pattern == "LOW": expected_uef = 0.9254 – (0.0003 × storage_volume)` - - determine the UEF based on the draw pattern for MEDIUM: `if draw_pattern == "MEDIUM": expected_uef = 0.9307 – (0.0002 × storage_volume)` - - determine the UEF based on the draw pattern for HIGH: `if draw_pattern == "HIGH": expected_uef = 0.9349 – (0.0001 × storage_volume)` + - check electric storage water heaters with capacity greater than 12 kW: `if swh_type == "ELECTRIC_RESISTANCE_STORAGE" and input_capacity > 40945.7 (btu/hr):` + - check that the capacity_per_volume < 4000 btu/hr/gallon: `if capacity_per_volume < 4000:` + - calculate the standby loss target: `standby_loss_target = 0.3 + (27/swh_eq.distribution_system.tank.storage_volume)` + - + - if the standby_loss is less than or equal to the target, set the rule_status to PASS: `if standby_loss <= standby_loss_target: rule_status: "PASS"` + - otherwise: `else:` + - set the note to indicate that the standby_loss is higher than the maximum allowed: `rule_note = "Standby Loss is higher than required by Table 7.8"` + - otherwise: `else:` + - set the note to indicate that the capacity per volume exceeds the limit: `rule_note = "Capacity per volume exceeds the limit of 4000 btu/hr/gallon for Electric Storage Water Heaters` + - check if the water heater is gas storage: `if swh_type == "GAS_STORAGE":` + - check if the capacity is <= 75,000 btu/hr: `if input_capacity <= 75000:` + - if the storage volume is between 20 and 55 gallons: `if storage_volume >= 20 and storage_volume <= 55:` + - determine the UEF based on the draw pattern for VERY_SMALL: `if draw_pattern == "VERY_SMALL": expected_uef = 0.3456 – (0.0020 × storage_volume)` + - determine the UEF based on the draw pattern for LOW: `if draw_pattern == "LOW": expected_uef = 0.5982 – (0.0019 × storage_volume)` + - determine the UEF based on the draw pattern for MEDIUM: `if draw_pattern == "MEDIUM": expected_uef = 0.6483 – (0.0017 × storage_volume)` + - determine the UEF based on the draw pattern for HIGH: `if draw_pattern == "HIGH": expected_uef = 0.6920 – (0.0013 × storage_volume)` + - check whether the uniform_energy_factor is valid: `if uniform_energy_factor != NULL + - check if the actual uniform_energy_factor is >= to the expected: `if uniform_energy_factor >= expected_UEF:` + - set rule_status to "PASS": `rule_status = "PASS"` + - otherwise, set rule status to FAIL and provide the note that the expected UEF is less than the required UEF: `else: rule_status = "FAIL"; rule_note = "The modeled Uniform energy Factor (UEF - " + uniform_energy_factor + ") is less than required (" + expected_UEF + ")"` + - otherwise, set rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note = "Uniform Energy Factor is required but not provided"` + - otherwise, if the storage volume is between 55 and 100 gallons: `elif storage_volume <= 100:` + - determine the UEF based on the draw pattern for VERY_SMALL: `if draw_pattern == "VERY_SMALL": expected_uef = 0.6470 – (0.0006 × storage_volume)` + - determine the UEF based on the draw pattern for LOW: `if draw_pattern == "LOW": expected_uef = 0.7689 – (0.0005 × storage_volume)` + - determine the UEF based on the draw pattern for MEDIUM: `if draw_pattern == "MEDIUM": expected_uef = 0.7897 – (0.0004 × storage_volume)` + - determine the UEF based on the draw pattern for HIGH: `if draw_pattern == "HIGH": expected_uef = 0.8072 – (0.0003 × storage_volume)` + - check whether the uniform_energy_factor is valid: `if uniform_energy_factor != NULL + - check if the actual uniform_energy_factor is >= to the expected: `if uniform_energy_factor >= expected_UEF:` + - set rule_status to "PASS": `rule_status = "PASS"` + - otherwise, set rule status to FAIL and provide the note that the expected UEF is less than the required UEF: `else: rule_status = "FAIL"; rule_note = "The modeled Uniform energy Factor (UEF - " + uniform_energy_factor + ") is less than required (" + expected_UEF + ")"` + - otherwise, set rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note = "Uniform Energy Factor is required but not provided"` + - otherwise, the storage volume is either greater than 100 gallons, or between 2 and 20, which is not covered by Appendix F: `else:` + - create a note indicating that gas water heaters greater with input capacity < 75,000 btu/hr and the given storage volume are not covered under Appendix F: `rule_note: "Gas water heaters with an input capacity < 75,000 btu/hr and a storage capacity of " + storage_volume + " are not covered under Appendix F"` + - change rule_status to UNDETERMINED: `rule_status = "UNDETERMINED"` + - check if the capacity <= 105,000 btu/hr: `elif input_capacity <= 105000:` + - the capacity per volume should be < 4000 btu/hr/gallon: `if capacity_per_volume >= 4000:` + - add the following text to the note: "For Gas Storage Water heaters, the capacity per volume should be less than 4000 btu/hr/gallon": `rule_note += "For Gas Storage Water heaters, the capacity per volume should be less than 4000 btu/hr/gallon. "` + - set has_fault to true: `has_fault = true` + - the volume should be <= 120 gallons: `if storage_volume > 120:` + - add the following text to the note: "For Gas Storage Water heaters with capacity less than 105,000 btu/hr, the storage capacity is expected to be less than 120 gallons": `rule_note += "For Gas Storage Water heaters with capacity less than 105,000 btu/hr, the storage capacity is expected to be less than 120 gallons. "` + - set has_fault to true: `has_fault = true` + - the supply water temperature should be <= 180F: `if shw_eq.setpoint_temperature > 180:` + - add the following text to the note: "For Gas Storage Water heaters with capacity less than 105,000 btu/hr, the supply water temperature is expected to be <= 180F": `rule_note += "For Gas Storage Water heaters with capacity less than 105,000 btu/hr, the supply water temperature is expected to be <= 180F. "` + - set has_fault to true: `has_fault = true` + - calculate the expected efficiency for VERY_SMALL draw pattern: `if draw_pattern == "VERY_SMALL": expected_UEF = 0.2674 – (0.0009 * volume)` + - calculate the expected efficiency for LOW draw pattern: `if draw_pattern == "LOW": expected_UEF = 0.5362 – (0.0012 * volume)` + - calculate the expected efficiency for MEDIUM draw pattern: `if draw_pattern == "MEDIUM": expected_UEF = 0.6002 – (0.0011 * volume)` + - calculate the expected efficiency for HIGH draw pattern: `if draw_pattern == "HIGH": expected_UEF = 0.6597 – (0.0009 * volume)` - check whether the uniform_energy_factor is valid: `if uniform_energy_factor != NULL - - check if the actual uniform_energy_factor is >= to the expected: `if uniform_energy_factor >= expected_UEF:` + - check if the actual uniform_energy_factor is >= to the expected: `if uniform_energy_factor >= expected_UEF and !has_faults:` - set rule_status to "PASS": `rule_status = "PASS"` - - otherwise, set rule status to FAIL and provide the note that the expected UEF is less than the required UEF: `else: rule_status = "FAIL"; rule_note = "The modeled Uniform energy Factor (UEF - " + uniform_energy_factor + ") is less than required (" + expected_UEF + ")"` - otherwise, set rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note = "Uniform Energy Factor is required but not provided"` - - else, if the storage tank is greater than 55 and less than 100 gallons, Appendix F provides a heat pump efficiency, which may be an error. return UNDETERMINED: `elif storage_volume <=100 and storage_volume > 55:` - - set rule_status to UNDETERMINED: `rule_status = "UNDETERMINED"` - - include a note: `rule_note = "The storage tank is between 55 and 100 gallons with a capacity <= 12kW (40945 btu/hr). Appendix F provides a heat pump efficiency for water heaters in this capacity range, but the RCT does not have a way to verify this efficiency." - - else if the storage volume is between 2 and 20 gallons, in which case there is no rating in APPENDIX F. set rule status to UNDETERMINED: `elif storage_volume < 20:` - - set the rule status to UNDETERMINED: `rule_status = "UNDETERMINED"` - - add a note: `rule_note = "The storage tank is between 2 and 20 gallons. Appendix F doesn't provide an efficiency for this water heaters of this size." - - otherwise, continue with rule logic: `else:` - - check electric storage water heaters with capacity greater than 12 kW: `if swh_type == "ELECTRIC_RESISTANCE_STORAGE" && input_capacity > 40945.7:` - - check that the capacity_per_volume < 4000 btu/hr/gallon: `if capacity_per_volume < 4000:` - - calculate the standby loss target: `standby_loss_target = 0.3 + (27/swh_eq.distribution_system.tank.storage_volume)` - - - - if the standby_loss is less than or equal to the target, set the rule_status to PASS: `if standby_loss <= standby_loss_target: rule_status: "PASS"` - - otherwise: `else:` - - set the note to indicate that the standby_loss is higher than the maximum allowed: `rule_note = "Standby Loss is higher than required by Table 7.8"` - - otherwise: `else:` - - set the note to indicate that the capacity per volume exceeds the limit: `rule_note = "Capacity per volume exceeds the limit of 4000 btu/hr/gallon for Electric Storage Water Heaters` - - check if the water heater is gas storage: `if swh_type == "GAS_STORAGE":` - - check if the capacity is <= 75,000 btu/hr: `if input_capacity <= 75000:` - - if the storage volume is between 20 and 55 gallons: `if storage_volume >= 20 && storage_volume <= 55:` - - determine the UEF based on the draw pattern for VERY_SMALL: `if draw_pattern == "VERY_SMALL": expected_uef = 0.3456 – (0.0020 × storage_volume)` - - determine the UEF based on the draw pattern for LOW: `if draw_pattern == "LOW": expected_uef = 0.5982 – (0.0019 × storage_volume)` - - determine the UEF based on the draw pattern for MEDIUM: `if draw_pattern == "MEDIUM": expected_uef = 0.6483 – (0.0017 × storage_volume)` - - determine the UEF based on the draw pattern for HIGH: `if draw_pattern == "HIGH": expected_uef = 0.6920 – (0.0013 × storage_volume)` - - check whether the uniform_energy_factor is valid: `if uniform_energy_factor != NULL - - check if the actual uniform_energy_factor is >= to the expected: `if uniform_energy_factor >= expected_UEF:` - - set rule_status to "PASS": `rule_status = "PASS"` - - otherwise, set rule status to FAIL and provide the note that the expected UEF is less than the required UEF: `else: rule_status = "FAIL"; rule_note = "The modeled Uniform energy Factor (UEF - " + uniform_energy_factor + ") is less than required (" + expected_UEF + ")"` - - otherwise, set rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note = "Uniform Energy Factor is required but not provided"` - - otherwise, if the storage volume is between 55 and 100 gallons: `elif storage_volume <= 100:` - - determine the UEF based on the draw pattern for VERY_SMALL: `if draw_pattern == "VERY_SMALL": expected_uef = 0.6470 – (0.0006 × storage_volume)` - - determine the UEF based on the draw pattern for LOW: `if draw_pattern == "LOW": expected_uef = 0.7689 – (0.0005 × storage_volume)` - - determine the UEF based on the draw pattern for MEDIUM: `if draw_pattern == "MEDIUM": expected_uef = 0.7897 – (0.0004 × storage_volume)` - - determine the UEF based on the draw pattern for HIGH: `if draw_pattern == "HIGH": expected_uef = 0.8072 – (0.0003 × storage_volume)` - - check whether the uniform_energy_factor is valid: `if uniform_energy_factor != NULL - - check if the actual uniform_energy_factor is >= to the expected: `if uniform_energy_factor >= expected_UEF:` - - set rule_status to "PASS": `rule_status = "PASS"` - - otherwise, set rule status to FAIL and provide the note that the expected UEF is less than the required UEF: `else: rule_status = "FAIL"; rule_note = "The modeled Uniform energy Factor (UEF - " + uniform_energy_factor + ") is less than required (" + expected_UEF + ")"` - - otherwise, set rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note = "Uniform Energy Factor is required but not provided"` - - otherwise, the storage volume is either greater than 100 gallons, or between 2 and 20, which is not covered by Appendix F: `else:` - - create a note indicating that gas water heaters greater with input capacity < 75,000 btu/hr and the given storage volume are not covered under Appendix F: `rule_note: "Gas water heaters with an input capacity < 75,000 btu/hr and a storage capacity of " + storage_volume + " are not covered under Appendix F"` - - change rule_status to UNDETERMINED: `rule_status = "UNDETERMINED"` - - check if the capacity <= 105,000 btu/hr: `elif input_capacity <= 105000:` - - the capacity per volume should be < 4000 btu/hr/gallon: `if capacity_per_volume >= 4000:` - - add the following text to the note: "For Gas Storage Water heaters, the capacity per volume should be less than 4000 btu/hr/gallon": `rule_note += "For Gas Storage Water heaters, the capacity per volume should be less than 4000 btu/hr/gallon. "` - - set has_fault to true: `has_fault = true` - - the volume should be <= 120 gallons: `if storage_volume > 120:` - - add the following text to the note: "For Gas Storage Water heaters with capacity less than 105,000 btu/hr, the storage capacity is expected to be less than 120 gallons": `rule_note += "For Gas Storage Water heaters with capacity less than 105,000 btu/hr, the storage capacity is expected to be less than 120 gallons. "` - - set has_fault to true: `has_fault = true` - - the supply water temperature should be <= 180F: `if shw_eq.setpoint_temperature > 180:` - - add the following text to the note: "For Gas Storage Water heaters with capacity less than 105,000 btu/hr, the supply water temperature is expected to be <= 180F": `rule_note += "For Gas Storage Water heaters with capacity less than 105,000 btu/hr, the supply water temperature is expected to be <= 180F. "` - - set has_fault to true: `has_fault = true` - - calculate the expected efficiency for VERY_SMALL draw pattern: `if draw_pattern == "VERY_SMALL": expected_UEF = 0.2674 – (0.0009 * volume)` - - calculate the expected efficiency for LOW draw pattern: `if draw_pattern == "LOW": expected_UEF = 0.5362 – (0.0012 * volume)` - - calculate the expected efficiency for MEDIUM draw pattern: `if draw_pattern == "MEDIUM": expected_UEF = 0.6002 – (0.0011 * volume)` - - calculate the expected efficiency for HIGH draw pattern: `if draw_pattern == "HIGH": expected_UEF = 0.6597 – (0.0009 * volume)` - - check whether the uniform_energy_factor is valid: `if uniform_energy_factor != NULL - - check if the actual uniform_energy_factor is >= to the expected: `if uniform_energy_factor >= expected_UEF && !has_faults:` + - otherwise the capacity is > 105,000 btu/hr: `else:` + - the capacity per volume should be < 4000 btu/hr/gallon: `if capacity_per_volume >= 4000:` + - add the following text to the note: "For Gas Storage Water heaters, the capacity per volume should be less than 4000 btu/hr/gallon": `rule_note += "For Gas Storage Water heaters, the capacity per volume should be less than 4000 btu/hr/gallon. "` + - set has_fault to true: `has_fault = true` + - calculate the expected_thermal_efficiency : `expected_thermal_efficiency = 0.8` + - calculate max_standby_loss (btu/hr): `max_standby_loss = (input_capacity/800 + 110 * sqrt(volume))` + - make sure that the thermal efficiency is not NULL: `if thermal_efficiency != NULL:` + - check whether the uniform_energy_factor is valid: `if uniform_energy_factor != NULL` + - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.thermal_efficiency >= expected_thermal_efficiency and standby_loss <= max_standby_loss and !has_faults:` - set rule_status to "PASS": `rule_status = "PASS"` - otherwise, set rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note = "Uniform Energy Factor is required but not provided"` - - otherwise the capacity is > 105,000 btu/hr: `else:` - - the capacity per volume should be < 4000 btu/hr/gallon: `if capacity_per_volume >= 4000:` - - add the following text to the note: "For Gas Storage Water heaters, the capacity per volume should be less than 4000 btu/hr/gallon": `rule_note += "For Gas Storage Water heaters, the capacity per volume should be less than 4000 btu/hr/gallon. "` - - set has_fault to true: `has_fault = true` - - calculate the expected_thermal_efficiency : `expected_thermal_efficiency = 0.8` - - calculate max_standby_loss (btu/hr): `max_standby_loss = (input_capacity/800 + 110 * sqrt(volume))` - - make sure that the thermal efficiency is not NULL: `if thermal_efficiency != NULL:` - - check whether the uniform_energy_factor is valid: `if uniform_energy_factor != NULL` - - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.thermal_efficiency >= expected_thermal_efficiency && standby_loss <= max_standby_loss && !has_faults:` - - set rule_status to "PASS": `rule_status = "PASS"` - - otherwise, set rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note = "Uniform Energy Factor is required but not provided"` - - otherwise set the rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note = "No thermal efficiency provided. Expected thermal efficiency is: " + expected_thermal_efficiency` - - check if the water heater is OIL_STORAGE: `elif swh_type == "OIL_STORAGE` - - if the input capacity <= 105,000 btu/hr, this equipment is covered under Appendix F: `if input_capacity <= 105000:` - - look to see if the water heater is covered in Appendix F, first look to see if it is anything less than 50 gallons of storage: `if storage_volume < 50:` - - determine the UEF based on the draw pattern for VERY_SMALL: `if draw_pattern == "VERY_SMALL": expected_uef = 0.2509 – (0.0012 × storage_volume)` - - determine the UEF based on the draw pattern for LOW: `if draw_pattern == "LOW": expected_uef = 0.5330 – (0.0016 × storage_volume)` - - determine the UEF based on the draw pattern for MEDIUM: `if draw_pattern == "MEDIUM": expected_uef = 0.6078 – (0.0016 × storage_volume)` - - determine the UEF based on the draw pattern for HIGH: `if draw_pattern == "HIGH": expected_uef = 0.6815 – (0.0014 × storage_volume)` - - check whether the uniform_energy_factor is valid: `if uniform_energy_factor != NULL` - - check if the actual uniform_energy_factor is >= to the expected: `if uniform_energy_factor >= expected_UEF:` - - set rule_status to "PASS": `rule_status = "PASS"` - - otherwise, set rule status to FAIL and provide the note that the expected UEF is less than the required UEF: `else: rule_status = "FAIL"; rule_note = "The modeled Uniform energy Factor (UEF - " + uniform_energy_factor + ") is less than required (" + expected_UEF + ")"` - - otherwise, set rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note = "Uniform Energy Factor is required but not provided"` - - otherwise, the storage volume is greater 50 gallons and is not covered by Appendix F: `else:` - - create a note indicating that gas water heaters with storage volume greater than 50 gallons are not covered under Appendix F: `rule_note: "Gas water heaters with a storage volume greater than 50 gallons are not covered under Appendix F"` - - change rule_status to UNDETERMINED: `rule_status = "UNDETERMINED"` - - else if the input capacity is <= 140,000 btu/hr: `elif input_capacity <= 140000:` - - calculate the expected efficiency for VERY_SMALL draw pattern: `if draw_pattern == "VERY_SMALL": expected_UEF = 0.2932 – (0.0015 * volume)` - - calculate the expected efficiency for LOW draw pattern: `if draw_pattern == "LOW": expected_UEF = 0.5596 – (0.0018 * volume)` - - calculate the expected efficiency for MEDIUM draw pattern: `if draw_pattern == "MEDIUM": expected_UEF = 0.6194 – (0.0016 * volume)` - - calculate the expected efficiency for HIGH draw pattern: `if draw_pattern == "HIGH": expected_UEF = 0.6740 – (0.0013 * volume)` - - check that the storage volume is <= 120 gallons: `if volume > 120 gallons:` - - add the following text to the note: "For Oil Storage heaters, with capacity <= 140,000 btu/hr, the storage volume should be <= 120 gallons.": `rule_note += "For Oil Storage heaters, with capacity <= 140,000 btu/hr, the storage volume should be <= 120 gallons. "` - - set has_fault to true: `has_fault = true` - - the capacity per volume should be < 4000 btu/hr/gallon: `if capacity_per_volume >= 4000:` - - add the following text to the note: "For Oil Storage heaters, with capacity <= 140,000 btu/hr, the capacity per volume should be < 4000 btu/hr/gallon.": `rule_note += "For Oil Storage heaters, with capacity <= 140,000 btu/hr, the capacity per volume should be < 4000 btu/hr/gallon. "` - - set has_fault to true: `has_fault = true` - - the setpoint temperature should be less than or equal to 180F: `if shw_eq.setpoint_temperature > 180:` - - add the following text to the note: "For Oil Storage Water heaters, the supply water temperature must be <= 180F": `rule_note += "For Oil Storage Water heaters, the supply water temperature must be <= 180F"` - - set has_fault to true: `has_fault = true` + - otherwise set the rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note = "No thermal efficiency provided. Expected thermal efficiency is: " + expected_thermal_efficiency` + - check if the water heater is OIL_STORAGE: `elif swh_type == "OIL_STORAGE` + - if the input capacity <= 105,000 btu/hr, this equipment is covered under Appendix F: `if input_capacity <= 105000:` + - look to see if the water heater is covered in Appendix F, first look to see if it is anything less than 50 gallons of storage: `if storage_volume < 50:` + - determine the UEF based on the draw pattern for VERY_SMALL: `if draw_pattern == "VERY_SMALL": expected_uef = 0.2509 – (0.0012 × storage_volume)` + - determine the UEF based on the draw pattern for LOW: `if draw_pattern == "LOW": expected_uef = 0.5330 – (0.0016 × storage_volume)` + - determine the UEF based on the draw pattern for MEDIUM: `if draw_pattern == "MEDIUM": expected_uef = 0.6078 – (0.0016 × storage_volume)` + - determine the UEF based on the draw pattern for HIGH: `if draw_pattern == "HIGH": expected_uef = 0.6815 – (0.0014 × storage_volume)` + - check whether the uniform_energy_factor is valid: `if uniform_energy_factor != NULL` + - check if the actual uniform_energy_factor is >= to the expected: `if uniform_energy_factor >= expected_UEF:` + - set rule_status to "PASS": `rule_status = "PASS"` + - otherwise, set rule status to FAIL and provide the note that the expected UEF is less than the required UEF: `else: rule_status = "FAIL"; rule_note = "The modeled Uniform energy Factor (UEF - " + uniform_energy_factor + ") is less than required (" + expected_UEF + ")"` + - otherwise, set rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note = "Uniform Energy Factor is required but not provided"` + - otherwise, the storage volume is greater 50 gallons and is not covered by Appendix F: `else:` + - create a note indicating that gas water heaters with storage volume greater than 50 gallons are not covered under Appendix F: `rule_note: "Gas water heaters with a storage volume greater than 50 gallons are not covered under Appendix F"` + - change rule_status to UNDETERMINED: `rule_status = "UNDETERMINED"` + - else if the input capacity is <= 140,000 btu/hr: `elif input_capacity <= 140000:` + - calculate the expected efficiency for VERY_SMALL draw pattern: `if draw_pattern == "VERY_SMALL": expected_UEF = 0.2932 – (0.0015 * volume)` + - calculate the expected efficiency for LOW draw pattern: `if draw_pattern == "LOW": expected_UEF = 0.5596 – (0.0018 * volume)` + - calculate the expected efficiency for MEDIUM draw pattern: `if draw_pattern == "MEDIUM": expected_UEF = 0.6194 – (0.0016 * volume)` + - calculate the expected efficiency for HIGH draw pattern: `if draw_pattern == "HIGH": expected_UEF = 0.6740 – (0.0013 * volume)` + - check that the storage volume is <= 120 gallons: `if volume > 120 gallons:` + - add the following text to the note: "For Oil Storage heaters, with capacity <= 140,000 btu/hr, the storage volume should be <= 120 gallons.": `rule_note += "For Oil Storage heaters, with capacity <= 140,000 btu/hr, the storage volume should be <= 120 gallons. "` + - set has_fault to true: `has_fault = true` + - the capacity per volume should be < 4000 btu/hr/gallon: `if capacity_per_volume >= 4000:` + - add the following text to the note: "For Oil Storage heaters, with capacity <= 140,000 btu/hr, the capacity per volume should be < 4000 btu/hr/gallon.": `rule_note += "For Oil Storage heaters, with capacity <= 140,000 btu/hr, the capacity per volume should be < 4000 btu/hr/gallon. "` + - set has_fault to true: `has_fault = true` + - the setpoint temperature should be less than or equal to 180F: `if shw_eq.setpoint_temperature > 180:` + - add the following text to the note: "For Oil Storage Water heaters, the supply water temperature must be <= 180F": `rule_note += "For Oil Storage Water heaters, the supply water temperature must be <= 180F"` + - set has_fault to true: `has_fault = true` + - check whether the uniform_energy_factor is valid: `if uniform_energy_factor != NULL` + - check if the actual uniform_energy_factor is >= to the expected: `if uniform_energy_factor >= expected_UEF and !has_faults:` + - set rule_status to "PASS": `rule_status = "PASS"` + - otherwise, set rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note = "Uniform Energy Factor is required but not provided"` + - else the input capacity is >= 140,000 btu/hr: `else:` + - the capacity per volume should be < 4000 btu/hr/gallon: `if capacity_per_volume >= 4000:` + - add the following text to the note: "For Oil Storage heaters, with capacity > 140,000 btu/hr, the capacity per volume should be < 4000 btu/hr/gallon.": `rule_note += "For Oil Storage heaters, with capacity <= 140,000 btu/hr, the capacity per volume should be < 4000 btu/hr/gallon. "` + - set has_fault to true: `has_fault = true` + - set the expected thermal efficiency to 0.8: `expected_thermal_efficiency = 0.8` + - make sure that the thermal efficiency is not NULL: `if thermal_efficiency != NULL:` - check whether the uniform_energy_factor is valid: `if uniform_energy_factor != NULL` - - check if the actual uniform_energy_factor is >= to the expected: `if uniform_energy_factor >= expected_UEF && !has_faults:` + - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.thermal_efficiency >= expected_thermal_efficiency and !has_faults:` - set rule_status to "PASS": `rule_status = "PASS"` - otherwise, set rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note = "Uniform Energy Factor is required but not provided"` - - else the input capacity is >= 140,000 btu/hr: `else:` - - the capacity per volume should be < 4000 btu/hr/gallon: `if capacity_per_volume >= 4000:` - - add the following text to the note: "For Oil Storage heaters, with capacity > 140,000 btu/hr, the capacity per volume should be < 4000 btu/hr/gallon.": `rule_note += "For Oil Storage heaters, with capacity <= 140,000 btu/hr, the capacity per volume should be < 4000 btu/hr/gallon. "` - - set has_fault to true: `has_fault = true` - - set the expected thermal efficiency to 0.8: `expected_thermal_efficiency = 0.8` - - make sure that the thermal efficiency is not NULL: `if thermal_efficiency != NULL:` - - check whether the uniform_energy_factor is valid: `if uniform_energy_factor != NULL` - - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.thermal_efficiency >= expected_thermal_efficiency && !has_faults:` - - set rule_status to "PASS": `rule_status = "PASS"` - - otherwise, set rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note = "Uniform Energy Factor is required but not provided"` - - otherwise set the rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note = "No thermal efficiency provided. Expected thermal efficiency is: " + expected_thermal_efficiency` + - otherwise set the rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note = "No thermal efficiency provided. Expected thermal efficiency is: " + expected_thermal_efficiency` **Rule Assertion - Zone:** - Case1: swh_type is INSTANTANEOUS - there is no baseline instantaneous water heater types: `if swh_type == "INSTANTANEOUS": UNDETERMINED; rule_note = "There baseline water heater is of an Instantaneous type. There are no acceptable instantaneous baseline water heaters in Table G3.1.1-2."` From ffc634b5a7692d4c0d40d6f866a9a1c08c6ce370 Mon Sep 17 00:00:00 2001 From: KarenWGard <114143532+KarenWGard@users.noreply.github.com> Date: Wed, 4 Dec 2024 14:20:17 -0500 Subject: [PATCH 14/25] Update Rule_11-10.md --- docs/section11/Rule_11-10.md | 32 ++++++++++++++++++++++---------- 1 file changed, 22 insertions(+), 10 deletions(-) diff --git a/docs/section11/Rule_11-10.md b/docs/section11/Rule_11-10.md index 01aad32917..90f1749ac3 100644 --- a/docs/section11/Rule_11-10.md +++ b/docs/section11/Rule_11-10.md @@ -17,14 +17,24 @@ **Applicability Checks:** - Each SHW Equipment is applicable -- use get_SHW_equipment_associated_with_each_SWH_bat to get the SHW BATs and SHW use in the building: `shw_bats_and_equip_dict = get_SHW_equipment_associated_with_each_SWH_bat(B_RMD)` +- use get_SHW_equipment_associated_with_each_SWH_bat to get the SHW BATs and SHW use in the building: `shw_bats_and_equip_dict = get_SWH_components_associated_with_each_SWH_bat(B_RMD)` +- look at each SHW equipment in the building: `for swh_eq in B_RMD.service_water_heating_equipment:` + - CONTINUE TO RULE LOGIC +- there are no cases where a Service Water Heating Equipment is not applicable to the rule - look through each of the SHW bats in the building: `for shw_bat in shw_bats_and_equip_dict:` - look through each SHW Equipment: `for service_water_heating_equipment_id in shw_bats_and_equip_dict[shw_bat]: CONTINUE TO RULE LOGIC` +- if there are no SWH equipment in the RMD, then this rule will not be evaluated ## Rule Logic: - create a value to track the rule status: `rule_status = "FAIL"` - create a variable to track any notes: `rule_note = """` + - find the swh_bat by looking at each swh_bat in shw_bats_and_equip_dict, and looking for the swh_eq.id in the list of SWHHeatingEq for each BAT. Start by setting the swh_bat to "NONE: `swh_bat = "NONE"` + - look at each swh building area type: `for swh_bat1 in shw_bats_and_equip_dict:` + - look for the id of the swh_eq in the SWHHeatingEq list: `if swh_eq.id in? shw_bats_and_equip_dict[swh_bat1]["SWHHeatingEq"]:` + - set the swh_bat to swh_bat1: `swh_bat = swh_bat1` + - and break out of the loop: `break` + - check if the swh_bat is still NONE we cannot evaluate the rule, create a note, and go to rule assertion: `if swh_bat == "NONE"; rule_note = "We were not able to identify the building area type for this service water heater, so the rule will not be evaluated."; GO TO RULE ASSERTION` - we need to find the following information about the SWH: - swh_heater_type - (ELECTRIC_RESISTANCE_INSTANTANEOUS, ELECTRIC_RESISTANCE_STORAGE, GAS_STORAGE, OTHER) - swh_type - one of the SWH BATs @@ -100,32 +110,34 @@ - determine the UEF based on the draw pattern for MEDIUM: `if draw_pattern == "MEDIUM": expected_uef = 0.6483 – (0.0017 × storage_volume)` - determine the UEF based on the draw pattern for HIGH: `if draw_pattern == "HIGH": expected_uef = 0.6920 – (0.0013 × storage_volume)` - check whether the uniform_energy_factor is valid: `if uniform_energy_factor != NULL - - check if the actual uniform_energy_factor is >= to the expected: `if uniform_energy_factor >= expected_UEF:` + - check if the actual uniform_energy_factor is equals the expected: `if uniform_energy_factor == expected_UEF:` - set rule_status to "PASS": `rule_status = "PASS"` - - otherwise, set rule status to FAIL and provide the note that the expected UEF is less than the required UEF: `else: rule_status = "FAIL"; rule_note = "The modeled Uniform energy Factor (UEF - " + uniform_energy_factor + ") is less than required (" + expected_UEF + ")"` + - otherwise, set rule status to FAIL and provide the note that the expected UEF is less than the required UEF: `else: rule_status = "FAIL"; rule_note = "The modeled Uniform energy Factor (UEF - " + uniform_energy_factor + ") does not equal the required (" + expected_UEF + ")"` - otherwise, set rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note = "Uniform Energy Factor is required but not provided"` + - otherwise, if the storage volume is less than 20 gallons, we will not be able to evaluate the rule logic, Provide a note and continue to rule evaluation: `elif storage_volume < 20: rule_note = "The storage tank volume is less than 20 gallons and the input capacity is <= 75,000 Btuh and based on the size categories in ASHRAE 90.1 Table 7.8 and Appendix F it would not be classified as a gas storage water heater. Consequently, this rule was not able to be assessed for this service water heater. "; GO TO RULE ASSERTION` - otherwise, if the storage volume is between 55 and 100 gallons: `elif storage_volume <= 100:` - determine the UEF based on the draw pattern for VERY_SMALL: `if draw_pattern == "VERY_SMALL": expected_uef = 0.6470 – (0.0006 × storage_volume)` - determine the UEF based on the draw pattern for LOW: `if draw_pattern == "LOW": expected_uef = 0.7689 – (0.0005 × storage_volume)` - determine the UEF based on the draw pattern for MEDIUM: `if draw_pattern == "MEDIUM": expected_uef = 0.7897 – (0.0004 × storage_volume)` - determine the UEF based on the draw pattern for HIGH: `if draw_pattern == "HIGH": expected_uef = 0.8072 – (0.0003 × storage_volume)` - check whether the uniform_energy_factor is valid: `if uniform_energy_factor != NULL - - check if the actual uniform_energy_factor is >= to the expected: `if uniform_energy_factor >= expected_UEF:` + - check if the actual uniform_energy_factor is >= to the expected: `if uniform_energy_factor == expected_UEF:` - set rule_status to "PASS": `rule_status = "PASS"` - - otherwise, set rule status to FAIL and provide the note that the expected UEF is less than the required UEF: `else: rule_status = "FAIL"; rule_note = "The modeled Uniform energy Factor (UEF - " + uniform_energy_factor + ") is less than required (" + expected_UEF + ")"` + - otherwise, set rule status to FAIL and provide the note that the expected UEF is does not equal the required UEF: `else: rule_status = "FAIL"; rule_note = "The modeled Uniform energy Factor (UEF - " + uniform_energy_factor + ") does not equal the required (" + expected_UEF + ")"` - otherwise, set rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note = "Uniform Energy Factor is required but not provided"` - - otherwise, the storage volume is either greater than 100 gallons, or between 2 and 20, which is not covered by Appendix F: `else:` - - create a note indicating that gas water heaters greater with input capacity < 75,000 btu/hr and the given storage volume are not covered under Appendix F: `rule_note: "Gas water heaters with an input capacity < 75,000 btu/hr and a storage capacity of " + storage_volume + " are not covered under Appendix F"` + + - otherwise, the storage volume is greater than 100 gallons, which is not covered by Appendix F: `else:` + - create a note indicating that gas water heaters greater with input capacity < 75,000 btu/hr and the given storage volume are not covered under Appendix F: `rule_note: "The storage tank volume is greater than 100 gallons and the input capacity is <= 75,000 Btuh and based on the size categories in ASHRAE 90.1 Table 7.8 and Appendix F it would not be classified as a gas storage water heater. Consequently, this rule was not able to be assessed for this service water heater."` - change rule_status to UNDETERMINED: `rule_status = "UNDETERMINED"` - check if the capacity <= 105,000 btu/hr: `elif input_capacity <= 105000:` - the capacity per volume should be < 4000 btu/hr/gallon: `if capacity_per_volume >= 4000:` - - add the following text to the note: "For Gas Storage Water heaters, the capacity per volume should be less than 4000 btu/hr/gallon": `rule_note += "For Gas Storage Water heaters, the capacity per volume should be less than 4000 btu/hr/gallon. "` + - add the to the rule note: `rule_note += "Based on the size categories for gas storage water heaters in ASHRAE 90.1 Table 7.8, gas storage water heaters with an input capacity between 75,000 and 105,000 btu/hr shall have a capacity per volume of 4,000 btu/hr/gallon. This water heater has a capacity per gallon of " + capacity_per_volume = " Consequently, this rule was not able to be assesed for this service water heater. "` - set has_fault to true: `has_fault = true` - the volume should be <= 120 gallons: `if storage_volume > 120:` - - add the following text to the note: "For Gas Storage Water heaters with capacity less than 105,000 btu/hr, the storage capacity is expected to be less than 120 gallons": `rule_note += "For Gas Storage Water heaters with capacity less than 105,000 btu/hr, the storage capacity is expected to be less than 120 gallons. "` + - add to the rule note: `rule_note += "Based on the size categories for gas storage water heaters in ASHRAE 90.1 Table 7.8, gas storage water heaters with an input capacity between 75,000 and 105,000 btu/hr shall have a storage capacity of <= 120 gallons. The storage capacity of this water heater is " + storage_volume + ". "` - set has_fault to true: `has_fault = true` - the supply water temperature should be <= 180F: `if shw_eq.setpoint_temperature > 180:` - - add the following text to the note: "For Gas Storage Water heaters with capacity less than 105,000 btu/hr, the supply water temperature is expected to be <= 180F": `rule_note += "For Gas Storage Water heaters with capacity less than 105,000 btu/hr, the supply water temperature is expected to be <= 180F. "` + - add to the rule note: `rule_note += "Based on the size categories for gas storage water heaters in ASHRAE 90.1 Table 7.8, gas storage water heaters with an input capacity between 75,000 and 105,000 btu/hr shall have a setpoint temperature of 180F. The setpoint temperature of this water heater is " + shw_eq.setpoint_temperature + ". "` - set has_fault to true: `has_fault = true` - calculate the expected efficiency for VERY_SMALL draw pattern: `if draw_pattern == "VERY_SMALL": expected_UEF = 0.2674 – (0.0009 * volume)` - calculate the expected efficiency for LOW draw pattern: `if draw_pattern == "LOW": expected_UEF = 0.5362 – (0.0012 * volume)` From 62815fddccf1abe1a46db0a23a1a535e2de4ddf4 Mon Sep 17 00:00:00 2001 From: KarenWGard <114143532+KarenWGard@users.noreply.github.com> Date: Wed, 4 Dec 2024 14:36:33 -0500 Subject: [PATCH 15/25] Update Rule_11-10.md --- docs/section11/Rule_11-10.md | 28 ++++++++++++++-------------- 1 file changed, 14 insertions(+), 14 deletions(-) diff --git a/docs/section11/Rule_11-10.md b/docs/section11/Rule_11-10.md index 90f1749ac3..3246e9f580 100644 --- a/docs/section11/Rule_11-10.md +++ b/docs/section11/Rule_11-10.md @@ -131,31 +131,31 @@ - change rule_status to UNDETERMINED: `rule_status = "UNDETERMINED"` - check if the capacity <= 105,000 btu/hr: `elif input_capacity <= 105000:` - the capacity per volume should be < 4000 btu/hr/gallon: `if capacity_per_volume >= 4000:` - - add the to the rule note: `rule_note += "Based on the size categories for gas storage water heaters in ASHRAE 90.1 Table 7.8, gas storage water heaters with an input capacity between 75,000 and 105,000 btu/hr shall have a capacity per volume of 4,000 btu/hr/gallon. This water heater has a capacity per gallon of " + capacity_per_volume = " Consequently, this rule was not able to be assesed for this service water heater. "` + - add the to the rule note: `rule_note += "Based on the size categories for gas storage water heaters in ASHRAE 90.1 Table 7.8, gas storage water heaters with an input capacity between 75,000 and 105,000 btu/hr shall have a capacity per volume of 4,000 btu/hr/gallon. This water heater has a capacity per gallon of " + capacity_per_volume + " btu/hr/gallon. Consequently, this rule was not able to be assesed for this service water heater. "` - set has_fault to true: `has_fault = true` - the volume should be <= 120 gallons: `if storage_volume > 120:` - - add to the rule note: `rule_note += "Based on the size categories for gas storage water heaters in ASHRAE 90.1 Table 7.8, gas storage water heaters with an input capacity between 75,000 and 105,000 btu/hr shall have a storage capacity of <= 120 gallons. The storage capacity of this water heater is " + storage_volume + ". "` + - add to the rule note: `rule_note += "Based on the size categories for gas storage water heaters in ASHRAE 90.1 Table 7.8, gas storage water heaters with an input capacity between 75,000 and 105,000 btu/hr shall have a storage capacity of <= 120 gallons. The storage capacity of this water heater is " + storage_volume + " gallons. "` - set has_fault to true: `has_fault = true` - the supply water temperature should be <= 180F: `if shw_eq.setpoint_temperature > 180:` - - add to the rule note: `rule_note += "Based on the size categories for gas storage water heaters in ASHRAE 90.1 Table 7.8, gas storage water heaters with an input capacity between 75,000 and 105,000 btu/hr shall have a setpoint temperature of 180F. The setpoint temperature of this water heater is " + shw_eq.setpoint_temperature + ". "` + - add to the rule note: `rule_note += "Based on the size categories for gas storage water heaters in ASHRAE 90.1 Table 7.8, gas storage water heaters with an input capacity between 75,000 and 105,000 btu/hr shall have a setpoint temperature of 180F. The setpoint temperature of this water heater is " + shw_eq.setpoint_temperature + "F. "` - set has_fault to true: `has_fault = true` - calculate the expected efficiency for VERY_SMALL draw pattern: `if draw_pattern == "VERY_SMALL": expected_UEF = 0.2674 – (0.0009 * volume)` - calculate the expected efficiency for LOW draw pattern: `if draw_pattern == "LOW": expected_UEF = 0.5362 – (0.0012 * volume)` - calculate the expected efficiency for MEDIUM draw pattern: `if draw_pattern == "MEDIUM": expected_UEF = 0.6002 – (0.0011 * volume)` - calculate the expected efficiency for HIGH draw pattern: `if draw_pattern == "HIGH": expected_UEF = 0.6597 – (0.0009 * volume)` - check whether the uniform_energy_factor is valid: `if uniform_energy_factor != NULL - - check if the actual uniform_energy_factor is >= to the expected: `if uniform_energy_factor >= expected_UEF and !has_faults:` + - check if the actual uniform_energy_factor equal to the expected: `if uniform_energy_factor == expected_UEF and !has_faults:` - set rule_status to "PASS": `rule_status = "PASS"` - otherwise, set rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note = "Uniform Energy Factor is required but not provided"` - otherwise the capacity is > 105,000 btu/hr: `else:` - the capacity per volume should be < 4000 btu/hr/gallon: `if capacity_per_volume >= 4000:` - - add the following text to the note: "For Gas Storage Water heaters, the capacity per volume should be less than 4000 btu/hr/gallon": `rule_note += "For Gas Storage Water heaters, the capacity per volume should be less than 4000 btu/hr/gallon. "` + - add to the rule note: `rule_note += "Based on the size categories for gas storage water heaters in ASHRAE 90.1 Table 7.8, gas storage water heaters with an input capacity greater than 105,000 btu/hr shall have a capacity per volume of 4,000 btu/hr/gallon. This water heater has a capacity per gallon of " + capacity_per_volume + " btu/hr/gallon. Consequently, this rule was not able to be assesed for this service water heater. "` - set has_fault to true: `has_fault = true` - calculate the expected_thermal_efficiency : `expected_thermal_efficiency = 0.8` - calculate max_standby_loss (btu/hr): `max_standby_loss = (input_capacity/800 + 110 * sqrt(volume))` - make sure that the thermal efficiency is not NULL: `if thermal_efficiency != NULL:` - check whether the uniform_energy_factor is valid: `if uniform_energy_factor != NULL` - - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.thermal_efficiency >= expected_thermal_efficiency and standby_loss <= max_standby_loss and !has_faults:` + - check if the actual uniform_energy_factor is == to the expected: `if shw_eq.thermal_efficiency == expected_thermal_efficiency and standby_loss <= max_standby_loss and !has_faults:` - set rule_status to "PASS": `rule_status = "PASS"` - otherwise, set rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note = "Uniform Energy Factor is required but not provided"` - otherwise set the rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note = "No thermal efficiency provided. Expected thermal efficiency is: " + expected_thermal_efficiency` @@ -167,9 +167,9 @@ - determine the UEF based on the draw pattern for MEDIUM: `if draw_pattern == "MEDIUM": expected_uef = 0.6078 – (0.0016 × storage_volume)` - determine the UEF based on the draw pattern for HIGH: `if draw_pattern == "HIGH": expected_uef = 0.6815 – (0.0014 × storage_volume)` - check whether the uniform_energy_factor is valid: `if uniform_energy_factor != NULL` - - check if the actual uniform_energy_factor is >= to the expected: `if uniform_energy_factor >= expected_UEF:` + - check if the actual uniform_energy_factor is == to the expected: `if uniform_energy_factor == expected_UEF:` - set rule_status to "PASS": `rule_status = "PASS"` - - otherwise, set rule status to FAIL and provide the note that the expected UEF is less than the required UEF: `else: rule_status = "FAIL"; rule_note = "The modeled Uniform energy Factor (UEF - " + uniform_energy_factor + ") is less than required (" + expected_UEF + ")"` + - otherwise, set rule status to FAIL and provide the note that the expected UEF is not equal to the required UEF: `else: rule_status = "FAIL"; rule_note = "The modeled Uniform energy Factor (UEF - " + uniform_energy_factor + ") is not equal to the required (" + expected_UEF + ")"` - otherwise, set rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note = "Uniform Energy Factor is required but not provided"` - otherwise, the storage volume is greater 50 gallons and is not covered by Appendix F: `else:` - create a note indicating that gas water heaters with storage volume greater than 50 gallons are not covered under Appendix F: `rule_note: "Gas water heaters with a storage volume greater than 50 gallons are not covered under Appendix F"` @@ -180,26 +180,26 @@ - calculate the expected efficiency for MEDIUM draw pattern: `if draw_pattern == "MEDIUM": expected_UEF = 0.6194 – (0.0016 * volume)` - calculate the expected efficiency for HIGH draw pattern: `if draw_pattern == "HIGH": expected_UEF = 0.6740 – (0.0013 * volume)` - check that the storage volume is <= 120 gallons: `if volume > 120 gallons:` - - add the following text to the note: "For Oil Storage heaters, with capacity <= 140,000 btu/hr, the storage volume should be <= 120 gallons.": `rule_note += "For Oil Storage heaters, with capacity <= 140,000 btu/hr, the storage volume should be <= 120 gallons. "` + - add to the note: `rule_note += "Based on the size categories for oil storage water heaters in ASHRAE 90.1 Table 7.8, oil storage water heaters with an input capacity between 105,000 and 140,000 btu/hr shall have a storage volume <= 120 gallons. This water heater has a storage volume of " + volume + " gallons. Consequently, this rule was not able to be assesed for this service water heater. "` - set has_fault to true: `has_fault = true` - the capacity per volume should be < 4000 btu/hr/gallon: `if capacity_per_volume >= 4000:` - - add the following text to the note: "For Oil Storage heaters, with capacity <= 140,000 btu/hr, the capacity per volume should be < 4000 btu/hr/gallon.": `rule_note += "For Oil Storage heaters, with capacity <= 140,000 btu/hr, the capacity per volume should be < 4000 btu/hr/gallon. "` + - add to the note: `rule_note += "Based on the size categories for oil storage water heaters in ASHRAE 90.1 Table 7.8, oil storage water heaters with an input capacity between 105,000 and 140,000 btu/hr shall have a capacity per volume >= 4000 btu/hour. This water heater has a capacity per volume of " + capacity_per_volume + " btu/hr/gallon. Consequently, this rule was not able to be assesed for this service water heater. "` - set has_fault to true: `has_fault = true` - the setpoint temperature should be less than or equal to 180F: `if shw_eq.setpoint_temperature > 180:` - - add the following text to the note: "For Oil Storage Water heaters, the supply water temperature must be <= 180F": `rule_note += "For Oil Storage Water heaters, the supply water temperature must be <= 180F"` + - add to the note: `rule_note += "Based on the size categories for oil storage water heaters in ASHRAE 90.1 Table 7.8, oil storage water heaters shall have a temperature setpoint <= 180 F. This water heater has a temperature setpoint of " + shw_eq.setpoint_temperature + " F. Consequently, this rule was not able to be assesed for this service water heater. "` - set has_fault to true: `has_fault = true` - check whether the uniform_energy_factor is valid: `if uniform_energy_factor != NULL` - - check if the actual uniform_energy_factor is >= to the expected: `if uniform_energy_factor >= expected_UEF and !has_faults:` + - check if the actual uniform_energy_factor is == to the expected: `if uniform_energy_factor == expected_UEF and !has_faults:` - set rule_status to "PASS": `rule_status = "PASS"` - otherwise, set rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note = "Uniform Energy Factor is required but not provided"` - else the input capacity is >= 140,000 btu/hr: `else:` - the capacity per volume should be < 4000 btu/hr/gallon: `if capacity_per_volume >= 4000:` - - add the following text to the note: "For Oil Storage heaters, with capacity > 140,000 btu/hr, the capacity per volume should be < 4000 btu/hr/gallon.": `rule_note += "For Oil Storage heaters, with capacity <= 140,000 btu/hr, the capacity per volume should be < 4000 btu/hr/gallon. "` + - add to the note: `rule_note += "Based on the size categories for oil storage water heaters in ASHRAE 90.1 Table 7.8, oil storage water heaters with a capacity >= 140,00 btu/hr shall have a capacity per volume < 4000 btu/gallon. This water heater has a capacity per gallon of " + capacity_per_volume + " btu/gallon. Consequently, this rule was not able to be assesed for this service water heater. "` - set has_fault to true: `has_fault = true` - set the expected thermal efficiency to 0.8: `expected_thermal_efficiency = 0.8` - make sure that the thermal efficiency is not NULL: `if thermal_efficiency != NULL:` - check whether the uniform_energy_factor is valid: `if uniform_energy_factor != NULL` - - check if the actual uniform_energy_factor is >= to the expected: `if shw_eq.thermal_efficiency >= expected_thermal_efficiency and !has_faults:` + - check if the actual uniform_energy_factor is == to the expected: `if shw_eq.thermal_efficiency == expected_thermal_efficiency and !has_faults:` - set rule_status to "PASS": `rule_status = "PASS"` - otherwise, set rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note = "Uniform Energy Factor is required but not provided"` - otherwise set the rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note = "No thermal efficiency provided. Expected thermal efficiency is: " + expected_thermal_efficiency` From 61bd71b68071a9e66a571a54c36b49c790664602 Mon Sep 17 00:00:00 2001 From: KarenWGard <114143532+KarenWGard@users.noreply.github.com> Date: Wed, 4 Dec 2024 14:50:19 -0500 Subject: [PATCH 16/25] Update Rule_11-10.md --- docs/section11/Rule_11-10.md | 55 ++++-------------------------------- 1 file changed, 5 insertions(+), 50 deletions(-) diff --git a/docs/section11/Rule_11-10.md b/docs/section11/Rule_11-10.md index 3246e9f580..3943e40421 100644 --- a/docs/section11/Rule_11-10.md +++ b/docs/section11/Rule_11-10.md @@ -1,4 +1,4 @@ -# HVAC_SystemZoneAssignment - Rule 11-10 +# ServiceWaterHeating - Rule 11-10 **Schema Version:** 0.0.37 **Mandatory Rule:** True @@ -36,7 +36,6 @@ - and break out of the loop: `break` - check if the swh_bat is still NONE we cannot evaluate the rule, create a note, and go to rule assertion: `if swh_bat == "NONE"; rule_note = "We were not able to identify the building area type for this service water heater, so the rule will not be evaluated."; GO TO RULE ASSERTION` - we need to find the following information about the SWH: - - swh_heater_type - (ELECTRIC_RESISTANCE_INSTANTANEOUS, ELECTRIC_RESISTANCE_STORAGE, GAS_STORAGE, OTHER) - swh_type - one of the SWH BATs - input_capacity (btu/hr) - storage_volume (gallons) @@ -44,7 +43,6 @@ - capacity_per_volume (btu/hr/gallon) - get the service water heating system: `swh_eq = get_object_by_id(service_water_heating_equipment_id,RMD)` - get the type of tank: `tank_type = swh_eq.tank.type` - - get the type of heater: `swh_heater_type = swh_eq.heater_type` - the swh_type will be one of the ServiceWaterHeaterTankOptions, which are more detailed than the four types we need. Determine our type based on the detailed type. - the default value of swh_type is OTHER. If the swh_type can be identified, the value will be changed in the logic below: `swh_type = "OTHER"` - if the tank_type is CONSUMER_INSTANTANEOUS, COMMERCIAL_INSTANTANEOUS, or RESIDENTIAL_DUTY_COMMERCIAL_INSTANTANEOUS, set the swh_type to INSTANTANEOUS and go to rule assertion: `if tank_type in ["CONSUMER_INSTANTANEOUS", "COMMERCIAL_INSTANTANEOUS", "RESIDENTIAL_DUTY_COMMERCIAL_INSTANTANEOUS"]: swh_type = "INSTANTANEOUS"`; GO TO RULE_ASSERTION @@ -53,7 +51,8 @@ - if the tank_type is CONSUMER_STORAGE or COMMERCIAL_STORAGE, set the swh_type to STORAGE for the fuel type: `if tank_type in ["CONSUMER_STORAGE", "COMMERCIAL_STORAGE"]:` - set the swh_type based on tank_type and fuel type: `if fuel_type == "ELECTRICITY": swh_type = "ELECTRIC_RESISTANCE_STORAGE` - `elif fuel_type == "NATURAL_GAS": swh_type = "GAS_STORAGE` - - `elif fuel_type == "FUEL_OIL": swh_type = "OIL_STORAGE` + - if the fuel type is propane, this is treated as natural gas in Table 7.8: `elif fuel_type == "PROPANE": swh_type = "GAS_STORAGE"` + - if the fuel type is not Electricity, Natural Gas, or Propane, this is not a valid baseline SWH system. Create a rule note and go directly to the rule assertion: `else: rule_note += "Fuel type: " + fuel_type + " is not a valid fuel type for a service water heating baseline system. According to ASHRAE 90.1 Table G3.1.1-2 service water heating equipment shall be either electric resistance or natural gas. According to ASHRAE 90.1 Table G3.1 #11 h, in cases where natural gas is specified as the baseline system, but there is no natural gas available on site, a propane system may be modeled. " ` - if the draw_pattern is given, get the draw pattern: `if shw_eq.draw_pattern != null: draw_pattern = shw_eq.draw_pattern` - otherwise, determine the draw pattern based off the first_hour_rating of the shw_eq: `else:` - First get the first hour rating (gallons): `first_hour_rating = shw_eq.first_hour_rating` @@ -159,52 +158,8 @@ - set rule_status to "PASS": `rule_status = "PASS"` - otherwise, set rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note = "Uniform Energy Factor is required but not provided"` - otherwise set the rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note = "No thermal efficiency provided. Expected thermal efficiency is: " + expected_thermal_efficiency` - - check if the water heater is OIL_STORAGE: `elif swh_type == "OIL_STORAGE` - - if the input capacity <= 105,000 btu/hr, this equipment is covered under Appendix F: `if input_capacity <= 105000:` - - look to see if the water heater is covered in Appendix F, first look to see if it is anything less than 50 gallons of storage: `if storage_volume < 50:` - - determine the UEF based on the draw pattern for VERY_SMALL: `if draw_pattern == "VERY_SMALL": expected_uef = 0.2509 – (0.0012 × storage_volume)` - - determine the UEF based on the draw pattern for LOW: `if draw_pattern == "LOW": expected_uef = 0.5330 – (0.0016 × storage_volume)` - - determine the UEF based on the draw pattern for MEDIUM: `if draw_pattern == "MEDIUM": expected_uef = 0.6078 – (0.0016 × storage_volume)` - - determine the UEF based on the draw pattern for HIGH: `if draw_pattern == "HIGH": expected_uef = 0.6815 – (0.0014 × storage_volume)` - - check whether the uniform_energy_factor is valid: `if uniform_energy_factor != NULL` - - check if the actual uniform_energy_factor is == to the expected: `if uniform_energy_factor == expected_UEF:` - - set rule_status to "PASS": `rule_status = "PASS"` - - otherwise, set rule status to FAIL and provide the note that the expected UEF is not equal to the required UEF: `else: rule_status = "FAIL"; rule_note = "The modeled Uniform energy Factor (UEF - " + uniform_energy_factor + ") is not equal to the required (" + expected_UEF + ")"` - - otherwise, set rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note = "Uniform Energy Factor is required but not provided"` - - otherwise, the storage volume is greater 50 gallons and is not covered by Appendix F: `else:` - - create a note indicating that gas water heaters with storage volume greater than 50 gallons are not covered under Appendix F: `rule_note: "Gas water heaters with a storage volume greater than 50 gallons are not covered under Appendix F"` - - change rule_status to UNDETERMINED: `rule_status = "UNDETERMINED"` - - else if the input capacity is <= 140,000 btu/hr: `elif input_capacity <= 140000:` - - calculate the expected efficiency for VERY_SMALL draw pattern: `if draw_pattern == "VERY_SMALL": expected_UEF = 0.2932 – (0.0015 * volume)` - - calculate the expected efficiency for LOW draw pattern: `if draw_pattern == "LOW": expected_UEF = 0.5596 – (0.0018 * volume)` - - calculate the expected efficiency for MEDIUM draw pattern: `if draw_pattern == "MEDIUM": expected_UEF = 0.6194 – (0.0016 * volume)` - - calculate the expected efficiency for HIGH draw pattern: `if draw_pattern == "HIGH": expected_UEF = 0.6740 – (0.0013 * volume)` - - check that the storage volume is <= 120 gallons: `if volume > 120 gallons:` - - add to the note: `rule_note += "Based on the size categories for oil storage water heaters in ASHRAE 90.1 Table 7.8, oil storage water heaters with an input capacity between 105,000 and 140,000 btu/hr shall have a storage volume <= 120 gallons. This water heater has a storage volume of " + volume + " gallons. Consequently, this rule was not able to be assesed for this service water heater. "` - - set has_fault to true: `has_fault = true` - - the capacity per volume should be < 4000 btu/hr/gallon: `if capacity_per_volume >= 4000:` - - add to the note: `rule_note += "Based on the size categories for oil storage water heaters in ASHRAE 90.1 Table 7.8, oil storage water heaters with an input capacity between 105,000 and 140,000 btu/hr shall have a capacity per volume >= 4000 btu/hour. This water heater has a capacity per volume of " + capacity_per_volume + " btu/hr/gallon. Consequently, this rule was not able to be assesed for this service water heater. "` - - set has_fault to true: `has_fault = true` - - the setpoint temperature should be less than or equal to 180F: `if shw_eq.setpoint_temperature > 180:` - - add to the note: `rule_note += "Based on the size categories for oil storage water heaters in ASHRAE 90.1 Table 7.8, oil storage water heaters shall have a temperature setpoint <= 180 F. This water heater has a temperature setpoint of " + shw_eq.setpoint_temperature + " F. Consequently, this rule was not able to be assesed for this service water heater. "` - - set has_fault to true: `has_fault = true` - - check whether the uniform_energy_factor is valid: `if uniform_energy_factor != NULL` - - check if the actual uniform_energy_factor is == to the expected: `if uniform_energy_factor == expected_UEF and !has_faults:` - - set rule_status to "PASS": `rule_status = "PASS"` - - otherwise, set rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note = "Uniform Energy Factor is required but not provided"` - - else the input capacity is >= 140,000 btu/hr: `else:` - - the capacity per volume should be < 4000 btu/hr/gallon: `if capacity_per_volume >= 4000:` - - add to the note: `rule_note += "Based on the size categories for oil storage water heaters in ASHRAE 90.1 Table 7.8, oil storage water heaters with a capacity >= 140,00 btu/hr shall have a capacity per volume < 4000 btu/gallon. This water heater has a capacity per gallon of " + capacity_per_volume + " btu/gallon. Consequently, this rule was not able to be assesed for this service water heater. "` - - set has_fault to true: `has_fault = true` - - set the expected thermal efficiency to 0.8: `expected_thermal_efficiency = 0.8` - - make sure that the thermal efficiency is not NULL: `if thermal_efficiency != NULL:` - - check whether the uniform_energy_factor is valid: `if uniform_energy_factor != NULL` - - check if the actual uniform_energy_factor is == to the expected: `if shw_eq.thermal_efficiency == expected_thermal_efficiency and !has_faults:` - - set rule_status to "PASS": `rule_status = "PASS"` - - otherwise, set rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note = "Uniform Energy Factor is required but not provided"` - - otherwise set the rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note = "No thermal efficiency provided. Expected thermal efficiency is: " + expected_thermal_efficiency` - - **Rule Assertion - Zone:** + + **Rule Assertion - ServiceWaterHeatingEquipment:** - Case1: swh_type is INSTANTANEOUS - there is no baseline instantaneous water heater types: `if swh_type == "INSTANTANEOUS": UNDETERMINED; rule_note = "There baseline water heater is of an Instantaneous type. There are no acceptable instantaneous baseline water heaters in Table G3.1.1-2."` - Case2: rule_status is PASS: `if rule_status == "PASS": PASS`. - Case3: rule_status is UNDETERMINED, UNDETERMINED & return rule_note: `elif rule_status == "UNDETERMINED": UNDETERMINED; rule_note` From 80062911c5419b2a28e516fe328829a263f739dd Mon Sep 17 00:00:00 2001 From: KarenWGard <114143532+KarenWGard@users.noreply.github.com> Date: Wed, 4 Dec 2024 17:01:07 -0500 Subject: [PATCH 17/25] Update Rule_11-10.md --- docs/section11/Rule_11-10.md | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/docs/section11/Rule_11-10.md b/docs/section11/Rule_11-10.md index 3943e40421..85c191b439 100644 --- a/docs/section11/Rule_11-10.md +++ b/docs/section11/Rule_11-10.md @@ -21,8 +21,6 @@ - look at each SHW equipment in the building: `for swh_eq in B_RMD.service_water_heating_equipment:` - CONTINUE TO RULE LOGIC - there are no cases where a Service Water Heating Equipment is not applicable to the rule -- look through each of the SHW bats in the building: `for shw_bat in shw_bats_and_equip_dict:` - - look through each SHW Equipment: `for service_water_heating_equipment_id in shw_bats_and_equip_dict[shw_bat]: CONTINUE TO RULE LOGIC` - if there are no SWH equipment in the RMD, then this rule will not be evaluated @@ -96,7 +94,7 @@ - check that the capacity_per_volume < 4000 btu/hr/gallon: `if capacity_per_volume < 4000:` - calculate the standby loss target: `standby_loss_target = 0.3 + (27/swh_eq.distribution_system.tank.storage_volume)` - - - if the standby_loss is less than or equal to the target, set the rule_status to PASS: `if standby_loss <= standby_loss_target: rule_status: "PASS"` + - if the standby_loss is less than or equal to the target, set the rule_status to PASS: `if swh_eq.standby_loss_fraction <= standby_loss_target: rule_status: "PASS"` - otherwise: `else:` - set the note to indicate that the standby_loss is higher than the maximum allowed: `rule_note = "Standby Loss is higher than required by Table 7.8"` - otherwise: `else:` @@ -154,6 +152,7 @@ - calculate max_standby_loss (btu/hr): `max_standby_loss = (input_capacity/800 + 110 * sqrt(volume))` - make sure that the thermal efficiency is not NULL: `if thermal_efficiency != NULL:` - check whether the uniform_energy_factor is valid: `if uniform_energy_factor != NULL` + - get the standby loss (see note 1 for calculation source): `standby_loss = swh_eq.standby_loss_fraction * 8.25 * volume * 70` - check if the actual uniform_energy_factor is == to the expected: `if shw_eq.thermal_efficiency == expected_thermal_efficiency and standby_loss <= max_standby_loss and !has_faults:` - set rule_status to "PASS": `rule_status = "PASS"` - otherwise, set rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note = "Uniform Energy Factor is required but not provided"` @@ -178,6 +177,5 @@ 3. gas- or oil-fired storage water heaters have a flue damper or fan-assisted combustion. 6. Written assuming the issue: https://github.com/open229/ruleset-model-description-schema/issues/287 will be accepted as part of the schema -- get the standby loss (see note 1 for calculation source): `standby_loss = swh_eq.standby_loss_fraction * 8.25 * volume * 70` **[Back](../_toc.md)** From f75bda9feb63555c6d8fdec09831a59f49605ed6 Mon Sep 17 00:00:00 2001 From: KarenWGard <114143532+KarenWGard@users.noreply.github.com> Date: Wed, 4 Dec 2024 17:03:20 -0500 Subject: [PATCH 18/25] Update Rule_11-10.md --- docs/section11/Rule_11-10.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/section11/Rule_11-10.md b/docs/section11/Rule_11-10.md index 85c191b439..5c8fea4dad 100644 --- a/docs/section11/Rule_11-10.md +++ b/docs/section11/Rule_11-10.md @@ -80,7 +80,7 @@ - check if the actual uniform_energy_factor equals the expected: `if uniform_energy_factor == expected_UEF:` - set rule_status to "PASS": `rule_status = "PASS"` - otherwise, set rule status to FAIL and provide the note that the expected UEF is less than the required UEF: `else: rule_status = "FAIL"; rule_note = "The modeled Uniform energy Factor (UEF - " + uniform_energy_factor + ") does not equal required (" + expected_UEF + ")"` - - otherwise, set rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note = "Uniform Energy Factor is required but not provided"` + - otherwise, set rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note = "Uniform Energy Factor is required to evaluate water heaters in ASHRAE 90.1 Table 7.8. Uniform Energy Factor is not provided for this waterheater."` - else, if the storage tank is greater than 55 and less than 100 gallons, Appendix F provides a heat pump efficiency, which may be an error. return UNDETERMINED: `elif storage_volume <=100 and storage_volume > 55:` - set rule_status to UNDETERMINED: `rule_status = "UNDETERMINED"` - include a note: `rule_note = "The storage tank is between 2 and 20 gallons and based on the size categories in ASHRAE 90.1 Table 7.8 and Appendix F it would not be classified as an electric storage water heater. Consequently, this rule was not able to be assessed for this service water heater."` From 8b196023e061e3b8ee9198e5eb44bb665a8d2818 Mon Sep 17 00:00:00 2001 From: KarenWGard <114143532+KarenWGard@users.noreply.github.com> Date: Wed, 11 Dec 2024 08:11:12 -0500 Subject: [PATCH 19/25] Update Rule_11-10.md --- docs/section11/Rule_11-10.md | 18 ++++++------------ 1 file changed, 6 insertions(+), 12 deletions(-) diff --git a/docs/section11/Rule_11-10.md b/docs/section11/Rule_11-10.md index 5c8fea4dad..e23ca2e214 100644 --- a/docs/section11/Rule_11-10.md +++ b/docs/section11/Rule_11-10.md @@ -21,20 +21,14 @@ - look at each SHW equipment in the building: `for swh_eq in B_RMD.service_water_heating_equipment:` - CONTINUE TO RULE LOGIC - there are no cases where a Service Water Heating Equipment is not applicable to the rule -- if there are no SWH equipment in the RMD, then this rule will not be evaluated +- if there are no SWH equipment in the RMD, then this rule is not applicable: `if(len(B_RMD.service_water_heating_equipment) == 0): NOT APPLICABLE` ## Rule Logic: - create a value to track the rule status: `rule_status = "FAIL"` - create a variable to track any notes: `rule_note = """` - - find the swh_bat by looking at each swh_bat in shw_bats_and_equip_dict, and looking for the swh_eq.id in the list of SWHHeatingEq for each BAT. Start by setting the swh_bat to "NONE: `swh_bat = "NONE"` - - look at each swh building area type: `for swh_bat1 in shw_bats_and_equip_dict:` - - look for the id of the swh_eq in the SWHHeatingEq list: `if swh_eq.id in? shw_bats_and_equip_dict[swh_bat1]["SWHHeatingEq"]:` - - set the swh_bat to swh_bat1: `swh_bat = swh_bat1` - - and break out of the loop: `break` - - check if the swh_bat is still NONE we cannot evaluate the rule, create a note, and go to rule assertion: `if swh_bat == "NONE"; rule_note = "We were not able to identify the building area type for this service water heater, so the rule will not be evaluated."; GO TO RULE ASSERTION` - we need to find the following information about the SWH: - - swh_type - one of the SWH BATs + - swh_type - one of the ServiceWaterHeaterTankOptions - input_capacity (btu/hr) - storage_volume (gallons) - draw_pattern (VERY_SMALL, LOW, MEDIUM, or HIGH) @@ -69,8 +63,8 @@ - what follows is logic that implements Table 7.8 - this table has multiple criteria, so I think it's simpler to implement with if / else logic than a table lookup - if the swh_type is OTHER, set rule_note to "Water heater type is not a recognized type", and continue to rule assertion: `if swh_type == "OTHER": rule_note = "Water heater type is not a recognized type"; GO TO RULE ASSERTION` - create a boolean has_fault and set it to false: `has_fault = false` - - if the water heater is electric resistance, or storage and the capacity is <= 12kW (40945 btu/hr), look at Appendix F: `if swh_type in ["ELECTRIC_RESISTANCE_STORAGE"] and input_capacity <= 40945.7:` - - check the size of the storage tank. If it's less than 2 gallons, provide a note, and continue to rule assertion: `if storage_volume < 2: rule_note = "The storage volume is not consistent with an electric storage water heater as it is less than 20 gallons."; GO TO RULE ASSERTION` + - if the water heater is electric resistance storage and the capacity is <= 12kW (40945 btu/hr), look at Appendix F: `if swh_type in ["ELECTRIC_RESISTANCE_STORAGE"] and input_capacity <= 40945.7:` + - check the size of the storage tank. If it's less than 2 gallons, provide a note, and continue to rule assertion: `if storage_volume < 2: rule_note = "The storage tank volume is less than 2 gallons and based on the size categories in ASHRAE 90.1 Table 7.8 and Appendix F it would not be classified as an electric storage water heater. Consequently, this rule was not assessed for this service water heater."; GO TO RULE ASSERTION` - else, if the storage tank is is between 20 and 55 gallons, this is considered an electric storage water heater in Appendix F: `elif storage_volume >= 20 and storage_volume <= 55:` - determine the UEF based on the draw pattern for VERY_SMALL: `if draw_pattern == "VERY_SMALL": expected_uef = 0.8808 – (0.0008 × storage_volume)` - determine the UEF based on the draw pattern for LOW: `if draw_pattern == "LOW": expected_uef = 0.9254 – (0.0003 × storage_volume)` @@ -87,14 +81,14 @@ - go to rule assertion: `GO TO RULE ASSERTION` - else if the storage volume is between 2 and 20 gallons, in which case there is no rating in APPENDIX F. set rule status to UNDETERMINED: `elif storage_volume < 20:` - set the rule status to UNDETERMINED: `rule_status = "UNDETERMINED"` - - add a note: `rule_note = "The storage tank is between 2 and 20 gallons. Appendix F doesn't provide an efficiency for water heaters of this size."` + - add a note: `rule_note = "The storage tank volume is between 2 and 20 gallons and based on the size categories in ASHRAE 90.1 Table 7.8 and Appendix F it would not be classified as an electric storage water heater. Consequently, this rule was not assessed for this service water heater."` - go to rule assertion: `GO TO RULE ASSERTION` - otherwise, continue with rule logic: `else:` - check electric storage water heaters with capacity greater than 12 kW: `if swh_type == "ELECTRIC_RESISTANCE_STORAGE" and input_capacity > 40945.7 (btu/hr):` - check that the capacity_per_volume < 4000 btu/hr/gallon: `if capacity_per_volume < 4000:` - calculate the standby loss target: `standby_loss_target = 0.3 + (27/swh_eq.distribution_system.tank.storage_volume)` - - - if the standby_loss is less than or equal to the target, set the rule_status to PASS: `if swh_eq.standby_loss_fraction <= standby_loss_target: rule_status: "PASS"` + - if the standby_loss is equal to the target, set the rule_status to PASS: `if swh_eq.standby_loss_fraction <= standby_loss_target: rule_status: "PASS"` - otherwise: `else:` - set the note to indicate that the standby_loss is higher than the maximum allowed: `rule_note = "Standby Loss is higher than required by Table 7.8"` - otherwise: `else:` From 0eab99e9f1dddfca64cbd0173b5df560027c98af Mon Sep 17 00:00:00 2001 From: KarenWGard <114143532+KarenWGard@users.noreply.github.com> Date: Wed, 11 Dec 2024 08:17:25 -0500 Subject: [PATCH 20/25] Update Rule_11-10.md --- docs/section11/Rule_11-10.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/section11/Rule_11-10.md b/docs/section11/Rule_11-10.md index e23ca2e214..7d1896a600 100644 --- a/docs/section11/Rule_11-10.md +++ b/docs/section11/Rule_11-10.md @@ -92,7 +92,7 @@ - otherwise: `else:` - set the note to indicate that the standby_loss is higher than the maximum allowed: `rule_note = "Standby Loss is higher than required by Table 7.8"` - otherwise: `else:` - - set the note to indicate that the capacity per volume exceeds the limit: `rule_note = "Capacity per volume exceeds the limit of 4000 btu/hr/gallon for Electric Storage Water Heaters` + - set the note to indicate that the capacity per volume exceeds the limit: `rule_note = "Capacity per volume exceeds the limit of 4000 btu/hr/gallon given for Electric Storage Water Heaters in ASHRAE 90.1 Table 7.8."` - check if the water heater is gas storage: `if swh_type == "GAS_STORAGE":` - check if the capacity is <= 75,000 btu/hr: `if input_capacity <= 75000:` - if the storage volume is between 20 and 55 gallons: `if storage_volume >= 20 and storage_volume <= 55:` @@ -104,7 +104,7 @@ - check if the actual uniform_energy_factor is equals the expected: `if uniform_energy_factor == expected_UEF:` - set rule_status to "PASS": `rule_status = "PASS"` - otherwise, set rule status to FAIL and provide the note that the expected UEF is less than the required UEF: `else: rule_status = "FAIL"; rule_note = "The modeled Uniform energy Factor (UEF - " + uniform_energy_factor + ") does not equal the required (" + expected_UEF + ")"` - - otherwise, set rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note = "Uniform Energy Factor is required but not provided"` + - otherwise, set rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note = "Gas storage water heaters in this size range are regulated based on ASHRAE 90.1 Appendix F Table F-2. The efficiency metric given in Table F-2 is Uniform Energy Factor. Uniform Energy Factor was not provided for this water heater."` - otherwise, if the storage volume is less than 20 gallons, we will not be able to evaluate the rule logic, Provide a note and continue to rule evaluation: `elif storage_volume < 20: rule_note = "The storage tank volume is less than 20 gallons and the input capacity is <= 75,000 Btuh and based on the size categories in ASHRAE 90.1 Table 7.8 and Appendix F it would not be classified as a gas storage water heater. Consequently, this rule was not able to be assessed for this service water heater. "; GO TO RULE ASSERTION` - otherwise, if the storage volume is between 55 and 100 gallons: `elif storage_volume <= 100:` - determine the UEF based on the draw pattern for VERY_SMALL: `if draw_pattern == "VERY_SMALL": expected_uef = 0.6470 – (0.0006 × storage_volume)` From 4cedca4b84932656239b140b097bee8b2569a30c Mon Sep 17 00:00:00 2001 From: KarenWGard <114143532+KarenWGard@users.noreply.github.com> Date: Wed, 11 Dec 2024 08:36:39 -0500 Subject: [PATCH 21/25] Update Rule_11-10.md --- docs/section11/Rule_11-10.md | 12 +++++------- 1 file changed, 5 insertions(+), 7 deletions(-) diff --git a/docs/section11/Rule_11-10.md b/docs/section11/Rule_11-10.md index 7d1896a600..a070905423 100644 --- a/docs/section11/Rule_11-10.md +++ b/docs/section11/Rule_11-10.md @@ -115,7 +115,7 @@ - check if the actual uniform_energy_factor is >= to the expected: `if uniform_energy_factor == expected_UEF:` - set rule_status to "PASS": `rule_status = "PASS"` - otherwise, set rule status to FAIL and provide the note that the expected UEF is does not equal the required UEF: `else: rule_status = "FAIL"; rule_note = "The modeled Uniform energy Factor (UEF - " + uniform_energy_factor + ") does not equal the required (" + expected_UEF + ")"` - - otherwise, set rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note = "Uniform Energy Factor is required but not provided"` + - otherwise, set rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note = "Gas storage water heaters in this size range are regulated based on ASHRAE 90.1 Appendix F Table F-2. The efficiency metric given in Table F-2 is Uniform Energy Factor. Uniform Energy Factor was not provided for this water heater."` - otherwise, the storage volume is greater than 100 gallons, which is not covered by Appendix F: `else:` - create a note indicating that gas water heaters greater with input capacity < 75,000 btu/hr and the given storage volume are not covered under Appendix F: `rule_note: "The storage tank volume is greater than 100 gallons and the input capacity is <= 75,000 Btuh and based on the size categories in ASHRAE 90.1 Table 7.8 and Appendix F it would not be classified as a gas storage water heater. Consequently, this rule was not able to be assessed for this service water heater."` @@ -145,15 +145,13 @@ - calculate the expected_thermal_efficiency : `expected_thermal_efficiency = 0.8` - calculate max_standby_loss (btu/hr): `max_standby_loss = (input_capacity/800 + 110 * sqrt(volume))` - make sure that the thermal efficiency is not NULL: `if thermal_efficiency != NULL:` - - check whether the uniform_energy_factor is valid: `if uniform_energy_factor != NULL` - - get the standby loss (see note 1 for calculation source): `standby_loss = swh_eq.standby_loss_fraction * 8.25 * volume * 70` - - check if the actual uniform_energy_factor is == to the expected: `if shw_eq.thermal_efficiency == expected_thermal_efficiency and standby_loss <= max_standby_loss and !has_faults:` - - set rule_status to "PASS": `rule_status = "PASS"` - - otherwise, set rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note = "Uniform Energy Factor is required but not provided"` + - get the standby loss (see note 1 for calculation source): `standby_loss = swh_eq.standby_loss_fraction * 8.25 * volume * 70` + - check if the actual thermal efficiency is == to the expected: `if shw_eq.thermal_efficiency == expected_thermal_efficiency and standby_loss <= max_standby_loss and !has_faults:` + - set rule_status to "PASS": `rule_status = "PASS"` - otherwise set the rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note = "No thermal efficiency provided. Expected thermal efficiency is: " + expected_thermal_efficiency` **Rule Assertion - ServiceWaterHeatingEquipment:** - - Case1: swh_type is INSTANTANEOUS - there is no baseline instantaneous water heater types: `if swh_type == "INSTANTANEOUS": UNDETERMINED; rule_note = "There baseline water heater is of an Instantaneous type. There are no acceptable instantaneous baseline water heaters in Table G3.1.1-2."` + - Case1: swh_type is INSTANTANEOUS - there is no baseline instantaneous water heater types: `if swh_type == "INSTANTANEOUS": UNDETERMINED; rule_note = "There baseline water heater is of an Instantaneous type. Only electric resistance and gas storage water heaters are applicable to the Appendix G baseline acccording to Table G3.1 #11 Baseline Building Performance column and Table G3.1.1-2. Consequently, the efficiency of the modeled water heater was not assessed."` - Case2: rule_status is PASS: `if rule_status == "PASS": PASS`. - Case3: rule_status is UNDETERMINED, UNDETERMINED & return rule_note: `elif rule_status == "UNDETERMINED": UNDETERMINED; rule_note` - Case4: rule_status is FAIL, FAIL & return rule_note: `elif rule_status == "FAIL": FAIL; rule_note` From cb1999b324a2d494d613d09fcb33356cec63129b Mon Sep 17 00:00:00 2001 From: KarenWGard <114143532+KarenWGard@users.noreply.github.com> Date: Wed, 11 Dec 2024 09:01:45 -0500 Subject: [PATCH 22/25] Update Rule_11-10.md --- docs/section11/Rule_11-10.md | 89 +++++++++++++++++++++--------------- 1 file changed, 51 insertions(+), 38 deletions(-) diff --git a/docs/section11/Rule_11-10.md b/docs/section11/Rule_11-10.md index a070905423..01f61bc7f3 100644 --- a/docs/section11/Rule_11-10.md +++ b/docs/section11/Rule_11-10.md @@ -26,7 +26,7 @@ ## Rule Logic: - create a value to track the rule status: `rule_status = "FAIL"` - - create a variable to track any notes: `rule_note = """` + - create a variable to track any notes: `rule_note = ""` - we need to find the following information about the SWH: - swh_type - one of the ServiceWaterHeaterTankOptions - input_capacity (btu/hr) @@ -63,36 +63,47 @@ - what follows is logic that implements Table 7.8 - this table has multiple criteria, so I think it's simpler to implement with if / else logic than a table lookup - if the swh_type is OTHER, set rule_note to "Water heater type is not a recognized type", and continue to rule assertion: `if swh_type == "OTHER": rule_note = "Water heater type is not a recognized type"; GO TO RULE ASSERTION` - create a boolean has_fault and set it to false: `has_fault = false` + + - if the water heater is electric resistance storage and the capacity is <= 12kW (40945 btu/hr), look at Appendix F: `if swh_type in ["ELECTRIC_RESISTANCE_STORAGE"] and input_capacity <= 40945.7:` - - check the size of the storage tank. If it's less than 2 gallons, provide a note, and continue to rule assertion: `if storage_volume < 2: rule_note = "The storage tank volume is less than 2 gallons and based on the size categories in ASHRAE 90.1 Table 7.8 and Appendix F it would not be classified as an electric storage water heater. Consequently, this rule was not assessed for this service water heater."; GO TO RULE ASSERTION` - - else, if the storage tank is is between 20 and 55 gallons, this is considered an electric storage water heater in Appendix F: `elif storage_volume >= 20 and storage_volume <= 55:` - - determine the UEF based on the draw pattern for VERY_SMALL: `if draw_pattern == "VERY_SMALL": expected_uef = 0.8808 – (0.0008 × storage_volume)` - - determine the UEF based on the draw pattern for LOW: `if draw_pattern == "LOW": expected_uef = 0.9254 – (0.0003 × storage_volume)` - - determine the UEF based on the draw pattern for MEDIUM: `if draw_pattern == "MEDIUM": expected_uef = 0.9307 – (0.0002 × storage_volume)` - - determine the UEF based on the draw pattern for HIGH: `if draw_pattern == "HIGH": expected_uef = 0.9349 – (0.0001 × storage_volume)` - - check whether the uniform_energy_factor is valid: `if uniform_energy_factor != NULL - - check if the actual uniform_energy_factor equals the expected: `if uniform_energy_factor == expected_UEF:` - - set rule_status to "PASS": `rule_status = "PASS"` - - otherwise, set rule status to FAIL and provide the note that the expected UEF is less than the required UEF: `else: rule_status = "FAIL"; rule_note = "The modeled Uniform energy Factor (UEF - " + uniform_energy_factor + ") does not equal required (" + expected_UEF + ")"` - - otherwise, set rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note = "Uniform Energy Factor is required to evaluate water heaters in ASHRAE 90.1 Table 7.8. Uniform Energy Factor is not provided for this waterheater."` - - else, if the storage tank is greater than 55 and less than 100 gallons, Appendix F provides a heat pump efficiency, which may be an error. return UNDETERMINED: `elif storage_volume <=100 and storage_volume > 55:` - - set rule_status to UNDETERMINED: `rule_status = "UNDETERMINED"` - - include a note: `rule_note = "The storage tank is between 2 and 20 gallons and based on the size categories in ASHRAE 90.1 Table 7.8 and Appendix F it would not be classified as an electric storage water heater. Consequently, this rule was not able to be assessed for this service water heater."` - - go to rule assertion: `GO TO RULE ASSERTION` + - check that the capacity_per_volume is < 4000 btu/hr/gallon: `if capacity_per_volume < 4000:` + - check the size of the storage tank. If it's less than 2 gallons, provide a note, and continue to rule assertion: `if storage_volume < 2: rule_note += " The storage tank volume is less than 2 gallons and based on the size categories in ASHRAE 90.1 Table 7.8 and Appendix F it would not be classified as an electric storage water heater. Consequently, this rule was not assessed for this service water heater."; GO TO RULE ASSERTION` + - else, if the storage tank is is between 20 and 55 gallons, this is considered an electric storage water heater in Appendix F: `elif storage_volume >= 20 and storage_volume <= 55:` + - determine the UEF based on the draw pattern for VERY_SMALL: `if draw_pattern == "VERY_SMALL": expected_uef = 0.8808 – (0.0008 × storage_volume)` + - determine the UEF based on the draw pattern for LOW: `if draw_pattern == "LOW": expected_uef = 0.9254 – (0.0003 × storage_volume)` + - determine the UEF based on the draw pattern for MEDIUM: `if draw_pattern == "MEDIUM": expected_uef = 0.9307 – (0.0002 × storage_volume)` + - determine the UEF based on the draw pattern for HIGH: `if draw_pattern == "HIGH": expected_uef = 0.9349 – (0.0001 × storage_volume)` + - check whether the uniform_energy_factor is valid: `if uniform_energy_factor != NULL + - check if the actual uniform_energy_factor equals the expected: `if uniform_energy_factor == expected_UEF:` + - set rule_status to "PASS": `rule_status = "PASS"; CONTINUE TO RULE ASSERTION` + - otherwise, set rule status to FAIL and provide the note that the expected UEF is less than the required UEF: `else: rule_status = "FAIL"; rule_note += " The modeled Uniform energy Factor (UEF - " + uniform_energy_factor + ") does not equal required (" + expected_UEF + ")"; CONTINUE TO RULE ASSERTION` + - otherwise, set rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note += " Uniform Energy Factor is required to evaluate water heaters in ASHRAE 90.1 Table 7.8 / Appendix F Table F-2. Uniform Energy Factor is not provided for this waterheater."; CONTINUE TO RULE ASSERTION` + + - else, if the storage tank is greater than 55 and less than 100 gallons, Appendix F provides a heat pump efficiency, which may be an error. return UNDETERMINED: `elif storage_volume <=100 and storage_volume > 55:` + - set rule_status to UNDETERMINED: `rule_status = "UNDETERMINED"; CONTINUE TO RULE ASSERTION` + - include a note: `rule_note += " The storage tank is between 55 and 100 gallons with a capacity <= 12kW (40945 btu/hr). The minimum efficiency requirements in 90.1 Section 7.4.2 point to ASHRAE 90.1 Appendix F which provides a heat pump efficiency for water heaters in this capacity range which is not consistent with the efficiency of an electric resistance storage water heater which is the only electric SWH system type associated with the baseline for ASHRAE 90.1 Appendix G. Consequently, this rule was not able to be assessed for this service water heater. "` + - go to rule assertion: `GO TO RULE ASSERTION` + + - otherwise, the capacity per volume is not < 4000 btu/ gallon: `else:` + - indicate with the note that the capacity per volume exceeds the limit: `rule_note += " Capacity per volume exceeds the limit of 4000 btu/hr/gallon given for Electric Storage Water Heaters in ASHRAE 90.1 Table 7.8."` + - set the rule status to FAIL and continue to rule assertion: `rule_status = "FAIL"; CONTINUE TO RULE ASSERTION` + - else if the storage volume is between 2 and 20 gallons, in which case there is no rating in APPENDIX F. set rule status to UNDETERMINED: `elif storage_volume < 20:` - set the rule status to UNDETERMINED: `rule_status = "UNDETERMINED"` - - add a note: `rule_note = "The storage tank volume is between 2 and 20 gallons and based on the size categories in ASHRAE 90.1 Table 7.8 and Appendix F it would not be classified as an electric storage water heater. Consequently, this rule was not assessed for this service water heater."` - - go to rule assertion: `GO TO RULE ASSERTION` - - otherwise, continue with rule logic: `else:` + - add a note: `rule_note += " The storage tank volume is between 2 and 20 gallons and based on the size categories in ASHRAE 90.1 Table 7.8 and Appendix F it would not be classified as an electric storage water heater. Consequently, this rule was not assessed for this service water heater."` + - go to rule assertion: `CONTINUE TO RULE ASSERTION` + + + - otherwise, this is an electric resistance water heater with input > 12 kW, continue with logic per Table 7.8: `else:` - check electric storage water heaters with capacity greater than 12 kW: `if swh_type == "ELECTRIC_RESISTANCE_STORAGE" and input_capacity > 40945.7 (btu/hr):` - - check that the capacity_per_volume < 4000 btu/hr/gallon: `if capacity_per_volume < 4000:` + - check that the capacity_per_volume is < 4000 btu/hr/gallon: `if capacity_per_volume < 4000:` - calculate the standby loss target: `standby_loss_target = 0.3 + (27/swh_eq.distribution_system.tank.storage_volume)` - - + - check whether the standby loss fraction is given, if it's not given, provide a note, and a rule result of UNDETERMINED: `if swh_eq.standby_loss_fraction == NULL: rule_note += " Electric resistance water heaters with input capacity > 12kW have a required standby loss given by ASHRAE 90.1 Table 7.8. No standby loss was given for this water heater, thus the rule was not able to be evaluated."` - if the standby_loss is equal to the target, set the rule_status to PASS: `if swh_eq.standby_loss_fraction <= standby_loss_target: rule_status: "PASS"` - otherwise: `else:` - - set the note to indicate that the standby_loss is higher than the maximum allowed: `rule_note = "Standby Loss is higher than required by Table 7.8"` + - set the note to indicate that the standby_loss is higher than the maximum allowed: `rule_note += " Standby Loss is higher than required by Table 7.8"` - otherwise: `else:` - - set the note to indicate that the capacity per volume exceeds the limit: `rule_note = "Capacity per volume exceeds the limit of 4000 btu/hr/gallon given for Electric Storage Water Heaters in ASHRAE 90.1 Table 7.8."` + - set the note to indicate that the capacity per volume exceeds the limit: `rule_note += " Capacity per volume exceeds the limit of 4000 btu/hr/gallon given for Electric Storage Water Heaters in ASHRAE 90.1 Table 7.8."` - check if the water heater is gas storage: `if swh_type == "GAS_STORAGE":` - check if the capacity is <= 75,000 btu/hr: `if input_capacity <= 75000:` - if the storage volume is between 20 and 55 gallons: `if storage_volume >= 20 and storage_volume <= 55:` @@ -102,10 +113,10 @@ - determine the UEF based on the draw pattern for HIGH: `if draw_pattern == "HIGH": expected_uef = 0.6920 – (0.0013 × storage_volume)` - check whether the uniform_energy_factor is valid: `if uniform_energy_factor != NULL - check if the actual uniform_energy_factor is equals the expected: `if uniform_energy_factor == expected_UEF:` - - set rule_status to "PASS": `rule_status = "PASS"` - - otherwise, set rule status to FAIL and provide the note that the expected UEF is less than the required UEF: `else: rule_status = "FAIL"; rule_note = "The modeled Uniform energy Factor (UEF - " + uniform_energy_factor + ") does not equal the required (" + expected_UEF + ")"` - - otherwise, set rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note = "Gas storage water heaters in this size range are regulated based on ASHRAE 90.1 Appendix F Table F-2. The efficiency metric given in Table F-2 is Uniform Energy Factor. Uniform Energy Factor was not provided for this water heater."` - - otherwise, if the storage volume is less than 20 gallons, we will not be able to evaluate the rule logic, Provide a note and continue to rule evaluation: `elif storage_volume < 20: rule_note = "The storage tank volume is less than 20 gallons and the input capacity is <= 75,000 Btuh and based on the size categories in ASHRAE 90.1 Table 7.8 and Appendix F it would not be classified as a gas storage water heater. Consequently, this rule was not able to be assessed for this service water heater. "; GO TO RULE ASSERTION` + - set rule_status to "PASS": `rule_status = "PASS"; CONTINUE TO RULE ASSERTION` + - otherwise, set rule status to FAIL and provide the note that the expected UEF is less than the required UEF: `else: rule_status = "FAIL"; rule_note += " The modeled Uniform energy Factor (UEF - " + uniform_energy_factor + ") does not equal the required (" + expected_UEF + ")"; CONTINUE TO RULE ASSERTION` + - otherwise, set rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note += " Gas storage water heaters in this size range are regulated based on ASHRAE 90.1 Appendix F Table F-2. The efficiency metric given in Table F-2 is Uniform Energy Factor. Uniform Energy Factor was not provided for this water heater."; CONTINUE TO RULE ASSERTION` + - otherwise, if the storage volume is less than 20 gallons, we will not be able to evaluate the rule logic, Provide a note and continue to rule evaluation: `elif storage_volume < 20: rule_note += " The storage tank volume is less than 20 gallons and the input capacity is <= 75,000 Btuh and based on the size categories in ASHRAE 90.1 Table 7.8 and Appendix F it would not be classified as a gas storage water heater. Consequently, this rule was not able to be assessed for this service water heater. "; GO TO RULE ASSERTION` - otherwise, if the storage volume is between 55 and 100 gallons: `elif storage_volume <= 100:` - determine the UEF based on the draw pattern for VERY_SMALL: `if draw_pattern == "VERY_SMALL": expected_uef = 0.6470 – (0.0006 × storage_volume)` - determine the UEF based on the draw pattern for LOW: `if draw_pattern == "LOW": expected_uef = 0.7689 – (0.0005 × storage_volume)` @@ -113,13 +124,13 @@ - determine the UEF based on the draw pattern for HIGH: `if draw_pattern == "HIGH": expected_uef = 0.8072 – (0.0003 × storage_volume)` - check whether the uniform_energy_factor is valid: `if uniform_energy_factor != NULL - check if the actual uniform_energy_factor is >= to the expected: `if uniform_energy_factor == expected_UEF:` - - set rule_status to "PASS": `rule_status = "PASS"` - - otherwise, set rule status to FAIL and provide the note that the expected UEF is does not equal the required UEF: `else: rule_status = "FAIL"; rule_note = "The modeled Uniform energy Factor (UEF - " + uniform_energy_factor + ") does not equal the required (" + expected_UEF + ")"` - - otherwise, set rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note = "Gas storage water heaters in this size range are regulated based on ASHRAE 90.1 Appendix F Table F-2. The efficiency metric given in Table F-2 is Uniform Energy Factor. Uniform Energy Factor was not provided for this water heater."` + - set rule_status to "PASS": `rule_status = "PASS"; CONTINUE TO RULE ASSERTION` + - otherwise, set rule status to FAIL and provide the note that the expected UEF is does not equal the required UEF: `else: rule_status = "FAIL"; rule_note += " The modeled Uniform energy Factor (UEF - " + uniform_energy_factor + ") does not equal the required (" + expected_UEF + ")"; CONTINUE TO RULE ASSERTION` + - otherwise, set rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note = "Gas storage water heaters in this size range are regulated based on ASHRAE 90.1 Appendix F Table F-2. The efficiency metric given in Table F-2 is Uniform Energy Factor. Uniform Energy Factor was not provided for this water heater."; CONTINUE TO RULE ASSERTION` - otherwise, the storage volume is greater than 100 gallons, which is not covered by Appendix F: `else:` - create a note indicating that gas water heaters greater with input capacity < 75,000 btu/hr and the given storage volume are not covered under Appendix F: `rule_note: "The storage tank volume is greater than 100 gallons and the input capacity is <= 75,000 Btuh and based on the size categories in ASHRAE 90.1 Table 7.8 and Appendix F it would not be classified as a gas storage water heater. Consequently, this rule was not able to be assessed for this service water heater."` - - change rule_status to UNDETERMINED: `rule_status = "UNDETERMINED"` + - change rule_status to UNDETERMINED: `rule_status = "UNDETERMINED"; CONTINUE TO RULE ASSERTION` - check if the capacity <= 105,000 btu/hr: `elif input_capacity <= 105000:` - the capacity per volume should be < 4000 btu/hr/gallon: `if capacity_per_volume >= 4000:` - add the to the rule note: `rule_note += "Based on the size categories for gas storage water heaters in ASHRAE 90.1 Table 7.8, gas storage water heaters with an input capacity between 75,000 and 105,000 btu/hr shall have a capacity per volume of 4,000 btu/hr/gallon. This water heater has a capacity per gallon of " + capacity_per_volume + " btu/hr/gallon. Consequently, this rule was not able to be assesed for this service water heater. "` @@ -136,8 +147,8 @@ - calculate the expected efficiency for HIGH draw pattern: `if draw_pattern == "HIGH": expected_UEF = 0.6597 – (0.0009 * volume)` - check whether the uniform_energy_factor is valid: `if uniform_energy_factor != NULL - check if the actual uniform_energy_factor equal to the expected: `if uniform_energy_factor == expected_UEF and !has_faults:` - - set rule_status to "PASS": `rule_status = "PASS"` - - otherwise, set rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note = "Uniform Energy Factor is required but not provided"` + - set rule_status to "PASS": `rule_status = "PASS"; CONTINUE TO RULE ASSERTION` + - otherwise, set rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note += " Uniform Energy Factor is required but not provided"; CONTINUE TO RULE ASSERTION` - otherwise the capacity is > 105,000 btu/hr: `else:` - the capacity per volume should be < 4000 btu/hr/gallon: `if capacity_per_volume >= 4000:` - add to the rule note: `rule_note += "Based on the size categories for gas storage water heaters in ASHRAE 90.1 Table 7.8, gas storage water heaters with an input capacity greater than 105,000 btu/hr shall have a capacity per volume of 4,000 btu/hr/gallon. This water heater has a capacity per gallon of " + capacity_per_volume + " btu/hr/gallon. Consequently, this rule was not able to be assesed for this service water heater. "` @@ -145,13 +156,15 @@ - calculate the expected_thermal_efficiency : `expected_thermal_efficiency = 0.8` - calculate max_standby_loss (btu/hr): `max_standby_loss = (input_capacity/800 + 110 * sqrt(volume))` - make sure that the thermal efficiency is not NULL: `if thermal_efficiency != NULL:` - - get the standby loss (see note 1 for calculation source): `standby_loss = swh_eq.standby_loss_fraction * 8.25 * volume * 70` - - check if the actual thermal efficiency is == to the expected: `if shw_eq.thermal_efficiency == expected_thermal_efficiency and standby_loss <= max_standby_loss and !has_faults:` - - set rule_status to "PASS": `rule_status = "PASS"` - - otherwise set the rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note = "No thermal efficiency provided. Expected thermal efficiency is: " + expected_thermal_efficiency` + - make sure that the standy loss is not NULL: `if swh_eq.standby_loss_fraction != NULL:` + - get the standby loss (see note 1 for calculation source): `standby_loss = swh_eq.standby_loss_fraction * 8.25 * volume * 70` + - check if the actual thermal efficiency is == to the expected: `if shw_eq.thermal_efficiency == expected_thermal_efficiency and standby_loss <= max_standby_loss and !has_faults:` + - set rule_status to "PASS": `rule_status = "PASS"; CONTINUE TO RULE ASSERTION` + - otherwise set the rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note += " For gas storage water heaters with capacity > 105,000 btu/hr, ASHRAE 90.1 Table 7.8 gives an expected standby loss. We calculate this standby loss based on the Standby Loss Fraction. No Standby Loss Fraction was given, so this rule could not be evaluated." + expected_thermal_efficiency; CONTINUE TO RULE ASSERTION` + - otherwise set the rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note += " For gas storage water heaters with capacity > 105,000 btu/hr, ASHRAE 90.1 Table 7.8 gives an expected thermal efficiency of : " + expected_thermal_efficiency + ". No thermal efficiency was given for this water heater, so the rule could not be evaluated."; CONTINUE TO RULE ASSERTION` **Rule Assertion - ServiceWaterHeatingEquipment:** - - Case1: swh_type is INSTANTANEOUS - there is no baseline instantaneous water heater types: `if swh_type == "INSTANTANEOUS": UNDETERMINED; rule_note = "There baseline water heater is of an Instantaneous type. Only electric resistance and gas storage water heaters are applicable to the Appendix G baseline acccording to Table G3.1 #11 Baseline Building Performance column and Table G3.1.1-2. Consequently, the efficiency of the modeled water heater was not assessed."` + - Case1: swh_type is INSTANTANEOUS - there is no baseline instantaneous water heater types: `if swh_type == "INSTANTANEOUS": UNDETERMINED; rule_note += " There baseline water heater is of an Instantaneous type. Only electric resistance and gas storage water heaters are applicable to the Appendix G baseline acccording to Table G3.1 #11 Baseline Building Performance column and Table G3.1.1-2. Consequently, the efficiency of the modeled water heater was not assessed."` - Case2: rule_status is PASS: `if rule_status == "PASS": PASS`. - Case3: rule_status is UNDETERMINED, UNDETERMINED & return rule_note: `elif rule_status == "UNDETERMINED": UNDETERMINED; rule_note` - Case4: rule_status is FAIL, FAIL & return rule_note: `elif rule_status == "FAIL": FAIL; rule_note` From d375e51cf0c6862f6a1c2601e26eeb4981a7b0b2 Mon Sep 17 00:00:00 2001 From: KarenWGard <114143532+KarenWGard@users.noreply.github.com> Date: Wed, 11 Dec 2024 11:03:17 -0500 Subject: [PATCH 23/25] Update Rule_11-10.md --- docs/section11/Rule_11-10.md | 23 ++++++++++++----------- 1 file changed, 12 insertions(+), 11 deletions(-) diff --git a/docs/section11/Rule_11-10.md b/docs/section11/Rule_11-10.md index 01f61bc7f3..4bfee6a84c 100644 --- a/docs/section11/Rule_11-10.md +++ b/docs/section11/Rule_11-10.md @@ -44,7 +44,7 @@ - set the swh_type based on tank_type and fuel type: `if fuel_type == "ELECTRICITY": swh_type = "ELECTRIC_RESISTANCE_STORAGE` - `elif fuel_type == "NATURAL_GAS": swh_type = "GAS_STORAGE` - if the fuel type is propane, this is treated as natural gas in Table 7.8: `elif fuel_type == "PROPANE": swh_type = "GAS_STORAGE"` - - if the fuel type is not Electricity, Natural Gas, or Propane, this is not a valid baseline SWH system. Create a rule note and go directly to the rule assertion: `else: rule_note += "Fuel type: " + fuel_type + " is not a valid fuel type for a service water heating baseline system. According to ASHRAE 90.1 Table G3.1.1-2 service water heating equipment shall be either electric resistance or natural gas. According to ASHRAE 90.1 Table G3.1 #11 h, in cases where natural gas is specified as the baseline system, but there is no natural gas available on site, a propane system may be modeled. " ` + - if the fuel type is not Electricity, Natural Gas, or Propane, this is not a valid baseline SWH system. Create a rule note and go directly to the rule assertion: `else: rule_note += "Fuel type: " + fuel_type + " is not a valid fuel type for a service water heating baseline system. According to ASHRAE 90.1 Table G3.1.1-2 service water heating equipment shall be either electric resistance or natural gas. According to ASHRAE 90.1 Table G3.1 #11 h, in cases where natural gas is specified as the baseline system, but there is no natural gas available on site, a propane system may be modeled. "; rule_status = FAIL; GO TO RULE ASSERTION ` - if the draw_pattern is given, get the draw pattern: `if shw_eq.draw_pattern != null: draw_pattern = shw_eq.draw_pattern` - otherwise, determine the draw pattern based off the first_hour_rating of the shw_eq: `else:` - First get the first hour rating (gallons): `first_hour_rating = shw_eq.first_hour_rating` @@ -61,13 +61,13 @@ - get the thermal efficiency: `thermal_efficiency = efficiency_metric_dict["THERMAL_EFFICIENCY"]` - get the uniform energy factor: `uniform_energy_factor = efficiency_metric_dict["UNIFORM_ENERGY_FACTOR"]` - what follows is logic that implements Table 7.8 - this table has multiple criteria, so I think it's simpler to implement with if / else logic than a table lookup - - if the swh_type is OTHER, set rule_note to "Water heater type is not a recognized type", and continue to rule assertion: `if swh_type == "OTHER": rule_note = "Water heater type is not a recognized type"; GO TO RULE ASSERTION` + - if the swh_type is OTHER, set rule_note to "Water heater type is not a recognized type", and continue to rule assertion: `if swh_type == "OTHER": rule_note = "Water heater type is not a recognized type"; rule_status = FAIL; GO TO RULE ASSERTION` - create a boolean has_fault and set it to false: `has_fault = false` - if the water heater is electric resistance storage and the capacity is <= 12kW (40945 btu/hr), look at Appendix F: `if swh_type in ["ELECTRIC_RESISTANCE_STORAGE"] and input_capacity <= 40945.7:` - check that the capacity_per_volume is < 4000 btu/hr/gallon: `if capacity_per_volume < 4000:` - - check the size of the storage tank. If it's less than 2 gallons, provide a note, and continue to rule assertion: `if storage_volume < 2: rule_note += " The storage tank volume is less than 2 gallons and based on the size categories in ASHRAE 90.1 Table 7.8 and Appendix F it would not be classified as an electric storage water heater. Consequently, this rule was not assessed for this service water heater."; GO TO RULE ASSERTION` + - check the size of the storage tank. If it's less than 2 gallons, provide a note, and continue to rule assertion: `if storage_volume < 2: rule_note += " The storage tank volume is less than 2 gallons and based on the size categories in ASHRAE 90.1 Table 7.8 and Appendix F it would not be classified as an electric storage water heater. Consequently, this rule was not assessed for this service water heater."; rule_status = FAIL; GO TO RULE ASSERTION` - else, if the storage tank is is between 20 and 55 gallons, this is considered an electric storage water heater in Appendix F: `elif storage_volume >= 20 and storage_volume <= 55:` - determine the UEF based on the draw pattern for VERY_SMALL: `if draw_pattern == "VERY_SMALL": expected_uef = 0.8808 – (0.0008 × storage_volume)` - determine the UEF based on the draw pattern for LOW: `if draw_pattern == "LOW": expected_uef = 0.9254 – (0.0003 × storage_volume)` @@ -99,11 +99,11 @@ - check that the capacity_per_volume is < 4000 btu/hr/gallon: `if capacity_per_volume < 4000:` - calculate the standby loss target: `standby_loss_target = 0.3 + (27/swh_eq.distribution_system.tank.storage_volume)` - check whether the standby loss fraction is given, if it's not given, provide a note, and a rule result of UNDETERMINED: `if swh_eq.standby_loss_fraction == NULL: rule_note += " Electric resistance water heaters with input capacity > 12kW have a required standby loss given by ASHRAE 90.1 Table 7.8. No standby loss was given for this water heater, thus the rule was not able to be evaluated."` - - if the standby_loss is equal to the target, set the rule_status to PASS: `if swh_eq.standby_loss_fraction <= standby_loss_target: rule_status: "PASS"` + - if the standby_loss is equal to the target, set the rule_status to PASS: `if swh_eq.standby_loss_fraction <= standby_loss_target: rule_status = "PASS"` - otherwise: `else:` - - set the note to indicate that the standby_loss is higher than the maximum allowed: `rule_note += " Standby Loss is higher than required by Table 7.8"` + - set the note to indicate that the standby_loss is higher than the maximum allowed: `rule_note += " Standby Loss is higher than required by Table 7.8"; rule_status = FAIL; GO TO RULE ASSERTION` - otherwise: `else:` - - set the note to indicate that the capacity per volume exceeds the limit: `rule_note += " Capacity per volume exceeds the limit of 4000 btu/hr/gallon given for Electric Storage Water Heaters in ASHRAE 90.1 Table 7.8."` + - set the note to indicate that the capacity per volume exceeds the limit: `rule_note += " Capacity per volume exceeds the limit of 4000 btu/hr/gallon given for Electric Storage Water Heaters in ASHRAE 90.1 Table 7.8."; rule_status = FAIL; GO TO RULE ASSERTION` - check if the water heater is gas storage: `if swh_type == "GAS_STORAGE":` - check if the capacity is <= 75,000 btu/hr: `if input_capacity <= 75000:` - if the storage volume is between 20 and 55 gallons: `if storage_volume >= 20 and storage_volume <= 55:` @@ -116,7 +116,7 @@ - set rule_status to "PASS": `rule_status = "PASS"; CONTINUE TO RULE ASSERTION` - otherwise, set rule status to FAIL and provide the note that the expected UEF is less than the required UEF: `else: rule_status = "FAIL"; rule_note += " The modeled Uniform energy Factor (UEF - " + uniform_energy_factor + ") does not equal the required (" + expected_UEF + ")"; CONTINUE TO RULE ASSERTION` - otherwise, set rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note += " Gas storage water heaters in this size range are regulated based on ASHRAE 90.1 Appendix F Table F-2. The efficiency metric given in Table F-2 is Uniform Energy Factor. Uniform Energy Factor was not provided for this water heater."; CONTINUE TO RULE ASSERTION` - - otherwise, if the storage volume is less than 20 gallons, we will not be able to evaluate the rule logic, Provide a note and continue to rule evaluation: `elif storage_volume < 20: rule_note += " The storage tank volume is less than 20 gallons and the input capacity is <= 75,000 Btuh and based on the size categories in ASHRAE 90.1 Table 7.8 and Appendix F it would not be classified as a gas storage water heater. Consequently, this rule was not able to be assessed for this service water heater. "; GO TO RULE ASSERTION` + - otherwise, if the storage volume is less than 20 gallons, we will not be able to evaluate the rule logic, Provide a note and continue to rule evaluation: `elif storage_volume < 20: rule_note += " The storage tank volume is less than 20 gallons and the input capacity is <= 75,000 Btuh and based on the size categories in ASHRAE 90.1 Table 7.8 and Appendix F it would not be classified as a gas storage water heater. Consequently, this rule was not able to be assessed for this service water heater. "; rule_status = UNDETERMINED; GO TO RULE ASSERTION` - otherwise, if the storage volume is between 55 and 100 gallons: `elif storage_volume <= 100:` - determine the UEF based on the draw pattern for VERY_SMALL: `if draw_pattern == "VERY_SMALL": expected_uef = 0.6470 – (0.0006 × storage_volume)` - determine the UEF based on the draw pattern for LOW: `if draw_pattern == "LOW": expected_uef = 0.7689 – (0.0005 × storage_volume)` @@ -133,13 +133,13 @@ - change rule_status to UNDETERMINED: `rule_status = "UNDETERMINED"; CONTINUE TO RULE ASSERTION` - check if the capacity <= 105,000 btu/hr: `elif input_capacity <= 105000:` - the capacity per volume should be < 4000 btu/hr/gallon: `if capacity_per_volume >= 4000:` - - add the to the rule note: `rule_note += "Based on the size categories for gas storage water heaters in ASHRAE 90.1 Table 7.8, gas storage water heaters with an input capacity between 75,000 and 105,000 btu/hr shall have a capacity per volume of 4,000 btu/hr/gallon. This water heater has a capacity per gallon of " + capacity_per_volume + " btu/hr/gallon. Consequently, this rule was not able to be assesed for this service water heater. "` + - add the to the rule note: `rule_note += "Based on the size categories for gas storage water heaters in ASHRAE 90.1 Table 7.8, gas storage water heaters with an input capacity between 75,000 and 105,000 btu/hr shall have a capacity per volume of 4,000 btu/hr/gallon. This water heater has a capacity per gallon of " + capacity_per_volume + " btu/hr/gallon. Consequently, this rule was not able to be assesed for this service water heater. "; rule_status = "UNDETERMINED"; CONTINUE TO RULE ASSERTION` - set has_fault to true: `has_fault = true` - the volume should be <= 120 gallons: `if storage_volume > 120:` - - add to the rule note: `rule_note += "Based on the size categories for gas storage water heaters in ASHRAE 90.1 Table 7.8, gas storage water heaters with an input capacity between 75,000 and 105,000 btu/hr shall have a storage capacity of <= 120 gallons. The storage capacity of this water heater is " + storage_volume + " gallons. "` + - add to the rule note: `rule_note += "Based on the size categories for gas storage water heaters in ASHRAE 90.1 Table 7.8, gas storage water heaters with an input capacity between 75,000 and 105,000 btu/hr shall have a storage capacity of <= 120 gallons. The storage capacity of this water heater is " + storage_volume + " gallons."; rule_status = FAIL` - set has_fault to true: `has_fault = true` - the supply water temperature should be <= 180F: `if shw_eq.setpoint_temperature > 180:` - - add to the rule note: `rule_note += "Based on the size categories for gas storage water heaters in ASHRAE 90.1 Table 7.8, gas storage water heaters with an input capacity between 75,000 and 105,000 btu/hr shall have a setpoint temperature of 180F. The setpoint temperature of this water heater is " + shw_eq.setpoint_temperature + "F. "` + - add to the rule note: `rule_note += "Based on the size categories for gas storage water heaters in ASHRAE 90.1 Table 7.8, gas storage water heaters with an input capacity between 75,000 and 105,000 btu/hr shall have a setpoint temperature of 180F. The setpoint temperature of this water heater is " + shw_eq.setpoint_temperature + "F. "; rule_status = FAIL` - set has_fault to true: `has_fault = true` - calculate the expected efficiency for VERY_SMALL draw pattern: `if draw_pattern == "VERY_SMALL": expected_UEF = 0.2674 – (0.0009 * volume)` - calculate the expected efficiency for LOW draw pattern: `if draw_pattern == "LOW": expected_UEF = 0.5362 – (0.0012 * volume)` @@ -151,7 +151,7 @@ - otherwise, set rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note += " Uniform Energy Factor is required but not provided"; CONTINUE TO RULE ASSERTION` - otherwise the capacity is > 105,000 btu/hr: `else:` - the capacity per volume should be < 4000 btu/hr/gallon: `if capacity_per_volume >= 4000:` - - add to the rule note: `rule_note += "Based on the size categories for gas storage water heaters in ASHRAE 90.1 Table 7.8, gas storage water heaters with an input capacity greater than 105,000 btu/hr shall have a capacity per volume of 4,000 btu/hr/gallon. This water heater has a capacity per gallon of " + capacity_per_volume + " btu/hr/gallon. Consequently, this rule was not able to be assesed for this service water heater. "` + - add to the rule note: `rule_note += "Based on the size categories for gas storage water heaters in ASHRAE 90.1 Table 7.8, gas storage water heaters with an input capacity greater than 105,000 btu/hr shall have a capacity per volume of 4,000 btu/hr/gallon. This water heater has a capacity per gallon of " + capacity_per_volume + " btu/hr/gallon. Consequently, this rule was not able to be assesed for this service water heater. "; rule_status = UNDETERMINED` - set has_fault to true: `has_fault = true` - calculate the expected_thermal_efficiency : `expected_thermal_efficiency = 0.8` - calculate max_standby_loss (btu/hr): `max_standby_loss = (input_capacity/800 + 110 * sqrt(volume))` @@ -162,6 +162,7 @@ - set rule_status to "PASS": `rule_status = "PASS"; CONTINUE TO RULE ASSERTION` - otherwise set the rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note += " For gas storage water heaters with capacity > 105,000 btu/hr, ASHRAE 90.1 Table 7.8 gives an expected standby loss. We calculate this standby loss based on the Standby Loss Fraction. No Standby Loss Fraction was given, so this rule could not be evaluated." + expected_thermal_efficiency; CONTINUE TO RULE ASSERTION` - otherwise set the rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note += " For gas storage water heaters with capacity > 105,000 btu/hr, ASHRAE 90.1 Table 7.8 gives an expected thermal efficiency of : " + expected_thermal_efficiency + ". No thermal efficiency was given for this water heater, so the rule could not be evaluated."; CONTINUE TO RULE ASSERTION` + - if we arrive here, we did not reach a PASS option, there are faults, go to rule assertion: `CONTINUE TO RULE ASSERTION` **Rule Assertion - ServiceWaterHeatingEquipment:** - Case1: swh_type is INSTANTANEOUS - there is no baseline instantaneous water heater types: `if swh_type == "INSTANTANEOUS": UNDETERMINED; rule_note += " There baseline water heater is of an Instantaneous type. Only electric resistance and gas storage water heaters are applicable to the Appendix G baseline acccording to Table G3.1 #11 Baseline Building Performance column and Table G3.1.1-2. Consequently, the efficiency of the modeled water heater was not assessed."` From 4161b3d39e1870b05d0a7a051fa23c6a169fa69d Mon Sep 17 00:00:00 2001 From: KarenWGard <114143532+KarenWGard@users.noreply.github.com> Date: Wed, 11 Dec 2024 15:46:30 -0500 Subject: [PATCH 24/25] Update Rule_11-10.md --- docs/section11/Rule_11-10.md | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/docs/section11/Rule_11-10.md b/docs/section11/Rule_11-10.md index 4bfee6a84c..6591a0ad0b 100644 --- a/docs/section11/Rule_11-10.md +++ b/docs/section11/Rule_11-10.md @@ -67,7 +67,7 @@ - if the water heater is electric resistance storage and the capacity is <= 12kW (40945 btu/hr), look at Appendix F: `if swh_type in ["ELECTRIC_RESISTANCE_STORAGE"] and input_capacity <= 40945.7:` - check that the capacity_per_volume is < 4000 btu/hr/gallon: `if capacity_per_volume < 4000:` - - check the size of the storage tank. If it's less than 2 gallons, provide a note, and continue to rule assertion: `if storage_volume < 2: rule_note += " The storage tank volume is less than 2 gallons and based on the size categories in ASHRAE 90.1 Table 7.8 and Appendix F it would not be classified as an electric storage water heater. Consequently, this rule was not assessed for this service water heater."; rule_status = FAIL; GO TO RULE ASSERTION` + - check the size of the storage tank. If it's less than 2 gallons, provide a note, and continue to rule assertion: `if storage_volume < 2: rule_note += " The storage tank volume is less than 2 gallons and based on the size categories in ASHRAE 90.1 Table 7.8 and in 10 CFR 430, it would not be classified as an electric storage water heater. Consequently, this rule was not assessed for this service water heater. Note that the specific requirements of 10 CFR 430 can be found in ASHRAE 90.1 Appendix F Table F-2."; rule_status = UNDETERMINED; GO TO RULE ASSERTION` - else, if the storage tank is is between 20 and 55 gallons, this is considered an electric storage water heater in Appendix F: `elif storage_volume >= 20 and storage_volume <= 55:` - determine the UEF based on the draw pattern for VERY_SMALL: `if draw_pattern == "VERY_SMALL": expected_uef = 0.8808 – (0.0008 × storage_volume)` - determine the UEF based on the draw pattern for LOW: `if draw_pattern == "LOW": expected_uef = 0.9254 – (0.0003 × storage_volume)` @@ -77,11 +77,11 @@ - check if the actual uniform_energy_factor equals the expected: `if uniform_energy_factor == expected_UEF:` - set rule_status to "PASS": `rule_status = "PASS"; CONTINUE TO RULE ASSERTION` - otherwise, set rule status to FAIL and provide the note that the expected UEF is less than the required UEF: `else: rule_status = "FAIL"; rule_note += " The modeled Uniform energy Factor (UEF - " + uniform_energy_factor + ") does not equal required (" + expected_UEF + ")"; CONTINUE TO RULE ASSERTION` - - otherwise, set rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note += " Uniform Energy Factor is required to evaluate water heaters in ASHRAE 90.1 Table 7.8 / Appendix F Table F-2. Uniform Energy Factor is not provided for this waterheater."; CONTINUE TO RULE ASSERTION` + - otherwise, set rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note += " Uniform Energy Factor is required to evaluate water heaters in ASHRAE 90.1 Table 7.8 / 10 CFR 430. Uniform Energy Factor is not provided for this waterheater. Note that the specific requirements of 10 CFR 430 can be found in ASHRAE 90.1 Appendix F Table F-2."; CONTINUE TO RULE ASSERTION` - else, if the storage tank is greater than 55 and less than 100 gallons, Appendix F provides a heat pump efficiency, which may be an error. return UNDETERMINED: `elif storage_volume <=100 and storage_volume > 55:` - set rule_status to UNDETERMINED: `rule_status = "UNDETERMINED"; CONTINUE TO RULE ASSERTION` - - include a note: `rule_note += " The storage tank is between 55 and 100 gallons with a capacity <= 12kW (40945 btu/hr). The minimum efficiency requirements in 90.1 Section 7.4.2 point to ASHRAE 90.1 Appendix F which provides a heat pump efficiency for water heaters in this capacity range which is not consistent with the efficiency of an electric resistance storage water heater which is the only electric SWH system type associated with the baseline for ASHRAE 90.1 Appendix G. Consequently, this rule was not able to be assessed for this service water heater. "` + - include a note: `rule_note += " The storage tank is between 55 and 100 gallons with a capacity <= 12kW (40945 btu/hr). The minimum efficiency requirements in 90.1 Section 7.4.2 point to 10 CFR 430 which provides a heat pump efficiency for water heaters in this capacity range which is not consistent with the efficiency of an electric resistance storage water heater which is the only electric SWH system type associated with the baseline for ASHRAE 90.1 Appendix G. Consequently, this rule was not able to be assessed for this service water heater. Note that the specific requirements of 10 CFR 430 can be found in ASHRAE 90.1 Appendix F Table F-2."` - go to rule assertion: `GO TO RULE ASSERTION` - otherwise, the capacity per volume is not < 4000 btu/ gallon: `else:` @@ -90,7 +90,7 @@ - else if the storage volume is between 2 and 20 gallons, in which case there is no rating in APPENDIX F. set rule status to UNDETERMINED: `elif storage_volume < 20:` - set the rule status to UNDETERMINED: `rule_status = "UNDETERMINED"` - - add a note: `rule_note += " The storage tank volume is between 2 and 20 gallons and based on the size categories in ASHRAE 90.1 Table 7.8 and Appendix F it would not be classified as an electric storage water heater. Consequently, this rule was not assessed for this service water heater."` + - add a note: `rule_note += " The storage tank volume is between 2 and 20 gallons and based on the size categories in ASHRAE 90.1 Table 7.8 and 10 CFR 430 it would not be classified as an electric storage water heater. Consequently, this rule was not assessed for this service water heater. Note that the specific requirements of 10 CFR 430 can be found in ASHRAE 90.1 Appendix F Table F-2."` - go to rule assertion: `CONTINUE TO RULE ASSERTION` @@ -115,8 +115,8 @@ - check if the actual uniform_energy_factor is equals the expected: `if uniform_energy_factor == expected_UEF:` - set rule_status to "PASS": `rule_status = "PASS"; CONTINUE TO RULE ASSERTION` - otherwise, set rule status to FAIL and provide the note that the expected UEF is less than the required UEF: `else: rule_status = "FAIL"; rule_note += " The modeled Uniform energy Factor (UEF - " + uniform_energy_factor + ") does not equal the required (" + expected_UEF + ")"; CONTINUE TO RULE ASSERTION` - - otherwise, set rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note += " Gas storage water heaters in this size range are regulated based on ASHRAE 90.1 Appendix F Table F-2. The efficiency metric given in Table F-2 is Uniform Energy Factor. Uniform Energy Factor was not provided for this water heater."; CONTINUE TO RULE ASSERTION` - - otherwise, if the storage volume is less than 20 gallons, we will not be able to evaluate the rule logic, Provide a note and continue to rule evaluation: `elif storage_volume < 20: rule_note += " The storage tank volume is less than 20 gallons and the input capacity is <= 75,000 Btuh and based on the size categories in ASHRAE 90.1 Table 7.8 and Appendix F it would not be classified as a gas storage water heater. Consequently, this rule was not able to be assessed for this service water heater. "; rule_status = UNDETERMINED; GO TO RULE ASSERTION` + - otherwise, set rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note += " Gas storage water heaters in this size range are regulated based on ASHRAE 90.1 10 CFR 430. The efficiency metric given in Table F-2 is Uniform Energy Factor. Uniform Energy Factor was not provided for this water heater. Note that the specific requirements of 10 CFR 430 can be found in ASHRAE 90.1 Appendix F Table F-2."; CONTINUE TO RULE ASSERTION` + - otherwise, if the storage volume is less than 20 gallons, we will not be able to evaluate the rule logic, Provide a note and continue to rule evaluation: `elif storage_volume < 20: rule_note += " The storage tank volume is less than 20 gallons and the input capacity is <= 75,000 Btuh and based on the size categories in ASHRAE 90.1 Table 7.8 and 10 CFR 430 it would not be classified as a gas storage water heater. Consequently, this rule was not able to be assessed for this service water heater. Note that the specific requirements of 10 CFR 430 can be found in ASHRAE 90.1 Appendix F Table F-2."; rule_status = UNDETERMINED; GO TO RULE ASSERTION` - otherwise, if the storage volume is between 55 and 100 gallons: `elif storage_volume <= 100:` - determine the UEF based on the draw pattern for VERY_SMALL: `if draw_pattern == "VERY_SMALL": expected_uef = 0.6470 – (0.0006 × storage_volume)` - determine the UEF based on the draw pattern for LOW: `if draw_pattern == "LOW": expected_uef = 0.7689 – (0.0005 × storage_volume)` @@ -126,10 +126,10 @@ - check if the actual uniform_energy_factor is >= to the expected: `if uniform_energy_factor == expected_UEF:` - set rule_status to "PASS": `rule_status = "PASS"; CONTINUE TO RULE ASSERTION` - otherwise, set rule status to FAIL and provide the note that the expected UEF is does not equal the required UEF: `else: rule_status = "FAIL"; rule_note += " The modeled Uniform energy Factor (UEF - " + uniform_energy_factor + ") does not equal the required (" + expected_UEF + ")"; CONTINUE TO RULE ASSERTION` - - otherwise, set rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note = "Gas storage water heaters in this size range are regulated based on ASHRAE 90.1 Appendix F Table F-2. The efficiency metric given in Table F-2 is Uniform Energy Factor. Uniform Energy Factor was not provided for this water heater."; CONTINUE TO RULE ASSERTION` + - otherwise, set rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note = "Gas storage water heaters in this size range are regulated based on 10 CFR 430. The efficiency metric given in Table F-2 is Uniform Energy Factor. Uniform Energy Factor was not provided for this water heater. Note that the specific requirements of 10 CFR 430 can be found in ASHRAE 90.1 Appendix F Table F-2."; CONTINUE TO RULE ASSERTION` - otherwise, the storage volume is greater than 100 gallons, which is not covered by Appendix F: `else:` - - create a note indicating that gas water heaters greater with input capacity < 75,000 btu/hr and the given storage volume are not covered under Appendix F: `rule_note: "The storage tank volume is greater than 100 gallons and the input capacity is <= 75,000 Btuh and based on the size categories in ASHRAE 90.1 Table 7.8 and Appendix F it would not be classified as a gas storage water heater. Consequently, this rule was not able to be assessed for this service water heater."` + - create a note indicating that gas water heaters greater with input capacity < 75,000 btu/hr and the given storage volume are not covered under Appendix F: `rule_note: "The storage tank volume is greater than 100 gallons and the input capacity is <= 75,000 Btuh and based on the size categories in ASHRAE 90.1 Table 7.8 and 10 CFR 430 it would not be classified as a gas storage water heater. Consequently, this rule was not able to be assessed for this service water heater. Note that the specific requirements of 10 CFR 430 can be found in ASHRAE 90.1 Appendix F Table F-2."` - change rule_status to UNDETERMINED: `rule_status = "UNDETERMINED"; CONTINUE TO RULE ASSERTION` - check if the capacity <= 105,000 btu/hr: `elif input_capacity <= 105000:` - the capacity per volume should be < 4000 btu/hr/gallon: `if capacity_per_volume >= 4000:` From 99c2f1403550589c11eee85d0dd29943e44b41d6 Mon Sep 17 00:00:00 2001 From: KarenWGard <114143532+KarenWGard@users.noreply.github.com> Date: Thu, 19 Dec 2024 16:44:33 -0500 Subject: [PATCH 25/25] Update Rule_11-10.md --- docs/section11/Rule_11-10.md | 141 ++++++++++++++++++----------------- 1 file changed, 71 insertions(+), 70 deletions(-) diff --git a/docs/section11/Rule_11-10.md b/docs/section11/Rule_11-10.md index 6591a0ad0b..a98313e133 100644 --- a/docs/section11/Rule_11-10.md +++ b/docs/section11/Rule_11-10.md @@ -53,8 +53,8 @@ - otherwise if the first_hour_rating is less than 75 gallons, draw pattern is MEDIUM: `elif first_hour_rating < 75: draw_pattern = "MEDIUM"` - otherwise draw pattern is HIGH: `else: draw_pattern = "HIGH"` - get the capacity of the SHW system (make sure to convert to btu/hr): `input_capacity = swh_eq.input_power` - - get the volume of the tank (make sure to convert to gallons): `storage_volume = swh_eq.distribution_system.tank.storage_capacity` - - calculate the capacity_per_volume based on the input_capacity and the storage_volume: `capacity_per_volume = shw_eq.rated_capacity / storage_volume` + - get the volume of the tank (make sure to convert to gallons): `storage_volume = swh_eq.tank.storage_capacity` + - calculate the capacity_per_volume based on the rated_capacity and the storage_volume: `capacity_per_volume = shw_eq.rated_capacity / storage_volume` - get the efficiency metric values: `efficiency_metric_values = swh_eq.efficiency_metric_values` - get the efficiency metric types: `efficiency_metric_types = swh_eq.efficiency_metric_types` - create a dictionary of the efficiency data: `efficiency_metric_dict = dict(zip(efficiency_metric_types, efficiency_metric_values)) @@ -67,7 +67,7 @@ - if the water heater is electric resistance storage and the capacity is <= 12kW (40945 btu/hr), look at Appendix F: `if swh_type in ["ELECTRIC_RESISTANCE_STORAGE"] and input_capacity <= 40945.7:` - check that the capacity_per_volume is < 4000 btu/hr/gallon: `if capacity_per_volume < 4000:` - - check the size of the storage tank. If it's less than 2 gallons, provide a note, and continue to rule assertion: `if storage_volume < 2: rule_note += " The storage tank volume is less than 2 gallons and based on the size categories in ASHRAE 90.1 Table 7.8 and in 10 CFR 430, it would not be classified as an electric storage water heater. Consequently, this rule was not assessed for this service water heater. Note that the specific requirements of 10 CFR 430 can be found in ASHRAE 90.1 Appendix F Table F-2."; rule_status = UNDETERMINED; GO TO RULE ASSERTION` + - check the size of the storage tank. If it's less than 20 gallons, provide a note, and continue to rule assertion: `if storage_volume < 20: rule_note += " The storage tank volume is less than 20 gallons and based on the size categories in ASHRAE 90.1 Table 7.8 and in 10 CFR 430, it would not be classified as an electric storage water heater. Consequently, this rule was not assessed for this service water heater. Note that the specific requirements of 10 CFR 430 can be found in ASHRAE 90.1 Appendix F Table F-2."; rule_status = UNDETERMINED; GO TO RULE ASSERTION` - else, if the storage tank is is between 20 and 55 gallons, this is considered an electric storage water heater in Appendix F: `elif storage_volume >= 20 and storage_volume <= 55:` - determine the UEF based on the draw pattern for VERY_SMALL: `if draw_pattern == "VERY_SMALL": expected_uef = 0.8808 – (0.0008 × storage_volume)` - determine the UEF based on the draw pattern for LOW: `if draw_pattern == "LOW": expected_uef = 0.9254 – (0.0003 × storage_volume)` @@ -86,82 +86,83 @@ - otherwise, the capacity per volume is not < 4000 btu/ gallon: `else:` - indicate with the note that the capacity per volume exceeds the limit: `rule_note += " Capacity per volume exceeds the limit of 4000 btu/hr/gallon given for Electric Storage Water Heaters in ASHRAE 90.1 Table 7.8."` - - set the rule status to FAIL and continue to rule assertion: `rule_status = "FAIL"; CONTINUE TO RULE ASSERTION` - - - else if the storage volume is between 2 and 20 gallons, in which case there is no rating in APPENDIX F. set rule status to UNDETERMINED: `elif storage_volume < 20:` - - set the rule status to UNDETERMINED: `rule_status = "UNDETERMINED"` - - add a note: `rule_note += " The storage tank volume is between 2 and 20 gallons and based on the size categories in ASHRAE 90.1 Table 7.8 and 10 CFR 430 it would not be classified as an electric storage water heater. Consequently, this rule was not assessed for this service water heater. Note that the specific requirements of 10 CFR 430 can be found in ASHRAE 90.1 Appendix F Table F-2."` - - go to rule assertion: `CONTINUE TO RULE ASSERTION` - + - set the rule status to FAIL when capacity_per_volume > 4000 and continue to rule assertion: `rule_status = "FAIL"; CONTINUE TO RULE ASSERTION` - otherwise, this is an electric resistance water heater with input > 12 kW, continue with logic per Table 7.8: `else:` - check electric storage water heaters with capacity greater than 12 kW: `if swh_type == "ELECTRIC_RESISTANCE_STORAGE" and input_capacity > 40945.7 (btu/hr):` - check that the capacity_per_volume is < 4000 btu/hr/gallon: `if capacity_per_volume < 4000:` - - calculate the standby loss target: `standby_loss_target = 0.3 + (27/swh_eq.distribution_system.tank.storage_volume)` - - check whether the standby loss fraction is given, if it's not given, provide a note, and a rule result of UNDETERMINED: `if swh_eq.standby_loss_fraction == NULL: rule_note += " Electric resistance water heaters with input capacity > 12kW have a required standby loss given by ASHRAE 90.1 Table 7.8. No standby loss was given for this water heater, thus the rule was not able to be evaluated."` - - if the standby_loss is equal to the target, set the rule_status to PASS: `if swh_eq.standby_loss_fraction <= standby_loss_target: rule_status = "PASS"` + - calculate the standby loss target: `standby_loss_target = 0.3 + (27/swh_eq.tank.storage_volume)` + - check whether the standby loss fraction is given, if it's not given, provide a note, and a rule result of UNDETERMINED: `if efficiency_metric_dict["STANDBY_LOSS_FRACTION"] == NULL: rule_note += " Electric resistance water heaters with input capacity > 12kW have a required standby loss given by ASHRAE 90.1 Table 7.8. No standby loss was given for this water heater, thus the rule was not able to be evaluated."; rule_status = "UNDETERMINED"` + - if the standby_loss is equal to the target, set the rule_status to PASS: `if efficiency_metric_dict["STANDBY_LOSS_FRACTION"] <= standby_loss_target: rule_status = "PASS"` - otherwise: `else:` - set the note to indicate that the standby_loss is higher than the maximum allowed: `rule_note += " Standby Loss is higher than required by Table 7.8"; rule_status = FAIL; GO TO RULE ASSERTION` - otherwise: `else:` - - set the note to indicate that the capacity per volume exceeds the limit: `rule_note += " Capacity per volume exceeds the limit of 4000 btu/hr/gallon given for Electric Storage Water Heaters in ASHRAE 90.1 Table 7.8."; rule_status = FAIL; GO TO RULE ASSERTION` - - check if the water heater is gas storage: `if swh_type == "GAS_STORAGE":` - - check if the capacity is <= 75,000 btu/hr: `if input_capacity <= 75000:` - - if the storage volume is between 20 and 55 gallons: `if storage_volume >= 20 and storage_volume <= 55:` - - determine the UEF based on the draw pattern for VERY_SMALL: `if draw_pattern == "VERY_SMALL": expected_uef = 0.3456 – (0.0020 × storage_volume)` - - determine the UEF based on the draw pattern for LOW: `if draw_pattern == "LOW": expected_uef = 0.5982 – (0.0019 × storage_volume)` - - determine the UEF based on the draw pattern for MEDIUM: `if draw_pattern == "MEDIUM": expected_uef = 0.6483 – (0.0017 × storage_volume)` - - determine the UEF based on the draw pattern for HIGH: `if draw_pattern == "HIGH": expected_uef = 0.6920 – (0.0013 × storage_volume)` - - check whether the uniform_energy_factor is valid: `if uniform_energy_factor != NULL - - check if the actual uniform_energy_factor is equals the expected: `if uniform_energy_factor == expected_UEF:` - - set rule_status to "PASS": `rule_status = "PASS"; CONTINUE TO RULE ASSERTION` - - otherwise, set rule status to FAIL and provide the note that the expected UEF is less than the required UEF: `else: rule_status = "FAIL"; rule_note += " The modeled Uniform energy Factor (UEF - " + uniform_energy_factor + ") does not equal the required (" + expected_UEF + ")"; CONTINUE TO RULE ASSERTION` - - otherwise, set rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note += " Gas storage water heaters in this size range are regulated based on ASHRAE 90.1 10 CFR 430. The efficiency metric given in Table F-2 is Uniform Energy Factor. Uniform Energy Factor was not provided for this water heater. Note that the specific requirements of 10 CFR 430 can be found in ASHRAE 90.1 Appendix F Table F-2."; CONTINUE TO RULE ASSERTION` - - otherwise, if the storage volume is less than 20 gallons, we will not be able to evaluate the rule logic, Provide a note and continue to rule evaluation: `elif storage_volume < 20: rule_note += " The storage tank volume is less than 20 gallons and the input capacity is <= 75,000 Btuh and based on the size categories in ASHRAE 90.1 Table 7.8 and 10 CFR 430 it would not be classified as a gas storage water heater. Consequently, this rule was not able to be assessed for this service water heater. Note that the specific requirements of 10 CFR 430 can be found in ASHRAE 90.1 Appendix F Table F-2."; rule_status = UNDETERMINED; GO TO RULE ASSERTION` - - otherwise, if the storage volume is between 55 and 100 gallons: `elif storage_volume <= 100:` - - determine the UEF based on the draw pattern for VERY_SMALL: `if draw_pattern == "VERY_SMALL": expected_uef = 0.6470 – (0.0006 × storage_volume)` - - determine the UEF based on the draw pattern for LOW: `if draw_pattern == "LOW": expected_uef = 0.7689 – (0.0005 × storage_volume)` - - determine the UEF based on the draw pattern for MEDIUM: `if draw_pattern == "MEDIUM": expected_uef = 0.7897 – (0.0004 × storage_volume)` - - determine the UEF based on the draw pattern for HIGH: `if draw_pattern == "HIGH": expected_uef = 0.8072 – (0.0003 × storage_volume)` - - check whether the uniform_energy_factor is valid: `if uniform_energy_factor != NULL - - check if the actual uniform_energy_factor is >= to the expected: `if uniform_energy_factor == expected_UEF:` - - set rule_status to "PASS": `rule_status = "PASS"; CONTINUE TO RULE ASSERTION` - - otherwise, set rule status to FAIL and provide the note that the expected UEF is does not equal the required UEF: `else: rule_status = "FAIL"; rule_note += " The modeled Uniform energy Factor (UEF - " + uniform_energy_factor + ") does not equal the required (" + expected_UEF + ")"; CONTINUE TO RULE ASSERTION` - - otherwise, set rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note = "Gas storage water heaters in this size range are regulated based on 10 CFR 430. The efficiency metric given in Table F-2 is Uniform Energy Factor. Uniform Energy Factor was not provided for this water heater. Note that the specific requirements of 10 CFR 430 can be found in ASHRAE 90.1 Appendix F Table F-2."; CONTINUE TO RULE ASSERTION` - - - otherwise, the storage volume is greater than 100 gallons, which is not covered by Appendix F: `else:` - - create a note indicating that gas water heaters greater with input capacity < 75,000 btu/hr and the given storage volume are not covered under Appendix F: `rule_note: "The storage tank volume is greater than 100 gallons and the input capacity is <= 75,000 Btuh and based on the size categories in ASHRAE 90.1 Table 7.8 and 10 CFR 430 it would not be classified as a gas storage water heater. Consequently, this rule was not able to be assessed for this service water heater. Note that the specific requirements of 10 CFR 430 can be found in ASHRAE 90.1 Appendix F Table F-2."` - - change rule_status to UNDETERMINED: `rule_status = "UNDETERMINED"; CONTINUE TO RULE ASSERTION` - - check if the capacity <= 105,000 btu/hr: `elif input_capacity <= 105000:` - - the capacity per volume should be < 4000 btu/hr/gallon: `if capacity_per_volume >= 4000:` - - add the to the rule note: `rule_note += "Based on the size categories for gas storage water heaters in ASHRAE 90.1 Table 7.8, gas storage water heaters with an input capacity between 75,000 and 105,000 btu/hr shall have a capacity per volume of 4,000 btu/hr/gallon. This water heater has a capacity per gallon of " + capacity_per_volume + " btu/hr/gallon. Consequently, this rule was not able to be assesed for this service water heater. "; rule_status = "UNDETERMINED"; CONTINUE TO RULE ASSERTION` - - set has_fault to true: `has_fault = true` - - the volume should be <= 120 gallons: `if storage_volume > 120:` - - add to the rule note: `rule_note += "Based on the size categories for gas storage water heaters in ASHRAE 90.1 Table 7.8, gas storage water heaters with an input capacity between 75,000 and 105,000 btu/hr shall have a storage capacity of <= 120 gallons. The storage capacity of this water heater is " + storage_volume + " gallons."; rule_status = FAIL` - - set has_fault to true: `has_fault = true` - - the supply water temperature should be <= 180F: `if shw_eq.setpoint_temperature > 180:` - - add to the rule note: `rule_note += "Based on the size categories for gas storage water heaters in ASHRAE 90.1 Table 7.8, gas storage water heaters with an input capacity between 75,000 and 105,000 btu/hr shall have a setpoint temperature of 180F. The setpoint temperature of this water heater is " + shw_eq.setpoint_temperature + "F. "; rule_status = FAIL` - - set has_fault to true: `has_fault = true` - - calculate the expected efficiency for VERY_SMALL draw pattern: `if draw_pattern == "VERY_SMALL": expected_UEF = 0.2674 – (0.0009 * volume)` - - calculate the expected efficiency for LOW draw pattern: `if draw_pattern == "LOW": expected_UEF = 0.5362 – (0.0012 * volume)` - - calculate the expected efficiency for MEDIUM draw pattern: `if draw_pattern == "MEDIUM": expected_UEF = 0.6002 – (0.0011 * volume)` - - calculate the expected efficiency for HIGH draw pattern: `if draw_pattern == "HIGH": expected_UEF = 0.6597 – (0.0009 * volume)` + - set the note to indicate that the capacity per volume exceeds the limit, set rule status to FAIL and go to rule assertion: `rule_note += " Capacity per volume exceeds the limit of 4000 btu/hr/gallon given for Electric Storage Water Heaters in ASHRAE 90.1 Table 7.8."; rule_status = FAIL; GO TO RULE ASSERTION` + - check if the water heater is gas storage: `if swh_type == "GAS_STORAGE":` + - check if the capacity is <= 75,000 btu/hr: `if input_capacity <= 75000:` + - if the storage volume is between 20 and 55 gallons: `if storage_volume >= 20 and storage_volume <= 55:` + - determine the UEF based on the draw pattern for VERY_SMALL: `if draw_pattern == "VERY_SMALL": expected_uef = 0.3456 – (0.0020 × storage_volume)` + - determine the UEF based on the draw pattern for LOW: `if draw_pattern == "LOW": expected_uef = 0.5982 – (0.0019 × storage_volume)` + - determine the UEF based on the draw pattern for MEDIUM: `if draw_pattern == "MEDIUM": expected_uef = 0.6483 – (0.0017 × storage_volume)` + - determine the UEF based on the draw pattern for HIGH: `if draw_pattern == "HIGH": expected_uef = 0.6920 – (0.0013 × storage_volume)` - check whether the uniform_energy_factor is valid: `if uniform_energy_factor != NULL - - check if the actual uniform_energy_factor equal to the expected: `if uniform_energy_factor == expected_UEF and !has_faults:` + - check if the actual uniform_energy_factor is equals the expected: `if uniform_energy_factor == expected_UEF:` + - set rule_status to "PASS": `rule_status = "PASS"; CONTINUE TO RULE ASSERTION` + - otherwise, set rule status to FAIL and provide the note that the expected UEF is less than the required UEF: `else: rule_status = "FAIL"; rule_note += " The modeled Uniform energy Factor (UEF - " + uniform_energy_factor + ") does not equal the required (" + expected_UEF + ")"; CONTINUE TO RULE ASSERTION` + - otherwise, set rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note += " Gas storage water heaters in this size range are regulated based on ASHRAE 90.1 10 CFR 430. The efficiency metric given in Table F-2 is Uniform Energy Factor. Uniform Energy Factor was not provided for this water heater. Note that the specific requirements of 10 CFR 430 can be found in ASHRAE 90.1 Appendix F Table F-2."; CONTINUE TO RULE ASSERTION` + - otherwise, if the storage volume is less than 20 gallons, we will not be able to evaluate the rule logic, Provide a note and continue to rule evaluation: `elif storage_volume < 20: rule_note += " The storage tank volume is less than 20 gallons and the input capacity is <= 75,000 Btuh and based on the size categories in ASHRAE 90.1 Table 7.8 and 10 CFR 430 it would not be classified as a gas storage water heater. Consequently, this rule was not able to be assessed for this service water heater. Note that the specific requirements of 10 CFR 430 can be found in ASHRAE 90.1 Appendix F Table F-2."; rule_status = UNDETERMINED; GO TO RULE ASSERTION` + - otherwise, if the storage volume is between 55 and 100 gallons: `elif storage_volume <= 100:` + - determine the UEF based on the draw pattern for VERY_SMALL: `if draw_pattern == "VERY_SMALL": expected_uef = 0.6470 – (0.0006 × storage_volume)` + - determine the UEF based on the draw pattern for LOW: `if draw_pattern == "LOW": expected_uef = 0.7689 – (0.0005 × storage_volume)` + - determine the UEF based on the draw pattern for MEDIUM: `if draw_pattern == "MEDIUM": expected_uef = 0.7897 – (0.0004 × storage_volume)` + - determine the UEF based on the draw pattern for HIGH: `if draw_pattern == "HIGH": expected_uef = 0.8072 – (0.0003 × storage_volume)` + - check whether the uniform_energy_factor is valid: `if uniform_energy_factor != NULL + - check if the actual uniform_energy_factor is >= to the expected: `if uniform_energy_factor == expected_UEF:` + - set rule_status to "PASS": `rule_status = "PASS"; CONTINUE TO RULE ASSERTION` + - otherwise, set rule status to FAIL and provide the note that the expected UEF is does not equal the required UEF: `else: rule_status = "FAIL"; rule_note += " The modeled Uniform energy Factor (UEF - " + uniform_energy_factor + ") does not equal the required (" + expected_UEF + ")"; CONTINUE TO RULE ASSERTION` + - otherwise, set rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note = "Gas storage water heaters in this size range are regulated based on 10 CFR 430. The efficiency metric given in Table F-2 is Uniform Energy Factor. Uniform Energy Factor was not provided for this water heater. Note that the specific requirements of 10 CFR 430 can be found in ASHRAE 90.1 Appendix F Table F-2."; CONTINUE TO RULE ASSERTION` + + - otherwise, the storage volume is greater than 100 gallons, which is not covered by Appendix F: `else:` + - create a note indicating that gas water heaters greater with input capacity < 75,000 btu/hr and the given storage volume are not covered under Appendix F: `rule_note: "The storage tank volume is greater than 100 gallons and the input capacity is <= 75,000 Btuh and based on the size categories in ASHRAE 90.1 Table 7.8 and 10 CFR 430 it would not be classified as a gas storage water heater. Consequently, this rule was not able to be assessed for this service water heater. Note that the specific requirements of 10 CFR 430 can be found in ASHRAE 90.1 Appendix F Table F-2."` + - change rule_status to UNDETERMINED: `rule_status = "UNDETERMINED"; CONTINUE TO RULE ASSERTION` + - check if the capacity <= 105,000 btu/hr: `elif input_capacity <= 105000:` + - the capacity per volume should be < 4000 btu/hr/gallon: `if capacity_per_volume >= 4000:` + - add the to the rule note, set the rule status to UNDETERMINED and go to rule assertion: `rule_note += "Based on the size categories for gas storage water heaters in ASHRAE 90.1 Table 7.8, gas storage water heaters with an input capacity between 75,000 and 105,000 btu/hr shall have a capacity per volume of 4,000 btu/hr/gallon. This water heater has a capacity per gallon of " + capacity_per_volume + " btu/hr/gallon. Consequently, this rule was not able to be assesed for this service water heater. "; rule_status = "UNDETERMINED"; CONTINUE TO RULE ASSERTION` + - set has_fault to true: `has_fault = true` + - the volume should be <= 120 gallons: `if storage_volume > 120:` + - add to the rule note: `rule_note += "Based on the size categories for gas storage water heaters in ASHRAE 90.1 Table 7.8, gas storage water heaters with an input capacity between 75,000 and 105,000 btu/hr shall have a storage capacity of <= 120 gallons. The storage capacity of this water heater is " + storage_volume + " gallons."; rule_status = FAIL` + - set has_fault to true: `has_fault = true` + - the supply water temperature should be <= 180F: `if shw_eq.setpoint_temperature > 180:` + - add to the rule note: `rule_note += "Based on the size categories for gas storage water heaters in ASHRAE 90.1 Table 7.8, gas storage water heaters with an input capacity between 75,000 and 105,000 btu/hr shall have a setpoint temperature of 180F. The setpoint temperature of this water heater is " + shw_eq.setpoint_temperature + "F. "; rule_status = FAIL` + - set has_fault to true: `has_fault = true` + - calculate the expected efficiency for VERY_SMALL draw pattern: `if draw_pattern == "VERY_SMALL": expected_UEF = 0.2674 – (0.0009 * volume)` + - calculate the expected efficiency for LOW draw pattern: `if draw_pattern == "LOW": expected_UEF = 0.5362 – (0.0012 * volume)` + - calculate the expected efficiency for MEDIUM draw pattern: `if draw_pattern == "MEDIUM": expected_UEF = 0.6002 – (0.0011 * volume)` + - calculate the expected efficiency for HIGH draw pattern: `if draw_pattern == "HIGH": expected_UEF = 0.6597 – (0.0009 * volume)` + - check whether the uniform_energy_factor is valid: `if uniform_energy_factor != NULL + - check if the actual uniform_energy_factor equal to the expected: `if uniform_energy_factor == expected_UEF and not has_faults:` + - set rule_status to "PASS": `rule_status = "PASS"; CONTINUE TO RULE ASSERTION` + - otherwise, set rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note += " Uniform Energy Factor is required but not provided"; CONTINUE TO RULE ASSERTION` + - otherwise the capacity is > 105,000 btu/hr: `else:` + - the capacity per volume should be < 4000 btu/hr/gallon: `if capacity_per_volume >= 4000:` + - add to the rule note, and set the rule status to UNDETERMINED: `rule_note += " Based on the size categories for gas storage water heaters in ASHRAE 90.1 Table 7.8, gas storage water heaters with an input capacity greater than 105,000 btu/hr shall have a capacity per volume of 4,000 btu/hr/gallon. This water heater has a capacity per gallon of " + capacity_per_volume + " btu/hr/gallon. Consequently, this rule was not able to be assesed for this service water heater. "; rule_status = UNDETERMINED` + - set has_fault to true: `has_fault = true` + - calculate the expected_thermal_efficiency : `expected_thermal_efficiency = 0.8` + - calculate max_standby_loss (btu/hr): `max_standby_loss = (input_capacity/800 + 110 * sqrt(volume))` + - make sure that the thermal efficiency is not NULL: `if thermal_efficiency != NULL:` + - make sure that the standy loss is not NULL: `if efficiency_metric_dict["STANDBY_LOSS_ENERGY"] != NULL:` + - get the standby loss: `standby_loss = efficiency_metric_dict["STANDBY_LOSS_ENERGY"]` + - check if the actual thermal efficiency is == to the expected: `if shw_eq.thermal_efficiency == expected_thermal_efficiency and standby_loss <= max_standby_loss and not has_faults:` - set rule_status to "PASS": `rule_status = "PASS"; CONTINUE TO RULE ASSERTION` - - otherwise, set rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note += " Uniform Energy Factor is required but not provided"; CONTINUE TO RULE ASSERTION` - - otherwise the capacity is > 105,000 btu/hr: `else:` - - the capacity per volume should be < 4000 btu/hr/gallon: `if capacity_per_volume >= 4000:` - - add to the rule note: `rule_note += "Based on the size categories for gas storage water heaters in ASHRAE 90.1 Table 7.8, gas storage water heaters with an input capacity greater than 105,000 btu/hr shall have a capacity per volume of 4,000 btu/hr/gallon. This water heater has a capacity per gallon of " + capacity_per_volume + " btu/hr/gallon. Consequently, this rule was not able to be assesed for this service water heater. "; rule_status = UNDETERMINED` - - set has_fault to true: `has_fault = true` - - calculate the expected_thermal_efficiency : `expected_thermal_efficiency = 0.8` - - calculate max_standby_loss (btu/hr): `max_standby_loss = (input_capacity/800 + 110 * sqrt(volume))` - - make sure that the thermal efficiency is not NULL: `if thermal_efficiency != NULL:` - - make sure that the standy loss is not NULL: `if swh_eq.standby_loss_fraction != NULL:` - - get the standby loss (see note 1 for calculation source): `standby_loss = swh_eq.standby_loss_fraction * 8.25 * volume * 70` - - check if the actual thermal efficiency is == to the expected: `if shw_eq.thermal_efficiency == expected_thermal_efficiency and standby_loss <= max_standby_loss and !has_faults:` - - set rule_status to "PASS": `rule_status = "PASS"; CONTINUE TO RULE ASSERTION` - - otherwise set the rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note += " For gas storage water heaters with capacity > 105,000 btu/hr, ASHRAE 90.1 Table 7.8 gives an expected standby loss. We calculate this standby loss based on the Standby Loss Fraction. No Standby Loss Fraction was given, so this rule could not be evaluated." + expected_thermal_efficiency; CONTINUE TO RULE ASSERTION` - - otherwise set the rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note += " For gas storage water heaters with capacity > 105,000 btu/hr, ASHRAE 90.1 Table 7.8 gives an expected thermal efficiency of : " + expected_thermal_efficiency + ". No thermal efficiency was given for this water heater, so the rule could not be evaluated."; CONTINUE TO RULE ASSERTION` + - otherwise, if the thermal efficiency is correct, and there are no faults, check the standby loss based on calculating using the standby_loss_fraction: `if shw_eq.thermal_efficiency == expected_thermal_efficiency not has_faults:` + - check if the standby loss fraction is given: `if efficiency_metric_dict["STANDBY_LOSS_FRACTION"] != NULL:` + - get the standby loss (see note 1 for calculation source): `standby_loss = efficiency_metric_dict["STANDBY_LOSS_FRACTION"] * 8.25 * volume * 70` + - check if the calculated standby_loss is <= to the expected: `if standby_loss <= max_standby_loss:` + - set the rule status to "UNDETERMINED" and provide a rule note indicating that the calculated standby loss was correct, but that the actual standby loss was not given: `rule_status = "UNDETERMINED"; rule_note += " For gas storage water heaters with capactiy > 105,000 btu/hr, ASHRAE 90.1 Table 7.8 gives an expected standby loss. No standby loss was given. We have calculated an approximate standby loss using the given Standby Loss Fraction given the formula: Standby_Loss = Standby_Loss_Fraction * 8.25 * volume * 70. This calculated loss is less than or equal to the expected loss. Rule passes if assesor determines that this equation is appropriate for this project."` + - otherwise, the calculated standby loss is not correct, set rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note += " For gas storage water heaters with capactiy > 105,000 btu/hr, ASHRAE 90.1 Table 7.8 gives an expected standby loss. No standby loss was given. We have calculated an approximate standby loss using the given Standby Loss Fraction given the formula: Standby_Loss = Standby_Loss_Fraction * 8.25 * volume * 70. This calculated loss greater than the expected loss. Rule fails unless the assesor determines that the loss is appropriate for this project."` + - continue to rule assertion: `CONTINUE TO RULE ASSERTION` + - otherwise set the rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note += " For gas storage water heaters with capacity > 105,000 btu/hr, ASHRAE 90.1 Table 7.8 gives an expected standby loss. No Standby Loss was given, so this rule could not be evaluated." + expected_thermal_efficiency; CONTINUE TO RULE ASSERTION` + - otherwise set the rule status to UNDETERMINED and provide a note: `else: rule_status = "UNDETERMINED"; rule_note += " For gas storage water heaters with capacity > 105,000 btu/hr, ASHRAE 90.1 Table 7.8 gives an expected thermal efficiency of : " + expected_thermal_efficiency + ". No thermal efficiency was given for this water heater, so the rule could not be evaluated."; CONTINUE TO RULE ASSERTION` - if we arrive here, we did not reach a PASS option, there are faults, go to rule assertion: `CONTINUE TO RULE ASSERTION` **Rule Assertion - ServiceWaterHeatingEquipment:**