open-fdd 0.1.8__py3-none-any.whl → 0.1.9__py3-none-any.whl

open_fdd/air_handling_unit/faults/fault_condition_six.py

@@ -0,0 +1,228 @@
+import sys
+
+import pandas as pd
+
+from open_fdd.core.base_fault import BaseFaultCondition
+from open_fdd.core.components import FaultInputColumn, InstanceAttribute
+from open_fdd.core.exceptions import InvalidParameterError
+from open_fdd.core.mixins import FaultConditionMixin
+
+INPUT_COLS = [
+    FaultInputColumn(
+        name="supply_fan_air_volume_col",
+        constant_form="SUPPLY_FAN_AIR_VOLUME_COL",
+        description="Supply fan air volume",
+        unit="CFM",
+        required=True,
+        type=float,
+    ),
+    FaultInputColumn(
+        name="mat_col",
+        constant_form="MAT_COL",
+        description="Mixed air temperature",
+        unit="°F",
+        required=True,
+        type=float,
+    ),
+    FaultInputColumn(
+        name="oat_col",
+        constant_form="OAT_COL",
+        description="Outside air temperature",
+        unit="°F",
+        required=True,
+        type=float,
+    ),
+    FaultInputColumn(
+        name="rat_col",
+        constant_form="RAT_COL",
+        description="Return air temperature",
+        unit="°F",
+        required=True,
+        type=float,
+    ),
+    FaultInputColumn(
+        name="supply_vfd_speed_col",
+        constant_form="SUPPLY_VFD_SPEED_COL",
+        description="Supply fan VFD speed",
+        unit="%",
+        required=True,
+        type=float,
+    ),
+    FaultInputColumn(
+        name="economizer_sig_col",
+        constant_form="ECONOMIZER_SIG_COL",
+        description="Economizer signal",
+        unit="%",
+        required=True,
+        type=float,
+    ),
+    FaultInputColumn(
+        name="heating_sig_col",
+        constant_form="HEATING_SIG_COL",
+        description="Heating signal",
+        unit="%",
+        required=True,
+        type=float,
+    ),
+    FaultInputColumn(
+        name="cooling_sig_col",
+        constant_form="COOLING_SIG_COL",
+        description="Cooling signal",
+        unit="%",
+        required=True,
+        type=float,
+    ),
+]
+
+FAULT_PARAMS = [
+    InstanceAttribute(
+        name="airflow_err_thres",
+        constant_form="AIRFLOW_ERR_THRES",
+        description="Airflow error threshold",
+        unit="fraction",
+        type=float,
+        range=(0.0, 1.0),
+    ),
+    InstanceAttribute(
+        name="ahu_min_oa_cfm_design",
+        constant_form="AHU_MIN_OA_CFM_DESIGN",
+        description="AHU minimum outdoor air CFM design",
+        unit="CFM",
+        type=float,
+        range=(0.0, 100000.0),
+    ),
+    InstanceAttribute(
+        name="outdoor_degf_err_thres",
+        constant_form="OUTDOOR_DEGF_ERR_THRES",
+        description="Outdoor air temperature error threshold",
+        unit="°F",
+        type=float,
+        range=(0.0, 10.0),
+    ),
+    InstanceAttribute(
+        name="return_degf_err_thres",
+        constant_form="RETURN_DEGF_ERR_THRES",
+        description="Return air temperature error threshold",
+        unit="°F",
+        type=float,
+        range=(0.0, 10.0),
+    ),
+    InstanceAttribute(
+        name="oat_rat_delta_min",
+        constant_form="OAT_RAT_DELTA_MIN",
+        description="Minimum delta between outdoor and return air temperature",
+        unit="°F",
+        type=float,
+        range=(0.0, 20.0),
+    ),
+    InstanceAttribute(
+        name="ahu_min_oa_dpr",
+        constant_form="AHU_MIN_OA_DPR",
+        description="Minimum outdoor air damper position",
+        unit="fraction",
+        type=float,
+        range=(0.0, 1.0),
+    ),
+]
+
+
+class FaultConditionSix(BaseFaultCondition, FaultConditionMixin):
+    """Class provides the definitions for Fault Condition 6.
+
+    This fault related to knowing the design air flow for
+    ventilation AHU_MIN_CFM_DESIGN which comes from the
+    design mech engineered records where then the fault
+    tries to calculate that based on totalized measured
+    AHU air flow and outside air fraction calc from
+    AHU temp sensors. The fault could flag issues where
+    flow stations are either not in calibration, temp
+    sensors used in the OA frac calc, or possibly the AHU
+    not bringing in design air flow when not operating in
+    economizer free cooling modes.
+
+    py -3.12 -m pytest open_fdd/tests/ahu/test_ahu_fc6.py -rP -s
+    """
+
+    input_columns = INPUT_COLS
+    fault_params = FAULT_PARAMS
+    equation_string = (
+        "fc6_flag = 1 if |OA_frac_calc - OA_min| > airflow_err_thres "
+        "in non-economizer modes, considering htg and mech clg OS \n"
+    )
+    description_string = (
+        "Fault Condition 6: Issues detected with OA fraction calculation or AHU "
+        "not maintaining design air flow in non-economizer conditions \n"
+    )
+    error_string = "One or more required columns are missing or None \n"
+
+    @FaultConditionMixin._handle_errors
+    def apply(self, df: pd.DataFrame) -> pd.DataFrame:
+        """Apply the fault condition to the DataFrame."""
+        # Apply common checks
+        self._apply_common_checks(df)
+
+        # Get column values using accessor methods
+        rat_col = self.get_input_column("rat_col")
+        oat_col = self.get_input_column("oat_col")
+        mat_col = self.get_input_column("mat_col")
+        supply_fan_air_volume_col = self.get_input_column("supply_fan_air_volume_col")
+        supply_vfd_speed_col = self.get_input_column("supply_vfd_speed_col")
+        economizer_sig_col = self.get_input_column("economizer_sig_col")
+        heating_sig_col = self.get_input_column("heating_sig_col")
+        cooling_sig_col = self.get_input_column("cooling_sig_col")
+
+        # Get parameter values using accessor methods
+        airflow_err_thres = self.get_param("airflow_err_thres")
+        ahu_min_oa_cfm_design = self.get_param("ahu_min_oa_cfm_design")
+        oat_rat_delta_min = self.get_param("oat_rat_delta_min")
+        ahu_min_oa_dpr = self.get_param("ahu_min_oa_dpr")
+
+        # Check for zeros in the columns that could lead to division by zero errors
+        cols_to_check = [rat_col, oat_col, supply_fan_air_volume_col]
+        if df[cols_to_check].eq(0).any().any():
+            print(f"Warning: Zero values found in columns: {cols_to_check}")
+            print("This may cause division by zero errors.")
+            sys.stdout.flush()
+
+        # Check analog outputs [data with units of %] are floats only
+        columns_to_check = [
+            supply_vfd_speed_col,
+            economizer_sig_col,
+            heating_sig_col,
+            cooling_sig_col,
+        ]
+        self._apply_analog_checks(df, columns_to_check, check_greater_than_one=True)
+
+        # Calculate intermediate values
+        rat_minus_oat = abs(df[rat_col] - df[oat_col])
+        percent_oa_calc = (df[mat_col] - df[rat_col]) / (df[oat_col] - df[rat_col])
+
+        # Replace negative values in percent_oa_calc with zero using vectorized operation
+        percent_oa_calc = percent_oa_calc.clip(lower=0)
+
+        perc_OAmin = ahu_min_oa_cfm_design / df[supply_fan_air_volume_col]
+        percent_oa_calc_minus_perc_OAmin = abs(percent_oa_calc - perc_OAmin)
+
+        # Combined checks for OS 1 and OS 4 modes
+        os1_htg_mode_check = (
+            (rat_minus_oat >= oat_rat_delta_min)
+            & (percent_oa_calc_minus_perc_OAmin > airflow_err_thres)
+            & (df[heating_sig_col] > 0.0)
+            & (df[supply_vfd_speed_col] > 0.0)
+        )
+
+        os4_clg_mode_check = (
+            (rat_minus_oat >= oat_rat_delta_min)
+            & (percent_oa_calc_minus_perc_OAmin > airflow_err_thres)
+            & (df[heating_sig_col] == 0.0)
+            & (df[cooling_sig_col] > 0.0)
+            & (df[supply_vfd_speed_col] > 0.0)
+            & (df[economizer_sig_col] == ahu_min_oa_dpr)
+        )
+
+        combined_check = os1_htg_mode_check | os4_clg_mode_check
+
+        # Set fault flag
+        self._set_fault_flag(df, combined_check, "fc6_flag")
+
+        return df

