Add is_tolerance_fail method for Section 5 to 6

rct229/rulesets/ashrae9012019/section5/section5rule1.py

@@ -146,6 +146,12 @@ def __init__(self):
                     required_fields={
                         "$.building_segments[*].zones[*].surfaces[*]": ["azimuth"],
                     },
+                    precision={
+                        "percent_difference_max_min_fen_area_per_orientation": {
+                            "precision": 0.01,
+                            "unit": "",
+                        }
+                    },
                     fail_msg="Fail unless Table G3.1#5a exception #2 is applicable and it can be demonstrated that the building orientation is dictated by site considerations.",
                 )
 
@@ -223,7 +229,13 @@ def get_key_for_azi(azi):
                 )
 
                 rotation_expected_b = (
-                    percent_difference >= ACCEPTABLE_FEN_PERCENTAGE_DIFFERENCE
+                    percent_difference > ACCEPTABLE_FEN_PERCENTAGE_DIFFERENCE
+                    or self.precision_comparison[
+                        "percent_difference_max_min_fen_area_per_orientation"
+                    ](
+                        percent_difference.magnitude,
+                        ACCEPTABLE_FEN_PERCENTAGE_DIFFERENCE,
+                    )
                 )
 
                 return {

rct229/rulesets/ashrae9012019/section5/section5rule10.py

@@ -80,6 +80,12 @@ def __init__(self):
                         "$": ["construction"],
                         "construction": ["u_factor"],
                     },
+                    precision={
+                        "floor_u_factor_b": {
+                            "precision": 0.001,
+                            "unit": "Btu/(hr*ft2*R)",
+                        }
+                    },
                 )
 
             def get_calc_vals(self, context, data=None):
@@ -132,7 +138,11 @@ def manual_check_required(self, context, calc_vals=None, data=None):
                 )
 
             def rule_check(self, context, calc_vals=None, data=None):
+                return self.precision_comparison["floor_u_factor_b"](
+                    calc_vals["floor_u_factor"], calc_vals["target_u_factor"]
+                )
+
+            def is_tolerance_fail(self, context, calc_vals=None, data=None):
                 floor_u_factor = calc_vals["floor_u_factor"]
                 target_u_factor = calc_vals["target_u_factor"]
-
-                return std_equal(val=floor_u_factor, std_val=target_u_factor)
+                return std_equal(floor_u_factor, target_u_factor)

rct229/rulesets/ashrae9012019/section5/section5rule12.py

@@ -91,6 +91,12 @@ def __init__(self):
                     },
                     manual_check_required_msg=MANUAL_CHECK_REQUIRED_MSG,
                     fail_msg=FAIL_MSG,
+                    precision={
+                        "floor_f_factor_b": {
+                            "precision": 0.001,
+                            "unit": "Btu/(hr*ft*R)",
+                        }
+                    },
                 )
 
             def get_calc_vals(self, context, data=None):
@@ -147,9 +153,14 @@ def manual_check_required(self, context, calc_vals=None, data=None):
                 return target_f_factor_res != target_f_factor_nonres
 
             def rule_check(self, context, calc_vals=None, data=None):
+                return self.precision_comparison["floor_f_factor_b"](
+                    calc_vals["target_f_factor"],
+                    calc_vals["slab_on_grade_floor_f_factor"],
+                )
+
+            def is_tolerance_fail(self, context, calc_vals=None, data=None):
                 target_f_factor = calc_vals["target_f_factor"]
                 slab_on_grade_floor_f_factor = calc_vals["slab_on_grade_floor_f_factor"]
-
                 return std_equal(
                     std_val=target_f_factor, val=slab_on_grade_floor_f_factor
                 )

rct229/rulesets/ashrae9012019/section5/section5rule13.py

@@ -16,7 +16,6 @@
 )
 from rct229.utils.assertions import getattr_
 from rct229.utils.pint_utils import CalcQ
-from rct229.utils.std_comparisons import std_equal
 
 
 class Section5Rule13(RuleDefinitionListIndexedBase):
@@ -76,6 +75,20 @@ def __init__(self):
                         USER=False, BASELINE_0=True, PROPOSED=True
                     ),
                     required_fields={"$": ["construction"]},