open_fdd/air_handling_unit/faults/fault_condition_sixteen.py

@@ -0,0 +1,196 @@
+import numpy as np
+import pandas as pd
+
+from open_fdd.core.base_fault import BaseFaultCondition
+from open_fdd.core.components import FaultInputColumn, InstanceAttribute
+from open_fdd.core.exceptions import InvalidParameterError
+from open_fdd.core.mixins import FaultConditionMixin
+
+INPUT_COLS = [
+    FaultInputColumn(
+        name="erv_oat_enter_col",
+        constant_form="ERV_OAT_ENTER_COL",
+        description="ERV outdoor air entering temperature",
+        unit="°F",
+        required=True,
+        type=float,
+    ),
+    FaultInputColumn(
+        name="erv_oat_leaving_col",
+        constant_form="ERV_OAT_LEAVING_COL",
+        description="ERV outdoor air leaving temperature",
+        unit="°F",
+        required=True,
+        type=float,
+    ),
+    FaultInputColumn(
+        name="erv_eat_enter_col",
+        constant_form="ERV_EAT_ENTER_COL",
+        description="ERV exhaust air entering temperature",
+        unit="°F",
+        required=True,
+        type=float,
+    ),
+    FaultInputColumn(
+        name="erv_eat_leaving_col",
+        constant_form="ERV_EAT_LEAVING_COL",
+        description="ERV exhaust air leaving temperature",
+        unit="°F",
+        required=True,
+        type=float,
+    ),
+    FaultInputColumn(
+        name="supply_vfd_speed_col",
+        constant_form="SUPPLY_VFD_SPEED_COL",
+        description="Supply fan VFD speed",
+        unit="%",
+        required=True,
+        type=float,
+    ),
+]
+
+FAULT_PARAMS = [
+    InstanceAttribute(
+        name="erv_efficiency_min_heating",
+        constant_form="ERV_EFFICIENCY_MIN_HEATING",
+        description="Minimum expected ERV efficiency in heating mode",
+        unit="fraction",
+        type=float,
+        range=(0.0, 1.0),
+    ),
+    InstanceAttribute(
+        name="erv_efficiency_max_heating",
+        constant_form="ERV_EFFICIENCY_MAX_HEATING",
+        description="Maximum expected ERV efficiency in heating mode",
+        unit="fraction",
+        type=float,
+        range=(0.0, 1.0),
+    ),
+    InstanceAttribute(
+        name="erv_efficiency_min_cooling",
+        constant_form="ERV_EFFICIENCY_MIN_COOLING",
+        description="Minimum expected ERV efficiency in cooling mode",
+        unit="fraction",
+        type=float,
+        range=(0.0, 1.0),
+    ),
+    InstanceAttribute(
+        name="erv_efficiency_max_cooling",
+        constant_form="ERV_EFFICIENCY_MAX_COOLING",
+        description="Maximum expected ERV efficiency in cooling mode",
+        unit="fraction",
+        type=float,
+        range=(0.0, 1.0),
+    ),
+    InstanceAttribute(
+        name="oat_low_threshold",
+        constant_form="OAT_LOW_THRESHOLD",
+        description="OAT threshold for heating mode",
+        unit="°F",
+        type=float,
+    ),
+    InstanceAttribute(
+        name="oat_high_threshold",
+        constant_form="OAT_HIGH_THRESHOLD",
+        description="OAT threshold for cooling mode",
+        unit="°F",
+        type=float,
+    ),
+    InstanceAttribute(
+        name="oat_rat_delta_min",
+        constant_form="OAT_RAT_DELTA_MIN",
+        description="Minimum required delta between OAT and RAT",
+        unit="°F",
+        type=float,
+    ),
+]
+
+
+class FaultConditionSixteen(BaseFaultCondition, FaultConditionMixin):
+    """Class provides the definitions for Fault Condition 16.
+    ERV effectiveness should be within specified thresholds based on OAT.
+    This fault checks if the ERV (Energy Recovery Ventilator) is operating
+    within expected efficiency ranges in both heating and cooling modes.
+
+    py -3.12 -m pytest open_fdd/tests/ahu/test_ahu_fc16.py -rP -s
+    """
+
+    input_columns = INPUT_COLS
+    fault_params = FAULT_PARAMS
+    equation_string = (
+        "fc16_flag = 1 if ERV effectiveness is outside expected range "
+        "(heating: εmin_htg ≤ ε ≤ εmax_htg, cooling: εmin_clg ≤ ε ≤ εmax_clg) "
+        "for N consecutive values else 0 \n"
+    )
+    description_string = (
+        "Fault Condition 16: ERV effectiveness should be within specified "
+        "thresholds based on OAT \n"
+    )
+    error_string = "One or more required columns are missing or None \n"
+
+    @FaultConditionMixin._handle_errors
+    def apply(self, df: pd.DataFrame) -> pd.DataFrame:
+        """Apply the fault condition to the DataFrame."""
+        # Apply common checks
+        self._apply_common_checks(df)
+
+        # Get column values using accessor methods
+        supply_vfd_speed_col = self.get_input_column("supply_vfd_speed_col")
+        erv_oat_enter_col = self.get_input_column("erv_oat_enter_col")
+        erv_oat_leaving_col = self.get_input_column("erv_oat_leaving_col")
+        erv_eat_enter_col = self.get_input_column("erv_eat_enter_col")
+
+        # Get parameter values using accessor methods
+        erv_efficiency_min_heating = self.get_param("erv_efficiency_min_heating")
+        erv_efficiency_max_heating = self.get_param("erv_efficiency_max_heating")
+        erv_efficiency_min_cooling = self.get_param("erv_efficiency_min_cooling")
+        erv_efficiency_max_cooling = self.get_param("erv_efficiency_max_cooling")
+        oat_low_threshold = self.get_param("oat_low_threshold")
+        oat_high_threshold = self.get_param("oat_high_threshold")
+        oat_rat_delta_min = self.get_param("oat_rat_delta_min")
+
+        # Check analog outputs [data with units of %] are floats only
+        columns_to_check = [supply_vfd_speed_col]
+        self._apply_analog_checks(df, columns_to_check, check_greater_than_one=True)
+
+        # Calculate temperature differences
+        oat_rat_delta = abs(df[erv_oat_enter_col] - df[erv_eat_enter_col])
+
+        # Calculate ERV effectiveness
+        # ε = (T_leaving - T_entering) / (T_exhaust - T_entering)
+        erv_effectiveness = (df[erv_oat_leaving_col] - df[erv_oat_enter_col]) / (
+            df[erv_eat_enter_col] - df[erv_oat_enter_col]
+        )
+
+        # Determine operating mode based on OAT
+        heating_mode = df[erv_oat_enter_col] < oat_low_threshold
+        cooling_mode = df[erv_oat_enter_col] > oat_high_threshold
+
+        # Check effectiveness against thresholds
+        low_effectiveness_htg = heating_mode & (
+            erv_effectiveness < erv_efficiency_min_heating
+        )
+        high_effectiveness_htg = heating_mode & (
+            erv_effectiveness > erv_efficiency_max_heating
+        )
+        low_effectiveness_clg = cooling_mode & (
+            erv_effectiveness < erv_efficiency_min_cooling
+        )
+        high_effectiveness_clg = cooling_mode & (
+            erv_effectiveness > erv_efficiency_max_cooling
+        )
+
+        # Combine conditions:
+        # Fault occurs when ERV effectiveness is outside expected range
+        # and there's sufficient temperature difference between OAT and RAT
+        combined_check = (oat_rat_delta >= oat_rat_delta_min) & (
+            low_effectiveness_htg
+            | high_effectiveness_htg
+            | low_effectiveness_clg
+            | high_effectiveness_clg
+        )
+
+        # Set fault flag
+        self._set_fault_flag(df, combined_check, "fc16_flag")
+
+        return df