+                    precision={
+                        "surface_u_factor_b": {
+                            "precision": 0.001,
+                            "unit": "Btu/(hr*ft2*R)",
+                        },
+                        "surface_c_factor_b": {
+                            "precision": 0.001,
+                            "unit": "Btu/(hr*ft2*R)",
+                        },
+                        "surface_f_factor_b": {
+                            "precision": 0.001,
+                            "unit": "Btu/(hr*ft*R)",
+                        },
+                    },
                 )
 
             def get_calc_vals(self, context, data=None):
@@ -157,17 +170,20 @@ def rule_check(self, context, calc_vals=None, data=None):
                     return False
 
                 if baseline_surface_type in [OST.ABOVE_GRADE_WALL, OST.FLOOR, OST.ROOF]:
-                    return std_equal(
+                    return self.precision_comparison["surface_u_factor_b"](
                         calc_vals["baseline_surface_u_factor"],
                         calc_vals["proposed_surface_u_factor"],
                     )
+
                 elif baseline_surface_type in [OST.UNHEATED_SOG, OST.HEATED_SOG]:
-                    return std_equal(
+                    return self.precision_comparison["surface_f_factor_b"](
                         calc_vals["baseline_surface_f_factor"],
                         calc_vals["proposed_surface_f_factor"],
                     )
+
                 elif baseline_surface_type == OST.BELOW_GRADE_WALL:
-                    return std_equal(
+
+                    return self.precision_comparison["surface_c_factor_b"](
                         calc_vals["baseline_surface_c_factor"],
                         calc_vals["proposed_surface_c_factor"],
                     )

rct229/rulesets/ashrae9012019/section5/section5rule14.py

@@ -110,6 +110,12 @@ def __init__(self):
                     rmds_used=produce_ruleset_model_description(
                         USER=False, BASELINE_0=True, PROPOSED=False
                     ),
+                    precision={
+                        "area_type_wwr_b": {
+                            "precision": 0.01,
+                            "unit": "",
+                        }
+                    },
                 )
 
             def get_calc_vals(self, context, data=None):
@@ -156,6 +162,12 @@ def get_manual_check_required_msg(self, context, calc_vals=None, data=None):
                 return manual_check_msg
 
             def rule_check(self, context, calc_vals=None, data=None):
+                return self.precision_comparison["area_type_wwr_b"](
+                    calc_vals["area_type_wwr"].magnitude,
+                    calc_vals["area_type_target_wwr"],
+                )
+
+            def is_tolerance_fail(self, context, calc_vals=None, data=None):
                 area_type_wwr = calc_vals["area_type_wwr"]
                 area_type_target_wwr = calc_vals["area_type_target_wwr"]
-                return std_equal(area_type_target_wwr, area_type_wwr)
+                return std_equal(area_type_wwr, area_type_target_wwr)

rct229/rulesets/ashrae9012019/section5/section5rule15.py

@@ -53,6 +53,12 @@ def __init__(self):
                         "area_type_vertical_fenestration",
                     ],
                 },
+                precision={
+                    "wwr_b": {
+                        "precision": 0.01,
+                        "unit": "",
+                    }
+                },
             )
 
         def is_applicable(self, context, data=None):
@@ -109,6 +115,10 @@ def get_manual_check_required_msg(self, context, calc_vals=None, data=None):
             return manual_check_msg
 
         def rule_check(self, context, calc_vals=None, data=None):
-            return not calc_vals["manual_check_flag"] and std_equal(
-                calc_vals["wwr_b"], min(calc_vals["wwr_p"], WWR_THRESHOLD)
+            return self.precision_comparison["wwr_b"](
+                calc_vals["wwr_b"].magnitude,
+                min(calc_vals["wwr_p"].magnitude, WWR_THRESHOLD),
             )
+
+        def is_tolerance_fail(self, context, calc_vals=None, data=None):
+            return std_equal(calc_vals["wwr_b"], min(calc_vals["wwr_p"], WWR_THRESHOLD))

rct229/rulesets/ashrae9012019/section5/section5rule16.py

@@ -109,6 +109,12 @@ def __init__(self):
                         "$": ["construction"],
                         "construction": ["u_factor"],
                     },
+                    precision={
+                        "total_fenestration_area_surface_b / total_fenstration_area_b": {
+                            "precision": 0.01,
+                            "unit": "",
+                        }
+                    },
                     fail_msg=FAIL_MSG,
                 )
 
@@ -169,7 +175,17 @@ def rule_check(self, context, calc_vals=None, data=None):
                 return (
                     total_fenestration_area_b == ZERO.AREA
                     and total_fenestration_area_p == ZERO.AREA
-                ) or std_equal(
-                    (total_fenestration_area_surface_b / total_fenestration_area_b),
-                    (total_fenestration_area_surface_p / total_fenestration_area_p),
+                ) or (
+                    self.precision_comparison[
+                        "total_fenestration_area_surface_b / total_fenstration_area_b"
+                    ](
+                        (
+                            total_fenestration_area_surface_b
+                            / total_fenestration_area_b
+                        ).magnitude,
+                        (
+                            total_fenestration_area_surface_p
+                            / total_fenestration_area_p
+                        ).magnitude,
+                    )
                 )

rct229/rulesets/ashrae9012019/section5/section5rule19.py

@@ -2,6 +2,7 @@
 from rct229.rule_engine.rule_list_indexed_base import RuleDefinitionListIndexedBase
 from rct229.rule_engine.ruleset_model_factory import produce_ruleset_model_description
 from rct229.rulesets.ashrae9012019 import BASELINE_0
+from rct229.schema.schema_enums import SchemaEnums
 from rct229.rulesets.ashrae9012019.data_fns.table_G3_4_fns import table_G34_lookup
 from rct229.rulesets.ashrae9012019.ruleset_functions.get_building_scc_window_wall_ratios_dict import (
     get_building_scc_window_wall_ratios_dict,
@@ -18,7 +19,6 @@
 from rct229.rulesets.ashrae9012019.ruleset_functions.get_surface_conditioning_category_dict import (
     get_surface_conditioning_category_dict,
 )
-from rct229.schema.schema_enums import SchemaEnums
 from rct229.utils.jsonpath_utils import find_all
 from rct229.utils.pint_utils import ZERO, CalcQ
 from rct229.utils.std_comparisons import std_equal
@@ -264,6 +264,12 @@ def __init__(self):
                         rmds_used=produce_ruleset_model_description(
                             USER=False, BASELINE_0=True, PROPOSED=False
                         ),
+                        precision={
+                            "subsurface_u_factor_b": {
+                                "precision": 0.01,
+                                "unit": "Btu/(hr*ft2*R)",
+                            }
+                        },
                     )
 
                 def get_calc_vals(self, context, data=None):
@@ -293,6 +299,11 @@ def get_calc_vals(self, context, data=None):
                     }
 
                 def rule_check(self, context, calc_vals=None, data=None):
+                    return self.precision_comparison["subsurface_u_factor_b"](
+                        calc_vals["target_u_factor"], calc_vals["subsurface_u_factor"]
+                    )
+
+                def is_tolerance_fail(self, context, calc_vals=None, data=None):
                     target_u_factor = calc_vals["target_u_factor"]
                     subsurface_u_factor = calc_vals["subsurface_u_factor"]
                     return std_equal(std_val=target_u_factor, val=subsurface_u_factor)

rct229/rulesets/ashrae9012019/section5/section5rule20.py

@@ -251,6 +251,12 @@ def __init__(self):
                         rmds_used=produce_ruleset_model_description(
                             USER=False, BASELINE_0=True, PROPOSED=False
                         ),
+                        precision={
+                            "subsurface_shgc_b": {
+                                "precision": 0.01,
+                                "unit": "",
+                            }
+                        },
                     )
 
                 def manual_check_required(self, context, calc_vals=None, data=None):
@@ -282,6 +288,14 @@ def get_calc_vals(self, context, data=None):
                 def rule_check(self, context, calc_vals=None, data=None):
                     target_shgc = calc_vals["target_shgc"]
                     subsurface_shgc = calc_vals["subsurface_shgc"]
+
+                    return target_shgc is not None and self.precision_comparison[
+                        "subsurface_shgc_b"
+                    ](subsurface_shgc, target_shgc)
+
+                def is_tolerance_fail(self, context, calc_vals=None, data=None):
+                    target_shgc = calc_vals["target_shgc"]
+                    subsurface_shgc = calc_vals["subsurface_shgc"]
                     return target_shgc is not None and std_equal(
                         std_val=target_shgc, val=subsurface_shgc
                     )

rct229/rulesets/ashrae9012019/section5/section5rule21.py