open_fdd/air_handling_unit/faults/fault_condition_ten.py

@@ -0,0 +1,119 @@
+import numpy as np
+import pandas as pd
+
+from open_fdd.core.base_fault import BaseFaultCondition
+from open_fdd.core.components import FaultInputColumn, InstanceAttribute
+from open_fdd.core.exceptions import InvalidParameterError
+from open_fdd.core.mixins import FaultConditionMixin
+
+INPUT_COLS = [
+    FaultInputColumn(
+        name="oat_col",
+        constant_form="OAT_COL",
+        description="Outside air temperature",
+        unit="°F",
+        required=True,
+        type=float,
+    ),
+    FaultInputColumn(
+        name="mat_col",
+        constant_form="MAT_COL",
+        description="Mixed air temperature",
+        unit="°F",
+        required=True,
+        type=float,
+    ),
+    FaultInputColumn(
+        name="cooling_sig_col",
+        constant_form="COOLING_SIG_COL",
+        description="Cooling signal",
+        unit="%",
+        required=True,
+        type=float,
+    ),
+    FaultInputColumn(
+        name="economizer_sig_col",
+        constant_form="ECONOMIZER_SIG_COL",
+        description="Economizer signal",
+        unit="%",
+        required=True,
+        type=float,
+    ),
+]
+
+FAULT_PARAMS = [
+    InstanceAttribute(
+        name="outdoor_degf_err_thres",
+        constant_form="OUTDOOR_DEGF_ERR_THRES",
+        description="Outdoor air temperature error threshold",
+        unit="°F",
+        type=float,
+    ),
+    InstanceAttribute(
+        name="mix_degf_err_thres",
+        constant_form="MIX_DEGF_ERR_THRES",
+        description="Mixed air temperature error threshold",
+        unit="°F",
+        type=float,
+    ),
+]
+
+
+class FaultConditionTen(BaseFaultCondition, FaultConditionMixin):
+    """Class provides the definitions for Fault Condition 10.
+    Outdoor air temperature and mix air temperature should
+    be approx equal in economizer plus mech cooling mode.
+
+    py -3.12 -m pytest open_fdd/tests/ahu/test_ahu_fc10.py -rP -s
+    """
+
+    input_columns = INPUT_COLS
+    fault_params = FAULT_PARAMS
+    equation_string = (
+        "fc10_flag = 1 if |OAT - MAT| > √(εOAT² + εMAT²) in "
+        "economizer + mech cooling mode for N consecutive values else 0 \n"
+    )
+    description_string = (
+        "Fault Condition 10: Outdoor air temperature and mixed air temperature "
+        "should be approximately equal in economizer plus mechanical cooling mode \n"
+    )
+    error_string = "One or more required columns are missing or None \n"
+
+    @FaultConditionMixin._handle_errors
+    def apply(self, df: pd.DataFrame) -> pd.DataFrame:
+        """Apply the fault condition to the DataFrame."""
+        # Apply common checks
+        self._apply_common_checks(df)
+
+        # Get column values using accessor methods
+        oat_col = self.get_input_column("oat_col")
+        mat_col = self.get_input_column("mat_col")
+        cooling_sig_col = self.get_input_column("cooling_sig_col")
+        economizer_sig_col = self.get_input_column("economizer_sig_col")
+
+        # Get parameter values using accessor methods
+        outdoor_degf_err_thres = self.get_param("outdoor_degf_err_thres")
+        mix_degf_err_thres = self.get_param("mix_degf_err_thres")
+
+        # Check analog outputs [data with units of %] are floats only
+        columns_to_check = [
+            economizer_sig_col,
+            cooling_sig_col,
+        ]
+        self._apply_analog_checks(df, columns_to_check, check_greater_than_one=True)
+
+        # Perform calculations
+        abs_mat_minus_oat = abs(df[mat_col] - df[oat_col])
+        mat_oat_sqrted = np.sqrt(mix_degf_err_thres**2 + outdoor_degf_err_thres**2)
+
+        combined_check = (
+            (abs_mat_minus_oat > mat_oat_sqrted)
+            # Verify AHU is running in OS 3 cooling mode with minimum OA
+            & (df[cooling_sig_col] > 0.01)
+            & (df[economizer_sig_col] > 0.9)
+        )
+
+        # Set fault flag
+        self._set_fault_flag(df, combined_check, "fc10_flag")
+
+        return df