@@ -9,7 +9,7 @@
     get_surface_conditioning_category_dict,
 )
 from rct229.utils.pint_utils import CalcQ
-from rct229.utils.std_comparisons import std_equal
+
 
 FAIL_MSG = "Subsurface that is not regulated (Not part of building envelope) is not modeled with the same area, U-factor and SHGC in the baseline as in the propsoed design."
 
@@ -83,22 +83,25 @@ def __init__(self):
                         rmds_used=produce_ruleset_model_description(
                             USER=False, BASELINE_0=True, PROPOSED=True
                         ),
-                        fail_msg=FAIL_MSG,
                         precision={
                             "subsurface_u_factor_b": {
-                                "precision": 0.000000001,
+                                "precision": 0.01,
                                 "unit": "Btu/(hr*ft2*R)",
                             },
-                            "subsurface_shgc_b": {"precision": 0.000000000001},
+                            "subsurface_shgc_b": {
+                                "precision": 0.01,
+                                "unit": "",
+                            },
                             "subsurface_glazed_area_b": {
-                                "precision": 0.000000000001,
+                                "precision": 1,
                                 "unit": "ft2",
                             },
                             "subsurface_opaque_area_b": {
-                                "precision": 0.000000000001,
+                                "precision": 1,
                                 "unit": "ft2",
                             },
                         },
+                        fail_msg=FAIL_MSG,
                     )
 
                 def get_calc_vals(self, context, data=None):

rct229/rulesets/ashrae9012019/section5/section5rule23.py

@@ -3,6 +3,7 @@
 from rct229.rule_engine.ruleset_model_factory import produce_ruleset_model_description
 from rct229.rulesets.ashrae9012019 import BASELINE_0
 from rct229.utils.jsonpath_utils import find_all
+from rct229.utils.std_comparisons import std_equal
 
 MANUAL_CHECK_MSG = "Surface in P-RMD has subsurfaces modeled with different manual shade status. Verify if subsurfaces manual shade status in B-RMD are modeled the same as in P-RMD"
 

rct229/rulesets/ashrae9012019/section5/section5rule24.py

@@ -63,6 +63,12 @@ def __init__(self):
                     rmds_used=produce_ruleset_model_description(
                         USER=False, BASELINE_0=True, PROPOSED=True
                     ),
+                    precision={
+                        "skylight_roof_ratio_b": {
+                            "precision": 0.01,
+                            "unit": "",
+                        }
+                    },
                 )
 
             def is_applicable(self, context, data=None):
@@ -112,6 +118,7 @@ def get_calc_vals(self, context, data=None):
                 }
 
             def rule_check(self, context, calc_vals=None, data=None):
-                skylight_roof_ratio_b = calc_vals["skylight_roof_ratio_b"]
-                skylight_roof_ratio_p = calc_vals["skylight_total_roof_ratio_p"]
-                return std_equal(skylight_roof_ratio_b, skylight_roof_ratio_p)
+                return self.precision_comparison["skylight_roof_ratio_b"](
+                    calc_vals["skylight_roof_ratio_b"].magnitude,
+                    calc_vals["skylight_total_roof_ratio_p"].magnitude,
+                )

rct229/rulesets/ashrae9012019/section5/section5rule25.py

@@ -63,6 +63,12 @@ def __init__(self):
                     rmds_used=produce_ruleset_model_description(
                         USER=False, BASELINE_0=True, PROPOSED=True
                     ),
+                    precision={
+                        "skylight_roof_ratio_b": {
+                            "precision": 0.01,
+                            "unit": "",
+                        }
+                    },
                 )
 
             def is_applicable(self, context, data=None):
@@ -110,5 +116,10 @@ def get_calc_vals(self, context, data=None):
                 }
 
             def rule_check(self, context, calc_vals=None, data=None):
+                return self.precision_comparison["skylight_roof_ratio_b"](
+                    calc_vals["skylight_roof_ratio_b"].magnitude, SKYLIGHT_THRESHOLD
+                )
+
+            def is_tolerance_fail(self, context, calc_vals=None, data=None):
                 skylight_roof_ratio_b = calc_vals["skylight_roof_ratio_b"]
-                return std_equal(skylight_roof_ratio_b, 0.03)
+                return std_equal(skylight_roof_ratio_b, SKYLIGHT_THRESHOLD)