open_fdd/air_handling_unit/faults/fault_condition_thirteen.py

@@ -0,0 +1,139 @@
+import pandas as pd
+
+from open_fdd.core.base_fault import BaseFaultCondition
+from open_fdd.core.components import FaultInputColumn, InstanceAttribute
+from open_fdd.core.exceptions import InvalidParameterError
+from open_fdd.core.mixins import FaultConditionMixin
+
+INPUT_COLS = [
+    FaultInputColumn(
+        name="sat_col",
+        constant_form="SAT_COL",
+        description="Supply air temperature",
+        unit="°F",
+        required=True,
+        type=float,
+    ),
+    FaultInputColumn(
+        name="sat_sp_col",
+        constant_form="SAT_SP_COL",
+        description="Supply air temperature setpoint",
+        unit="°F",
+        required=True,
+        type=float,
+    ),
+    FaultInputColumn(
+        name="cooling_sig_col",
+        constant_form="COOLING_SIG_COL",
+        description="Cooling signal",
+        unit="%",
+        required=True,
+        type=float,
+    ),
+    FaultInputColumn(
+        name="economizer_sig_col",
+        constant_form="ECONOMIZER_SIG_COL",
+        description="Economizer signal",
+        unit="%",
+        required=True,
+        type=float,
+    ),
+]
+
+FAULT_PARAMS = [
+    InstanceAttribute(
+        name="supply_degf_err_thres",
+        constant_form="SUPPLY_DEGF_ERR_THRES",
+        description="Supply air temperature error threshold",
+        unit="°F",
+        type=float,
+    ),
+    InstanceAttribute(
+        name="mix_degf_err_thres",
+        constant_form="MIX_DEGF_ERR_THRES",
+        description="Mixed air temperature error threshold",
+        unit="°F",
+        type=float,
+    ),
+    InstanceAttribute(
+        name="outdoor_degf_err_thres",
+        constant_form="OUTDOOR_DEGF_ERR_THRES",
+        description="Outdoor air temperature error threshold",
+        unit="°F",
+        type=float,
+    ),
+    InstanceAttribute(
+        name="ahu_min_oa_dpr",
+        constant_form="AHU_MIN_OA_DPR",
+        description="Minimum outdoor air damper position",
+        unit="fraction",
+        type=float,
+    ),
+]
+
+
+class FaultConditionThirteen(BaseFaultCondition, FaultConditionMixin):
+    """Class provides the definitions for Fault Condition 13.
+    Supply air temperature too high in full cooling mode.
+    This fault checks if SAT is too high compared to SAT setpoint
+    in OS3 (economizer + mechanical cooling) and OS4 (mechanical cooling only) modes.
+
+    py -3.12 -m pytest open_fdd/tests/ahu/test_ahu_fc13.py -rP -s
+    """
+
+    input_columns = INPUT_COLS
+    fault_params = FAULT_PARAMS
+    equation_string = (
+        "fc13_flag = 1 if (SAT > SATSP + εSAT) and "
+        "((CLG > 0.9 and ECO > 0.9) or (CLG > 0.9 and ECO = MIN_OA)) "
+        "for N consecutive values else 0 \n"
+    )
+    description_string = (
+        "Fault Condition 13: Supply air temperature too high in full cooling mode "
+        "in OS3 (economizer + mechanical cooling) and OS4 (mechanical cooling only) modes \n"
+    )
+    error_string = "One or more required columns are missing or None \n"
+
+    @FaultConditionMixin._handle_errors
+    def apply(self, df: pd.DataFrame) -> pd.DataFrame:
+        """Apply the fault condition to the DataFrame."""
+        # Apply common checks
+        self._apply_common_checks(df)
+
+        # Get column values using accessor methods
+        sat_col = self.get_input_column("sat_col")
+        sat_sp_col = self.get_input_column("sat_sp_col")
+        cooling_sig_col = self.get_input_column("cooling_sig_col")
+        economizer_sig_col = self.get_input_column("economizer_sig_col")
+
+        # Get parameter values using accessor methods
+        supply_degf_err_thres = self.get_param("supply_degf_err_thres")
+        ahu_min_oa_dpr = self.get_param("ahu_min_oa_dpr")
+
+        # Check analog outputs [data with units of %] are floats only
+        columns_to_check = [
+            economizer_sig_col,
+            cooling_sig_col,
+        ]
+        self._apply_analog_checks(df, columns_to_check, check_greater_than_one=True)
+
+        # Check if SAT is too high compared to setpoint
+        sat_too_high = df[sat_col] > (df[sat_sp_col] + supply_degf_err_thres)
+
+        # Check operating modes:
+        # OS3: Economizer + full mechanical cooling (ECO > 0.9 and CLG > 0.9)
+        os3_mode = (df[economizer_sig_col] > 0.9) & (df[cooling_sig_col] > 0.9)
+
+        # OS4: Full mechanical cooling only (ECO = MIN_OA and CLG > 0.9)
+        os4_mode = (df[economizer_sig_col] <= ahu_min_oa_dpr) & (
+            df[cooling_sig_col] > 0.9
+        )
+
+        # Combine conditions:
+        # Fault occurs when SAT is too high in either OS3 or OS4 mode with full cooling
+        combined_check = sat_too_high & (os3_mode | os4_mode)
+
+        # Set fault flag
+        self._set_fault_flag(df, combined_check, "fc13_flag")
+
+        return df