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

open_fdd/air_handling_unit/faults/__init__.py

@@ -1,185 +1,89 @@
 import pandas as pd
 import numpy as np
-from open_fdd.air_handling_unit.faults.fault_condition import (
-    FaultCondition,
-    MissingColumnError,
-    InvalidParameterError,
-)
+from open_fdd.core.base_fault import BaseFaultCondition
+from open_fdd.core.mixins import FaultConditionMixin
+from open_fdd.air_handling_unit.faults.helper_utils import SharedUtils
 import operator
 import sys
+from open_fdd.core.exceptions import MissingColumnError, InvalidParameterError
 
 
-class FaultConditionOne(FaultCondition):
+class FaultConditionOne(BaseFaultCondition, FaultConditionMixin):
     """Class provides the definitions for Fault Condition 1.
     AHU low duct static pressure fan fault.
 
     py -3.12 -m pytest open_fdd/tests/ahu/test_ahu_fc1.py -rP -s
     """
 
-    def __init__(self, dict_):
-        super().__init__()
-
-        # Threshold parameters
-        self.vfd_speed_percent_err_thres = dict_.get(
-            "VFD_SPEED_PERCENT_ERR_THRES", None
-        )
-        self.vfd_speed_percent_max = dict_.get("VFD_SPEED_PERCENT_MAX", None)
-        self.duct_static_inches_err_thres = dict_.get(
-            "DUCT_STATIC_INCHES_ERR_THRES", None
-        )
-
-        # Validate that threshold parameters are floats
-        for param, value in [
-            ("vfd_speed_percent_err_thres", self.vfd_speed_percent_err_thres),
-            ("vfd_speed_percent_max", self.vfd_speed_percent_max),
-            ("duct_static_inches_err_thres", self.duct_static_inches_err_thres),
-        ]:
-            if not isinstance(value, float):
-                raise InvalidParameterError(
-                    f"The parameter '{param}' should be a float, but got {type(value).__name__}."
-                )
-
-        # Other attributes
+    def _init_specific_attributes(self, dict_):
+        # Initialize specific attributes
         self.duct_static_col = dict_.get("DUCT_STATIC_COL", None)
         self.supply_vfd_speed_col = dict_.get("SUPPLY_VFD_SPEED_COL", None)
         self.duct_static_setpoint_col = dict_.get("DUCT_STATIC_SETPOINT_COL", None)
-        self.troubleshoot_mode = dict_.get("TROUBLESHOOT_MODE", False)
-        self.rolling_window_size = dict_.get("ROLLING_WINDOW_SIZE", None)
-
-        self.equation_string = (
-            "fc1_flag = 1 if (DSP < DPSP - εDSP) and (VFDSPD >= VFDSPD_max - εVFDSPD) "
-            "for N consecutive values else 0 \n"
+        self.duct_static_inches_err_thres = dict_.get(
+            "DUCT_STATIC_INCHES_ERR_THRES", None
         )
-        self.description_string = (
-            "Fault Condition 1: Duct static too low at fan at full speed \n"
+        self.vfd_speed_percent_max = dict_.get("VFD_SPEED_PERCENT_MAX", None)
+        self.vfd_speed_percent_err_thres = dict_.get(
+            "VFD_SPEED_PERCENT_ERR_THRES", None
         )
-        self.required_column_description = "Required inputs are the duct static pressure, setpoint, and supply fan VFD speed \n"
-        self.error_string = f"One or more required columns are missing or None \n"
-
-        self.set_attributes(dict_)
 
-        # Set required columns specific to this fault condition
+        # Set required columns
         self.required_columns = [
             self.duct_static_col,
             self.supply_vfd_speed_col,
             self.duct_static_setpoint_col,
         ]
 
-        # Check if any of the required columns are None
-        if any(col is None for col in self.required_columns):
-            raise MissingColumnError(
-                f"{self.error_string}"
-                f"{self.equation_string}"
-                f"{self.description_string}"
-                f"{self.required_column_description}"
-                f"{self.required_columns}"
-            )
-
-        # Ensure all required columns are strings
-        self.required_columns = [str(col) for col in self.required_columns]
-
-        self.mapped_columns = (
-            f"Your config dictionary is mapped as: {', '.join(self.required_columns)}"
-        )
-
-    def get_required_columns(self) -> str:
-        """Called from IPython to print out."""
-        return (
-            f"{self.equation_string}"
-            f"{self.description_string}"
-            f"{self.required_column_description}"
-            f"{self.mapped_columns}"
+        # Set documentation strings
+        self.equation_string = "fc1_flag = 1 if (DP < DPSP - εDP) and (VFDSPD >= VFDSPD_max - εVFDSPD) for N consecutive values else 0 \n"
+        self.description_string = (
+            "Fault Condition 1: Duct static too low at fan at full speed \n"
         )
+        self.required_column_description = "Required inputs are the duct static pressure, setpoint, and supply fan VFD speed \n"
+        self.error_string = "One or more required columns are missing or None \n"
 
+    @FaultConditionMixin._handle_errors
     def apply(self, df: pd.DataFrame) -> pd.DataFrame:
-        try:
-            # Ensure all required columns are present
-            self.check_required_columns(df)
-
-            if self.troubleshoot_mode:
-                self.troubleshoot_cols(df)
-
-            # Check analog outputs [data with units of %] are floats only
-            columns_to_check = [self.supply_vfd_speed_col]
-            self.check_analog_pct(df, columns_to_check)
-
-            # Perform checks
-            static_check = (
-                df[self.duct_static_col]
-                < df[self.duct_static_setpoint_col] - self.duct_static_inches_err_thres
-            )
-            fan_check = (
-                df[self.supply_vfd_speed_col]
-                >= self.vfd_speed_percent_max - self.vfd_speed_percent_err_thres
-            )
-
-            # Combined condition check
-            combined_check = static_check & fan_check
+        self._apply_common_checks(df)
+        self._apply_analog_checks(df, [self.supply_vfd_speed_col])
 
-            # Rolling sum to count consecutive trues
-            rolling_sum = combined_check.rolling(window=self.rolling_window_size).sum()
+        # Convert VFD speed from percentage to fraction if needed
+        if (df[self.supply_vfd_speed_col] > 1.0).any():
+            df[self.supply_vfd_speed_col] = df[self.supply_vfd_speed_col] / 100.0
 
-            # Set flag to 1 if rolling sum equals the window size
-            df["fc1_flag"] = (rolling_sum == self.rolling_window_size).astype(int)
+        # Convert thresholds from percentage to fraction
+        vfd_speed_max = self.vfd_speed_percent_max / 100.0
+        vfd_speed_err_thres = self.vfd_speed_percent_err_thres / 100.0
 
-            return df
+        # Specific checks
+        static_check = (
+            df[self.duct_static_col]
+            < df[self.duct_static_setpoint_col] - self.duct_static_inches_err_thres
+        )
+        fan_check = df[self.supply_vfd_speed_col] >= vfd_speed_max - vfd_speed_err_thres
+        combined_check = static_check & fan_check
 
-        except MissingColumnError as e:
-            print(f"Error: {e.message}")
-            sys.stdout.flush()
-            raise e
-        except InvalidParameterError as e:
-            print(f"Error: {e.message}")
-            sys.stdout.flush()
-            raise e
+        self._set_fault_flag(df, combined_check, "fc1_flag")
+        return df
 
 
-class FaultConditionTwo(FaultCondition):
+class FaultConditionTwo(BaseFaultCondition, FaultConditionMixin):
     """Class provides the definitions for Fault Condition 2.
     Mix temperature too low; should be between outside and return air.
     """
 
-    def __init__(self, dict_):
-        super().__init__()
-
-        # Threshold parameters
-        self.mix_degf_err_thres = dict_.get("MIX_DEGF_ERR_THRES", None)
-        self.return_degf_err_thres = dict_.get("RETURN_DEGF_ERR_THRES", None)
-        self.outdoor_degf_err_thres = dict_.get("OUTDOOR_DEGF_ERR_THRES", None)
-
-        # Validate that threshold parameters are floats
-        for param, value in [
-            ("mix_degf_err_thres", self.mix_degf_err_thres),
-            ("return_degf_err_thres", self.return_degf_err_thres),
-            ("outdoor_degf_err_thres", self.outdoor_degf_err_thres),
-        ]:
-            if not isinstance(value, float):
-                raise InvalidParameterError(
-                    f"The parameter '{param}' should be a float, but got {type(value).__name__}."
-                )
-
-        # Other attributes
+    def _init_specific_attributes(self, dict_):
+        # Initialize specific attributes
         self.mat_col = dict_.get("MAT_COL", None)
         self.rat_col = dict_.get("RAT_COL", None)
         self.oat_col = dict_.get("OAT_COL", None)
         self.supply_vfd_speed_col = dict_.get("SUPPLY_VFD_SPEED_COL", None)
-        self.troubleshoot_mode = dict_.get("TROUBLESHOOT_MODE", False)
-        self.rolling_window_size = dict_.get("ROLLING_WINDOW_SIZE", None)
-
-        self.equation_string = (
-            "fc2_flag = 1 if (MAT + εMAT < min(RAT - εRAT, OAT - εOAT)) and (VFDSPD > 0) "
-            "for N consecutive values else 0 \n"
-        )
-        self.description_string = "Fault Condition 2: Mix temperature too low; should be between outside and return air \n"
-        self.required_column_description = (
-            "Required inputs are the mix air temperature, return air temperature, outside air temperature, "
-            "and supply fan VFD speed \n"
-        )
-        self.error_string = "One or more required columns are missing or None \n"
-
-        self.set_attributes(dict_)
+        self.mix_degf_err_thres = dict_.get("MIX_DEGF_ERR_THRES", None)
+        self.outdoor_degf_err_thres = dict_.get("OUTDOOR_DEGF_ERR_THRES", None)
+        self.return_degf_err_thres = dict_.get("RETURN_DEGF_ERR_THRES", None)
 
-        # Set required columns specific to this fault condition
+        # Set required columns
         self.required_columns = [
             self.mat_col,
             self.rat_col,
@@ -187,119 +91,47 @@ class FaultConditionTwo(FaultCondition):
             self.supply_vfd_speed_col,
         ]
 
-        # Check if any of the required columns are None
-        if any(col is None for col in self.required_columns):
-            raise MissingColumnError(
-                f"{self.error_string}"
-                f"{self.equation_string}"
-                f"{self.description_string}"
-                f"{self.required_column_description}"
-                f"{self.required_columns}"
-            )
+        # Set documentation strings
+        self.equation_string = "fc2_flag = 1 if (MAT - εMAT < min(RAT - εRAT, OAT - εOAT)) and (VFDSPD > 0) for N consecutive values else 0 \n"
+        self.description_string = "Fault Condition 2: Mix temperature too low; should be between outside and return air \n"
+        self.required_column_description = "Required inputs are the mixed air temperature, return air temperature, outside air temperature, and supply fan VFD speed \n"
+        self.error_string = "One or more required columns are missing or None \n"
 
-        # Ensure all required columns are strings
-        self.required_columns = [str(col) for col in self.required_columns]
+    @FaultConditionMixin._handle_errors
+    def apply(self, df: pd.DataFrame) -> pd.DataFrame:
+        self._apply_common_checks(df)
+        self._apply_analog_checks(df, [self.supply_vfd_speed_col])
 
-        self.mapped_columns = (
-            f"Your config dictionary is mapped as: {', '.join(self.required_columns)}"
+        # Specific checks
+        mat_check = df[self.mat_col] - self.mix_degf_err_thres
+        temp_min_check = np.minimum(
+            df[self.rat_col] - self.return_degf_err_thres,
+            df[self.oat_col] - self.outdoor_degf_err_thres,
         )
-
-    def get_required_columns(self) -> str:
-        """Returns a string representation of the required columns."""
-        return (
-            f"{self.equation_string}"
-            f"{self.description_string}"
-            f"{self.required_column_description}"
-            f"{self.mapped_columns}"
+        combined_check = (mat_check < temp_min_check) & (
+            df[self.supply_vfd_speed_col] > 0.01
         )
 
-    def apply(self, df: pd.DataFrame) -> pd.DataFrame:
-        try:
-            # Ensure all required columns are present
-            self.check_required_columns(df)
-
-            if self.troubleshoot_mode:
-                self.troubleshoot_cols(df)
-
-            # Check analog outputs [data with units of %] are floats only
-            columns_to_check = [self.supply_vfd_speed_col]
-            self.check_analog_pct(df, columns_to_check)
-
-            # Perform checks
-            mat_check = df[self.mat_col] + self.mix_degf_err_thres
-            temp_min_check = np.minimum(
-                df[self.rat_col] - self.return_degf_err_thres,
-                df[self.oat_col] - self.outdoor_degf_err_thres,
-            )
-
-            combined_check = (mat_check < temp_min_check) & (
-                df[self.supply_vfd_speed_col] > 0.01
-            )
-
-            # Rolling sum to count consecutive trues
-            rolling_sum = combined_check.rolling(window=self.rolling_window_size).sum()
-
-            # Set flag to 1 if rolling sum equals the window size
-            df["fc2_flag"] = (rolling_sum >= self.rolling_window_size).astype(int)
-
-            return df
-
-        except MissingColumnError as e:
-            print(f"Error: {e.message}")
-            sys.stdout.flush()
-            raise e
-        except InvalidParameterError as e:
-            print(f"Error: {e.message}")
-            sys.stdout.flush()
-            raise e
+        self._set_fault_flag(df, combined_check, "fc2_flag")
+        return df
 
 
-class FaultConditionThree(FaultCondition):
+class FaultConditionThree(BaseFaultCondition, FaultConditionMixin):
     """Class provides the definitions for Fault Condition 3.
     Mix temperature too high; should be between outside and return air.
     """
 
-    def __init__(self, dict_):
-        super().__init__()
-
-        # Threshold parameters
-        self.mix_degf_err_thres = dict_.get("MIX_DEGF_ERR_THRES", None)
-        self.return_degf_err_thres = dict_.get("RETURN_DEGF_ERR_THRES", None)
-        self.outdoor_degf_err_thres = dict_.get("OUTDOOR_DEGF_ERR_THRES", None)
-
-        # Validate that threshold parameters are floats
-        for param, value in [
-            ("mix_degf_err_thres", self.mix_degf_err_thres),
-            ("return_degf_err_thres", self.return_degf_err_thres),
-            ("outdoor_degf_err_thres", self.outdoor_degf_err_thres),
-        ]:
-            if not isinstance(value, float):
-                raise InvalidParameterError(
-                    f"The parameter '{param}' should be a float, but got {type(value).__name__}."
-                )
-
-        # Other attributes
+    def _init_specific_attributes(self, dict_):
+        # Initialize specific attributes
         self.mat_col = dict_.get("MAT_COL", None)
         self.rat_col = dict_.get("RAT_COL", None)
         self.oat_col = dict_.get("OAT_COL", None)
         self.supply_vfd_speed_col = dict_.get("SUPPLY_VFD_SPEED_COL", None)
-        self.troubleshoot_mode = dict_.get("TROUBLESHOOT_MODE", False)
-        self.rolling_window_size = dict_.get("ROLLING_WINDOW_SIZE", None)
-
-        self.equation_string = (
-            "fc3_flag = 1 if (MAT - εMAT > max(RAT + εRAT, OAT + εOAT)) and (VFDSPD > 0) "
-            "for N consecutive values else 0 \n"
-        )
-        self.description_string = "Fault Condition 3: Mix temperature too high; should be between outside and return air \n"
-        self.required_column_description = (
-            "Required inputs are the mix air temperature, return air temperature, outside air temperature, "
-            "and supply fan VFD speed \n"
-        )
-        self.error_string = "One or more required columns are missing or None \n"
-
-        self.set_attributes(dict_)
+        self.mix_degf_err_thres = dict_.get("MIX_DEGF_ERR_THRES", None)
+        self.outdoor_degf_err_thres = dict_.get("OUTDOOR_DEGF_ERR_THRES", None)
+        self.return_degf_err_thres = dict_.get("RETURN_DEGF_ERR_THRES", None)
 
-        # Set required columns specific to this fault condition
+        # Set required columns
         self.required_columns = [
             self.mat_col,
             self.rat_col,
@@ -307,74 +139,32 @@ class FaultConditionThree(FaultCondition):
             self.supply_vfd_speed_col,
         ]
 
-        # Check if any of the required columns are None
-        if any(col is None for col in self.required_columns):
-            raise MissingColumnError(
-                f"{self.error_string}"
-                f"{self.equation_string}"
-                f"{self.description_string}"
-                f"{self.required_column_description}"
-                f"{self.required_columns}"
-            )
+        # Set documentation strings
+        self.equation_string = "fc3_flag = 1 if (MAT - εMAT > max(RAT + εRAT, OAT + εOAT)) and (VFDSPD > 0) for N consecutive values else 0 \n"
+        self.description_string = "Fault Condition 3: Mix temperature too high; should be between outside and return air \n"
+        self.required_column_description = "Required inputs are the mixed air temperature, return air temperature, outside air temperature, and supply fan VFD speed \n"
+        self.error_string = "One or more required columns are missing or None \n"
 
-        # Ensure all required columns are strings
-        self.required_columns = [str(col) for col in self.required_columns]
+    @FaultConditionMixin._handle_errors
+    def apply(self, df: pd.DataFrame) -> pd.DataFrame:
+        self._apply_common_checks(df)
+        self._apply_analog_checks(df, [self.supply_vfd_speed_col])
 
-        self.mapped_columns = (
-            f"Your config dictionary is mapped as: {', '.join(self.required_columns)}"
+        # Specific checks
+        mat_check = df[self.mat_col] - self.mix_degf_err_thres
+        temp_max_check = np.maximum(
+            df[self.rat_col] + self.return_degf_err_thres,
+            df[self.oat_col] + self.outdoor_degf_err_thres,
         )
-
-    def get_required_columns(self) -> str:
-        """Returns a string representation of the required columns."""
-        return (
-            f"{self.equation_string}"
-            f"{self.description_string}"
-            f"{self.required_column_description}"
-            f"{self.mapped_columns}"
+        combined_check = (mat_check > temp_max_check) & (
+            df[self.supply_vfd_speed_col] > 0.01
         )
 
-    def apply(self, df: pd.DataFrame) -> pd.DataFrame:
-        try:
-            # Ensure all required columns are present
-            self.check_required_columns(df)
-
-            if self.troubleshoot_mode:
-                self.troubleshoot_cols(df)
-
-            # Check analog outputs [data with units of %] are floats only
-            columns_to_check = [self.supply_vfd_speed_col]
-            self.check_analog_pct(df, columns_to_check)
-
-            # Perform checks
-            mat_check = df[self.mat_col] - self.mix_degf_err_thres
-            temp_max_check = np.maximum(
-                df[self.rat_col] + self.return_degf_err_thres,
-                df[self.oat_col] + self.outdoor_degf_err_thres,
-            )
-
-            combined_check = (mat_check > temp_max_check) & (
-                df[self.supply_vfd_speed_col] > 0.01
-            )
-
-            # Rolling sum to count consecutive trues
-            rolling_sum = combined_check.rolling(window=self.rolling_window_size).sum()
-
-            # Set flag to 1 if rolling sum equals the window size
-            df["fc3_flag"] = (rolling_sum >= self.rolling_window_size).astype(int)
-
-            return df
-
-        except MissingColumnError as e:
-            print(f"Error: {e.message}")
-            sys.stdout.flush()
-            raise e
-        except InvalidParameterError as e:
-            print(f"Error: {e.message}")
-            sys.stdout.flush()
-            raise e
+        self._set_fault_flag(df, combined_check, "fc3_flag")
+        return df
 
 
-class FaultConditionFour(FaultCondition):
+class FaultConditionFour(BaseFaultCondition, FaultConditionMixin):
     """Class provides the definitions for Fault Condition 4.
 
     This fault flags excessive operating states on the AHU
@@ -386,15 +176,12 @@ class FaultConditionFour(FaultCondition):
     py -3.12 -m pytest open_fdd/tests/ahu/test_ahu_fc4.py -rP -s
     """
 
-    def __init__(self, dict_):
-        super().__init__()
-
+    def _init_specific_attributes(self, dict_):
         # Threshold parameters
         self.delta_os_max = dict_.get("DELTA_OS_MAX", None)
         self.ahu_min_oa_dpr = dict_.get("AHU_MIN_OA_DPR", None)
 
         # Validate that delta_os_max can be either a float or an integer
-        # if not isinstance(self.delta_os_max, (float, int)):
         if not isinstance(self.delta_os_max, (int)):
             raise InvalidParameterError(
                 f"The parameter 'delta_os_max' should be an integer data type, but got {type(self.delta_os_max).__name__}."
@@ -411,8 +198,8 @@ class FaultConditionFour(FaultCondition):
         self.heating_sig_col = dict_.get("HEATING_SIG_COL", None)
         self.cooling_sig_col = dict_.get("COOLING_SIG_COL", None)
         self.supply_vfd_speed_col = dict_.get("SUPPLY_VFD_SPEED_COL", None)
-        self.troubleshoot_mode = dict_.get("TROUBLESHOOT_MODE", False)
 
+        # Set documentation strings
         self.equation_string = (
             "fc4_flag = 1 if excessive mode changes (> δOS_max) occur "
             "within an hour across heating, econ, econ+mech, mech clg, and min OA modes \n"
@@ -424,8 +211,6 @@ class FaultConditionFour(FaultCondition):
         )
         self.error_string = "One or more required columns are missing or None \n"
 
-        self.set_attributes(dict_)
-
         # Set required columns, making heating and cooling optional
         self.required_columns = [
             self.economizer_sig_col,
@@ -438,137 +223,48 @@ class FaultConditionFour(FaultCondition):
         if self.cooling_sig_col:
             self.required_columns.append(self.cooling_sig_col)
 
-        # Check if any of the required columns are None
-        if any(col is None for col in self.required_columns):
-            raise MissingColumnError(
-                f"{self.error_string}"
-                f"{self.equation_string}"
-                f"{self.description_string}"
-                f"{self.required_column_description}"
-                f"{self.required_columns}"
-            )
-        # Ensure all required columns are strings
-        self.required_columns = [str(col) for col in self.required_columns]
-
-        self.mapped_columns = (
-            f"Your config dictionary is mapped as: {', '.join(self.required_columns)}"
-        )
-
-    def get_required_columns(self) -> str:
-        """Returns a string representation of the required columns."""
-        return (
-            f"{self.equation_string}"
-            f"{self.description_string}"
-            f"{self.required_column_description}"
-            f"{self.mapped_columns}"
-        )
-
+    @FaultConditionMixin._handle_errors
     def apply(self, df: pd.DataFrame) -> pd.DataFrame:
-        try:
-            # Ensure all required columns are present
-            self.check_required_columns(df)
-
-            # If the optional columns are not present, create them with all values set to 0.0
-            if self.heating_sig_col not in df.columns:
-                df[self.heating_sig_col] = 0.0
-            if self.cooling_sig_col not in df.columns:
-                df[self.cooling_sig_col] = 0.0
-
-            if self.troubleshoot_mode:
-                self.troubleshoot_cols(df)
-
-            # Check analog outputs [data with units of %] are floats only
-            columns_to_check = [
-                self.economizer_sig_col,
-                self.heating_sig_col,
-                self.cooling_sig_col,
-                self.supply_vfd_speed_col,
-            ]
-
-            for col in columns_to_check:
-                self.check_analog_pct(df, [col])
-
-            print("=" * 50)
-            print("Warning: The program is in FC4 and resampling the data")
-            print("to compute AHU OS state changes per hour")
-            print("to flag any hunting issue")
-            print("and this usually takes a while to run...")
-            print("=" * 50)
-
-            sys.stdout.flush()
-
-            # AHU htg only mode based on OA damper @ min oa and only htg pid/vlv modulating
-            df["heating_mode"] = (
-                (df[self.heating_sig_col] > 0)
-                & (df[self.cooling_sig_col] == 0)
-                & (df[self.supply_vfd_speed_col] > 0)
-                & (df[self.economizer_sig_col] == self.ahu_min_oa_dpr)
-            )
-
-            # AHU econ only mode based on OA damper modulating and clg htg = zero
-            df["econ_only_cooling_mode"] = (
-                (df[self.heating_sig_col] == 0)
-                & (df[self.cooling_sig_col] == 0)
-                & (df[self.supply_vfd_speed_col] > 0)
-                & (df[self.economizer_sig_col] > self.ahu_min_oa_dpr)
-            )
-
-            # AHU econ+mech clg mode based on OA damper modulating for cooling and clg pid/vlv modulating
-            df["econ_plus_mech_cooling_mode"] = (
-                (df[self.heating_sig_col] == 0)
-                & (df[self.cooling_sig_col] > 0)
-                & (df[self.supply_vfd_speed_col] > 0)
-                & (df[self.economizer_sig_col] > self.ahu_min_oa_dpr)
-            )
-
-            # AHU mech mode based on OA damper @ min OA and clg pid/vlv modulating
-            df["mech_cooling_only_mode"] = (
-                (df[self.heating_sig_col] == 0)
-                & (df[self.cooling_sig_col] > 0)
-                & (df[self.supply_vfd_speed_col] > 0)
-                & (df[self.economizer_sig_col] == self.ahu_min_oa_dpr)
-            )
-
-            # AHU minimum OA mode without heating or cooling (ventilation mode)
-            df["min_oa_mode_only"] = (
-                (df[self.heating_sig_col] == 0)
-                & (df[self.cooling_sig_col] == 0)
-                & (df[self.supply_vfd_speed_col] > 0)
-                & (df[self.economizer_sig_col] == self.ahu_min_oa_dpr)
-            )
-
-            # Fill non-finite values with zero or drop them
-            df = df.fillna(0)
+        """Apply the fault condition to the DataFrame."""
+        # Apply common checks
+        self._apply_common_checks(df)
+        # Add analog checks for supply_vfd_speed_col
+        self._apply_analog_checks(df, [self.supply_vfd_speed_col])
+
+        # Convert VFD speed from percentage to fraction if needed
+        if (df[self.supply_vfd_speed_col] > 1.0).any():
+            df[self.supply_vfd_speed_col] = df[self.supply_vfd_speed_col] / 100.0
+
+        # Calculate operating state changes
+        df["os_change"] = 0
+        df.loc[df[self.economizer_sig_col] > 0, "os_change"] += 1
+        df.loc[df[self.supply_vfd_speed_col] > self.ahu_min_oa_dpr, "os_change"] += 1
+        if self.heating_sig_col:
+            df.loc[df[self.heating_sig_col] > 0, "os_change"] += 1
+        if self.cooling_sig_col:
+            df.loc[df[self.cooling_sig_col] > 0, "os_change"] += 1
 
-            df = df.astype(int)
-            df = df.resample("60min").apply(lambda x: (x.eq(1) & x.shift().ne(1)).sum())
+        # Calculate changes in operating state
+        df["os_change_diff"] = df["os_change"].diff().abs()
+        df["os_change_diff"] = df["os_change_diff"].fillna(0)
 
-            df["fc4_flag"] = (
-                df[df.columns].gt(self.delta_os_max).any(axis=1).astype(int)
-            )
+        # Calculate rolling sum of changes
+        df["os_change_sum"] = df["os_change_diff"].rolling(window=60).sum()
 
-            return df
+        # Set fault flag
+        df["fc4_flag"] = (df["os_change_sum"] > self.delta_os_max).astype(int)
 
-        except MissingColumnError as e:
-            print(f"Error: {e.message}")
-            sys.stdout.flush()
-            raise e
-        except InvalidParameterError as e:
-            print(f"Error: {e.message}")
-            sys.stdout.flush()
-            raise e
+        return df
 
 
-class FaultConditionFive(FaultCondition):
+class FaultConditionFive(BaseFaultCondition, FaultConditionMixin):
     """Class provides the definitions for Fault Condition 5.
     SAT too low; should be higher than MAT in HTG MODE
     --Broken heating valve or other mechanical issue
     related to heat valve not working as designed
     """
 
-    def __init__(self, dict_):
-        super().__init__()
-
+    def _init_specific_attributes(self, dict_):
         # Threshold parameters
         self.mix_degf_err_thres = dict_.get("MIX_DEGF_ERR_THRES", None)
         self.supply_degf_err_thres = dict_.get("SUPPLY_DEGF_ERR_THRES", None)
@@ -590,9 +286,8 @@ class FaultConditionFive(FaultCondition):
         self.sat_col = dict_.get("SAT_COL", None)
         self.heating_sig_col = dict_.get("HEATING_SIG_COL", None)
         self.supply_vfd_speed_col = dict_.get("SUPPLY_VFD_SPEED_COL", None)
-        self.troubleshoot_mode = dict_.get("TROUBLESHOOT_MODE", False)
-        self.rolling_window_size = dict_.get("ROLLING_WINDOW_SIZE", None)
 
+        # Set documentation strings
         self.equation_string = (
             "fc5_flag = 1 if (SAT + εSAT <= MAT - εMAT + ΔT_supply_fan) and "
             "(heating signal > 0) and (VFDSPD > 0) for N consecutive values else 0 \n"
@@ -607,8 +302,6 @@ class FaultConditionFive(FaultCondition):
         )
         self.error_string = "One or more required columns are missing or None \n"
 
-        self.set_attributes(dict_)
-
         # Set required columns specific to this fault condition
         self.required_columns = [
             self.mat_col,
@@ -617,72 +310,33 @@ class FaultConditionFive(FaultCondition):
             self.supply_vfd_speed_col,
         ]
 
-        # Check if any of the required columns are None
-        if any(col is None for col in self.required_columns):
-            raise MissingColumnError(
-                f"{self.error_string}"
-                f"{self.equation_string}"
-                f"{self.description_string}"
-                f"{self.required_column_description}"
-                f"{self.required_columns}"
-            )
-
-        # Ensure all required columns are strings
-        self.required_columns = [str(col) for col in self.required_columns]
-
-        self.mapped_columns = (
-            f"Your config dictionary is mapped as: {', '.join(self.required_columns)}"
-        )
-
-    def get_required_columns(self) -> str:
-        """Returns a string representation of the required columns."""
-        return (
-            f"{self.equation_string}"
-            f"{self.description_string}"
-            f"{self.required_column_description}"
-            f"{self.mapped_columns}"
-        )
-
+    @FaultConditionMixin._handle_errors
     def apply(self, df: pd.DataFrame) -> pd.DataFrame:
-        try:
-            # Ensure all required columns are present
-            self.check_required_columns(df)
-
-            # Check analog outputs [data with units of %] are floats only
-            columns_to_check = [self.supply_vfd_speed_col, self.heating_sig_col]
-            self.check_analog_pct(df, columns_to_check)
-
-            # Perform checks
-            sat_check = df[self.sat_col] + self.supply_degf_err_thres
-            mat_check = (
-                df[self.mat_col] - self.mix_degf_err_thres + self.delta_t_supply_fan
-            )
+        """Apply the fault condition to the DataFrame."""
+        # Apply common checks
+        self._apply_common_checks(df)
 
-            combined_check = (
-                (sat_check <= mat_check)
-                & (df[self.heating_sig_col] > 0.01)
-                & (df[self.supply_vfd_speed_col] > 0.01)
-            )
+        # Check analog outputs [data with units of %] are floats only
+        columns_to_check = [self.supply_vfd_speed_col, self.heating_sig_col]
+        self._apply_analog_checks(df, columns_to_check)
 
-            # Rolling sum to count consecutive trues
-            rolling_sum = combined_check.rolling(window=self.rolling_window_size).sum()
+        # Perform checks
+        sat_check = df[self.sat_col] + self.supply_degf_err_thres
+        mat_check = df[self.mat_col] - self.mix_degf_err_thres + self.delta_t_supply_fan
 
-            # Set flag to 1 if rolling sum equals the window size
-            df["fc5_flag"] = (rolling_sum == self.rolling_window_size).astype(int)
+        combined_check = (
+            (sat_check <= mat_check)
+            & (df[self.heating_sig_col] > 0.01)
+            & (df[self.supply_vfd_speed_col] > 0.01)
+        )
 
-            return df
+        # Set fault flag
+        self._set_fault_flag(df, combined_check, "fc5_flag")
 
-        except MissingColumnError as e:
-            print(f"Error: {e.message}")
-            sys.stdout.flush()
-            raise e
-        except InvalidParameterError as e:
-            print(f"Error: {e.message}")
-            sys.stdout.flush()
-            raise e
+        return df
 
 
-class FaultConditionSix(FaultCondition):
+class FaultConditionSix(BaseFaultCondition, FaultConditionMixin):
     """Class provides the definitions for Fault Condition 6.
 
     This fault related to knowing the design air flow for
@@ -699,9 +353,7 @@ class FaultConditionSix(FaultCondition):
     py -3.12 -m pytest open_fdd/tests/ahu/test_ahu_fc6.py -rP -s
     """
 
-    def __init__(self, dict_):
-        super().__init__()
-
+    def _init_specific_attributes(self, dict_):
         # Threshold parameters
         self.airflow_err_thres = dict_.get("AIRFLOW_ERR_THRES", None)
         self.ahu_min_oa_cfm_design = dict_.get("AHU_MIN_OA_CFM_DESIGN", None)
@@ -737,9 +389,8 @@ class FaultConditionSix(FaultCondition):
         self.economizer_sig_col = dict_.get("ECONOMIZER_SIG_COL", None)
         self.heating_sig_col = dict_.get("HEATING_SIG_COL", None)
         self.cooling_sig_col = dict_.get("COOLING_SIG_COL", None)
-        self.troubleshoot_mode = dict_.get("TROUBLESHOOT_MODE", False)
-        self.rolling_window_size = dict_.get("ROLLING_WINDOW_SIZE", None)
 
+        # Set documentation strings
         self.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"
@@ -755,8 +406,6 @@ class FaultConditionSix(FaultCondition):
         )
         self.error_string = "One or more required columns are missing or None \n"
 
-        self.set_attributes(dict_)
-
         # Set required columns specific to this fault condition
         self.required_columns = [
             self.supply_fan_air_volume_col,
@@ -769,96 +418,66 @@ class FaultConditionSix(FaultCondition):
             self.cooling_sig_col,
         ]
 
-        # Check if any of the required columns are None
-        if any(col is None for col in self.required_columns):
-            raise MissingColumnError(
-                f"{self.error_string}"
-                f"{self.equation_string}"
-                f"{self.description_string}"
-                f"{self.required_column_description}"
-                f"{self.required_columns}"
-            )
-
-        # Ensure all required columns are strings
-        self.required_columns = [str(col) for col in self.required_columns]
-
-        self.mapped_columns = (
-            f"Your config dictionary is mapped as: {', '.join(self.required_columns)}"
-        )
-
-    def get_required_columns(self) -> str:
-        """Returns a string representation of the required columns."""
-        return (
-            f"{self.equation_string}"
-            f"{self.description_string}"
-            f"{self.required_column_description}"
-            f"{self.mapped_columns}"
-        )
-
+    @FaultConditionMixin._handle_errors
     def apply(self, df: pd.DataFrame) -> pd.DataFrame:
-        try:
-            # Ensure all required columns are present
-            self.check_required_columns(df)
-
-            # Check analog outputs [data with units of %] are floats only
-            columns_to_check = [
-                self.supply_vfd_speed_col,
-                self.economizer_sig_col,
-                self.heating_sig_col,
-                self.cooling_sig_col,
-            ]
-            self.check_analog_pct(df, columns_to_check)
-
-            # Calculate intermediate values
-            rat_minus_oat = abs(df[self.rat_col] - df[self.oat_col])
-            percent_oa_calc = (df[self.mat_col] - df[self.rat_col]) / (
-                df[self.oat_col] - df[self.rat_col]
-            )
+        """Apply the fault condition to the DataFrame."""
+        # Apply common checks
+        self._apply_common_checks(df)
+
+        # Check for zeros in the columns that could lead to division by zero errors
+        cols_to_check = [self.rat_col, self.oat_col, self.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()
 
-            # Replace negative values in percent_oa_calc with zero using vectorized operation
-            percent_oa_calc = percent_oa_calc.clip(lower=0)
+        # Check analog outputs [data with units of %] are floats only
+        columns_to_check = [
+            self.supply_vfd_speed_col,
+            self.economizer_sig_col,
+            self.heating_sig_col,
+            self.cooling_sig_col,
+        ]
+        self._apply_analog_checks(df, columns_to_check)
 
-            perc_OAmin = self.ahu_min_oa_cfm_design / df[self.supply_fan_air_volume_col]
-            percent_oa_calc_minus_perc_OAmin = abs(percent_oa_calc - perc_OAmin)
+        # Calculate intermediate values
+        rat_minus_oat = abs(df[self.rat_col] - df[self.oat_col])
+        percent_oa_calc = (df[self.mat_col] - df[self.rat_col]) / (
+            df[self.oat_col] - df[self.rat_col]
+        )
 
-            # Combined checks for OS 1 and OS 4 modes
-            os1_htg_mode_check = (
-                (rat_minus_oat >= self.oat_rat_delta_min)
-                & (percent_oa_calc_minus_perc_OAmin > self.airflow_err_thres)
-                & (df[self.heating_sig_col] > 0.0)
-                & (df[self.supply_vfd_speed_col] > 0.0)
-            )
+        # Replace negative values in percent_oa_calc with zero using vectorized operation
+        percent_oa_calc = percent_oa_calc.clip(lower=0)
 
-            os4_clg_mode_check = (
-                (rat_minus_oat >= self.oat_rat_delta_min)
-                & (percent_oa_calc_minus_perc_OAmin > self.airflow_err_thres)
-                & (df[self.heating_sig_col] == 0.0)
-                & (df[self.cooling_sig_col] > 0.0)
-                & (df[self.supply_vfd_speed_col] > 0.0)
-                & (df[self.economizer_sig_col] == self.ahu_min_oa_dpr)
-            )
+        perc_OAmin = self.ahu_min_oa_cfm_design / df[self.supply_fan_air_volume_col]
+        percent_oa_calc_minus_perc_OAmin = abs(percent_oa_calc - perc_OAmin)
 
-            combined_check = os1_htg_mode_check | os4_clg_mode_check
+        # Combined checks for OS 1 and OS 4 modes
+        os1_htg_mode_check = (
+            (rat_minus_oat >= self.oat_rat_delta_min)
+            & (percent_oa_calc_minus_perc_OAmin > self.airflow_err_thres)
+            & (df[self.heating_sig_col] > 0.0)
+            & (df[self.supply_vfd_speed_col] > 0.0)
+        )
 
-            # Rolling sum to count consecutive trues
-            rolling_sum = combined_check.rolling(window=self.rolling_window_size).sum()
+        os4_clg_mode_check = (
+            (rat_minus_oat >= self.oat_rat_delta_min)
+            & (percent_oa_calc_minus_perc_OAmin > self.airflow_err_thres)
+            & (df[self.heating_sig_col] == 0.0)
+            & (df[self.cooling_sig_col] > 0.0)
+            & (df[self.supply_vfd_speed_col] > 0.0)
+            & (df[self.economizer_sig_col] == self.ahu_min_oa_dpr)
+        )
 
-            # Set flag to 1 if rolling sum equals the window size
-            df["fc6_flag"] = (rolling_sum == self.rolling_window_size).astype(int)
+        combined_check = os1_htg_mode_check | os4_clg_mode_check
 
-            return df
+        # Set fault flag
+        self._set_fault_flag(df, combined_check, "fc6_flag")
 
-        except MissingColumnError as e:
-            print(f"Error: {e.message}")
-            sys.stdout.flush()
-            raise e
-        except InvalidParameterError as e:
-            print(f"Error: {e.message}")
-            sys.stdout.flush()
-            raise e
+        return df
 
 
-class FaultConditionSeven(FaultCondition):
+class FaultConditionSeven(BaseFaultCondition, FaultConditionMixin):
     """Class provides the definitions for Fault Condition 7.
     Very similar to FC 13 but uses heating valve.
     Supply air temperature too low in full heating.
@@ -866,9 +485,7 @@ class FaultConditionSeven(FaultCondition):
     py -3.12 -m pytest open_fdd/tests/ahu/test_ahu_fc7.py -rP -s
     """
 
-    def __init__(self, dict_):
-        super().__init__()
-
+    def _init_specific_attributes(self, dict_):
         # Threshold parameters
         self.supply_degf_err_thres = dict_.get("SUPPLY_DEGF_ERR_THRES", None)
 
@@ -883,9 +500,8 @@ class FaultConditionSeven(FaultCondition):
         self.sat_setpoint_col = dict_.get("SAT_SETPOINT_COL", None)
         self.heating_sig_col = dict_.get("HEATING_SIG_COL", None)
         self.supply_vfd_speed_col = dict_.get("SUPPLY_VFD_SPEED_COL", None)
-        self.troubleshoot_mode = dict_.get("TROUBLESHOOT_MODE", False)
-        self.rolling_window_size = dict_.get("ROLLING_WINDOW_SIZE", None)
 
+        # Set documentation strings
         self.equation_string = (
             "fc7_flag = 1 if SAT < (SATSP - εSAT) in full heating mode "
             "and VFD speed > 0 for N consecutive values else 0 \n"
@@ -900,8 +516,6 @@ class FaultConditionSeven(FaultCondition):
         )
         self.error_string = "One or more required columns are missing or None \n"
 
-        self.set_attributes(dict_)
-
         # Set required columns specific to this fault condition
         self.required_columns = [
             self.sat_col,
@@ -910,69 +524,32 @@ class FaultConditionSeven(FaultCondition):
             self.supply_vfd_speed_col,
         ]
 
-        # Check if any of the required columns are None
-        if any(col is None for col in self.required_columns):
-            raise MissingColumnError(
-                f"{self.error_string}"
-                f"{self.equation_string}"
-                f"{self.description_string}"
-                f"{self.required_column_description}"
-                f"{self.required_columns}"
-            )
-
-        # Ensure all required columns are strings
-        self.required_columns = [str(col) for col in self.required_columns]
-
-        self.mapped_columns = (
-            f"Your config dictionary is mapped as: {', '.join(self.required_columns)}"
-        )
-
-    def get_required_columns(self) -> str:
-        """Returns a string representation of the required columns."""
-        return (
-            f"{self.equation_string}"
-            f"{self.description_string}"
-            f"{self.required_column_description}"
-            f"{self.mapped_columns}"
-        )
-
+    @FaultConditionMixin._handle_errors
     def apply(self, df: pd.DataFrame) -> pd.DataFrame:
-        try:
-            # Ensure all required columns are present
-            self.check_required_columns(df)
+        """Apply the fault condition to the DataFrame."""
+        # Apply common checks
+        self._apply_common_checks(df)
 
-            # Check analog outputs [data with units of %] are floats only
-            columns_to_check = [self.supply_vfd_speed_col, self.heating_sig_col]
-            self.check_analog_pct(df, columns_to_check)
+        # Check analog outputs [data with units of %] are floats only
+        columns_to_check = [self.supply_vfd_speed_col, self.heating_sig_col]
+        self._apply_analog_checks(df, columns_to_check)
 
-            # Perform checks
-            sat_check = df[self.sat_setpoint_col] - self.supply_degf_err_thres
+        # Perform checks
+        sat_check = df[self.sat_setpoint_col] - self.supply_degf_err_thres
 
-            combined_check = (
-                (df[self.sat_col] < sat_check)
-                & (df[self.heating_sig_col] > 0.9)
-                & (df[self.supply_vfd_speed_col] > 0)
-            )
-
-            # Rolling sum to count consecutive trues
-            rolling_sum = combined_check.rolling(window=self.rolling_window_size).sum()
-
-            # Set flag to 1 if rolling sum equals the window size
-            df["fc7_flag"] = (rolling_sum >= self.rolling_window_size).astype(int)
+        combined_check = (
+            (df[self.sat_col] < sat_check)
+            & (df[self.heating_sig_col] > 0.9)
+            & (df[self.supply_vfd_speed_col] > 0)
+        )
 
-            return df
+        # Set fault flag
+        self._set_fault_flag(df, combined_check, "fc7_flag")
 
-        except MissingColumnError as e:
-            print(f"Error: {e.message}")
-            sys.stdout.flush()
-            raise e
-        except InvalidParameterError as e:
-            print(f"Error: {e.message}")
-            sys.stdout.flush()
-            raise e
+        return df
 
 
-class FaultConditionEight(FaultCondition):
+class FaultConditionEight(BaseFaultCondition, FaultConditionMixin):
     """Class provides the definitions for Fault Condition 8.
     Supply air temperature and mix air temperature should
     be approx equal in economizer mode.
@@ -980,9 +557,7 @@ class FaultConditionEight(FaultCondition):
     py -3.12 -m pytest open_fdd/tests/ahu/test_ahu_fc8.py -rP -s
     """
 
-    def __init__(self, dict_):
-        super().__init__()
-
+    def _init_specific_attributes(self, dict_):
         # Threshold parameters
         self.delta_t_supply_fan = dict_.get("DELTA_T_SUPPLY_FAN", None)
         self.mix_degf_err_thres = dict_.get("MIX_DEGF_ERR_THRES", None)
@@ -1006,9 +581,8 @@ class FaultConditionEight(FaultCondition):
         self.sat_col = dict_.get("SAT_COL", None)
         self.economizer_sig_col = dict_.get("ECONOMIZER_SIG_COL", None)
         self.cooling_sig_col = dict_.get("COOLING_SIG_COL", None)
-        self.troubleshoot_mode = dict_.get("TROUBLESHOOT_MODE", False)
-        self.rolling_window_size = dict_.get("ROLLING_WINDOW_SIZE", None)
 
+        # Set documentation strings
         self.equation_string = (
             "fc8_flag = 1 if |SAT - MAT - ΔT_fan| > √(εSAT² + εMAT²) "
             "in economizer mode for N consecutive values else 0 \n"
@@ -1059,51 +633,42 @@ class FaultConditionEight(FaultCondition):
             f"{self.mapped_columns}"
         )
 
+    @FaultConditionMixin._handle_errors
     def apply(self, df: pd.DataFrame) -> pd.DataFrame:
-        try:
-            # Ensure all required columns are present
-            self.check_required_columns(df)
-
-            # Check analog outputs [data with units of %] are floats only
-            columns_to_check = [
-                self.economizer_sig_col,
-                self.cooling_sig_col,
-            ]
-            self.check_analog_pct(df, columns_to_check)
-
-            # Perform checks
-            sat_fan_mat = abs(
-                df[self.sat_col] - self.delta_t_supply_fan - df[self.mat_col]
-            )
-            sat_mat_sqrted = np.sqrt(
-                self.supply_degf_err_thres**2 + self.mix_degf_err_thres**2
-            )
+        """Apply the fault condition to the DataFrame."""
+        # Apply common checks
+        self._apply_common_checks(df)
 
-            combined_check = (
-                (sat_fan_mat > sat_mat_sqrted)
-                & (df[self.economizer_sig_col] > self.ahu_min_oa_dpr)
-                & (df[self.cooling_sig_col] < 0.1)
-            )
+        # Check analog outputs [data with units of %] are floats only
+        columns_to_check = [
+            self.economizer_sig_col,
+            self.cooling_sig_col,
+        ]
+        self._apply_analog_checks(df, columns_to_check)
 
-            # Rolling sum to count consecutive trues
-            rolling_sum = combined_check.rolling(window=self.rolling_window_size).sum()
+        # Perform checks
+        sat_fan_mat = abs(df[self.sat_col] - self.delta_t_supply_fan - df[self.mat_col])
+        sat_mat_sqrted = np.sqrt(
+            self.supply_degf_err_thres**2 + self.mix_degf_err_thres**2
+        )
 
-            # Set flag to 1 if rolling sum equals the window size
-            df["fc8_flag"] = (rolling_sum >= self.rolling_window_size).astype(int)
+        combined_check = (
+            (sat_fan_mat > sat_mat_sqrted)
+            # Verify AHU is running in OS 3 cooling mode with minimum OA
+            & (df[self.economizer_sig_col] > self.ahu_min_oa_dpr)
+            & (df[self.cooling_sig_col] < 0.1)
+        )
 
-            return df
+        # Rolling sum to count consecutive trues
+        rolling_sum = combined_check.rolling(window=self.rolling_window_size).sum()
 
-        except MissingColumnError as e:
-            print(f"Error: {e.message}")
-            sys.stdout.flush()
-            raise e
-        except InvalidParameterError as e:
-            print(f"Error: {e.message}")
-            sys.stdout.flush()
-            raise e
+        # Set flag to 1 if rolling sum equals the window size
+        df["fc8_flag"] = (rolling_sum >= self.rolling_window_size).astype(int)
+
+        return df
 
 
-class FaultConditionNine(FaultCondition):
+class FaultConditionNine(BaseFaultCondition, FaultConditionMixin):
     """Class provides the definitions for Fault Condition 9.
     Outside air temperature too high in free cooling without
     additional mechanical cooling in economizer mode.
@@ -1111,9 +676,7 @@ class FaultConditionNine(FaultCondition):
     py -3.12 -m pytest open_fdd/tests/ahu/test_ahu_fc9.py -rP -s
     """
 
-    def __init__(self, dict_):
-        super().__init__()
-
+    def _init_specific_attributes(self, dict_):
         # Threshold parameters
         self.delta_t_supply_fan = dict_.get("DELTA_T_SUPPLY_FAN", None)
         self.outdoor_degf_err_thres = dict_.get("OUTDOOR_DEGF_ERR_THRES", None)
@@ -1137,9 +700,8 @@ class FaultConditionNine(FaultCondition):
         self.oat_col = dict_.get("OAT_COL", None)
         self.cooling_sig_col = dict_.get("COOLING_SIG_COL", None)
         self.economizer_sig_col = dict_.get("ECONOMIZER_SIG_COL", None)
-        self.troubleshoot_mode = dict_.get("TROUBLESHOOT_MODE", False)
-        self.rolling_window_size = dict_.get("ROLLING_WINDOW_SIZE", None)
 
+        # Set documentation strings
         self.equation_string = (
             "fc9_flag = 1 if OAT > (SATSP - ΔT_fan + εSAT) "
             "in free cooling mode for N consecutive values else 0 \n"
@@ -1154,8 +716,6 @@ class FaultConditionNine(FaultCondition):
         )
         self.error_string = "One or more required columns are missing or None \n"
 
-        self.set_attributes(dict_)
-
         # Set required columns specific to this fault condition
         self.required_columns = [
             self.sat_setpoint_col,
@@ -1164,78 +724,41 @@ class FaultConditionNine(FaultCondition):
             self.economizer_sig_col,
         ]
 
-        # Check if any of the required columns are None
-        if any(col is None for col in self.required_columns):
-            raise MissingColumnError(
-                f"{self.error_string}"
-                f"{self.equation_string}"
-                f"{self.description_string}"
-                f"{self.required_column_description}"
-                f"{self.required_columns}"
-            )
+    @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)
 
-        # Ensure all required columns are strings
-        self.required_columns = [str(col) for col in self.required_columns]
+        # Check analog outputs [data with units of %] are floats only
+        columns_to_check = [
+            self.economizer_sig_col,
+            self.cooling_sig_col,
+        ]
+        self._apply_analog_checks(df, columns_to_check)
 
-        self.mapped_columns = (
-            f"Your config dictionary is mapped as: {', '.join(self.required_columns)}"
+        # Perform calculations
+        oat_minus_oaterror = df[self.oat_col] - self.outdoor_degf_err_thres
+        satsp_delta_saterr = (
+            df[self.sat_setpoint_col]
+            - self.delta_t_supply_fan
+            + self.supply_degf_err_thres
         )
 
-    def get_required_columns(self) -> str:
-        """Returns a string representation of the required columns."""
-        return (
-            f"{self.equation_string}"
-            f"{self.description_string}"
-            f"{self.required_column_description}"
-            f"{self.mapped_columns}"
+        combined_check = (
+            (oat_minus_oaterror > satsp_delta_saterr)
+            # verify AHU is in OS2 only free cooling mode
+            & (df[self.economizer_sig_col] > self.ahu_min_oa_dpr)
+            & (df[self.cooling_sig_col] < 0.1)
         )
 
-    def apply(self, df: pd.DataFrame) -> pd.DataFrame:
-        try:
-            # Ensure all required columns are present
-            self.check_required_columns(df)
-
-            # Check analog outputs [data with units of %] are floats only
-            columns_to_check = [
-                self.economizer_sig_col,
-                self.cooling_sig_col,
-            ]
-            self.check_analog_pct(df, columns_to_check)
-
-            # Perform calculations
-            oat_minus_oaterror = df[self.oat_col] - self.outdoor_degf_err_thres
-            satsp_delta_saterr = (
-                df[self.sat_setpoint_col]
-                - self.delta_t_supply_fan
-                + self.supply_degf_err_thres
-            )
-
-            combined_check = (
-                (oat_minus_oaterror > satsp_delta_saterr)
-                # verify AHU is in OS2 only free cooling mode
-                & (df[self.economizer_sig_col] > self.ahu_min_oa_dpr)
-                & (df[self.cooling_sig_col] < 0.1)
-            )
+        # Set fault flag
+        self._set_fault_flag(df, combined_check, "fc9_flag")
 
-            # Rolling sum to count consecutive trues
-            rolling_sum = combined_check.rolling(window=self.rolling_window_size).sum()
-
-            # Set flag to 1 if rolling sum equals the window size
-            df["fc9_flag"] = (rolling_sum >= self.rolling_window_size).astype(int)
-
-            return df
-
-        except MissingColumnError as e:
-            print(f"Error: {e.message}")
-            sys.stdout.flush()
-            raise e
-        except InvalidParameterError as e:
-            print(f"Error: {e.message}")
-            sys.stdout.flush()
-            raise e
+        return df
 
 
-class FaultConditionTen(FaultCondition):
+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.
@@ -1243,9 +766,7 @@ class FaultConditionTen(FaultCondition):
     py -3.12 -m pytest open_fdd/tests/ahu/test_ahu_fc10.py -rP -s
     """
 
-    def __init__(self, dict_):
-        super().__init__()
-
+    def _init_specific_attributes(self, dict_):
         # Threshold parameters
         self.outdoor_degf_err_thres = dict_.get("OUTDOOR_DEGF_ERR_THRES", None)
         self.mix_degf_err_thres = dict_.get("MIX_DEGF_ERR_THRES", None)
@@ -1265,9 +786,8 @@ class FaultConditionTen(FaultCondition):
         self.mat_col = dict_.get("MAT_COL", None)
         self.cooling_sig_col = dict_.get("COOLING_SIG_COL", None)
         self.economizer_sig_col = dict_.get("ECONOMIZER_SIG_COL", None)
-        self.troubleshoot_mode = dict_.get("TROUBLESHOOT_MODE", False)
-        self.rolling_window_size = dict_.get("ROLLING_WINDOW_SIZE", None)
 
+        # Set documentation strings
         self.equation_string = (
             "fc10_flag = 1 if |OAT - MAT| > √(εOAT² + εMAT²) in "
             "economizer + mech cooling mode for N consecutive values else 0 \n"
@@ -1282,8 +802,6 @@ class FaultConditionTen(FaultCondition):
         )
         self.error_string = "One or more required columns are missing or None \n"
 
-        self.set_attributes(dict_)
-
         # Set required columns specific to this fault condition
         self.required_columns = [
             self.oat_col,
@@ -1292,97 +810,55 @@ class FaultConditionTen(FaultCondition):
             self.economizer_sig_col,
         ]
 
-        # Check if any of the required columns are None
-        if any(col is None for col in self.required_columns):
-            raise MissingColumnError(
-                f"{self.error_string}"
-                f"{self.equation_string}"
-                f"{self.description_string}"
-                f"{self.required_column_description}"
-                f"{self.required_columns}"
-            )
+    @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)
 
-        # Ensure all required columns are strings
-        self.required_columns = [str(col) for col in self.required_columns]
+        # Check analog outputs [data with units of %] are floats only
+        columns_to_check = [
+            self.economizer_sig_col,
+            self.cooling_sig_col,
+        ]
+        self._apply_analog_checks(df, columns_to_check)
 
-        self.mapped_columns = (
-            f"Your config dictionary is mapped as: {', '.join(self.required_columns)}"
+        # Perform calculations
+        abs_mat_minus_oat = abs(df[self.mat_col] - df[self.oat_col])
+        mat_oat_sqrted = np.sqrt(
+            self.mix_degf_err_thres**2 + self.outdoor_degf_err_thres**2
         )
 
-    def get_required_columns(self) -> str:
-        """Returns a string representation of the required columns."""
-        return (
-            f"{self.equation_string}"
-            f"{self.description_string}"
-            f"{self.required_column_description}"
-            f"{self.mapped_columns}"
+        combined_check = (
+            (abs_mat_minus_oat > mat_oat_sqrted)
+            # Verify AHU is running in OS 3 cooling mode with minimum OA
+            & (df[self.cooling_sig_col] > 0.01)
+            & (df[self.economizer_sig_col] > 0.9)
         )
 
-    def apply(self, df: pd.DataFrame) -> pd.DataFrame:
-        try:
-            # Ensure all required columns are present
-            self.check_required_columns(df)
-
-            # Check analog outputs [data with units of %] are floats only
-            columns_to_check = [
-                self.economizer_sig_col,
-                self.cooling_sig_col,
-            ]
-            self.check_analog_pct(df, columns_to_check)
-
-            # Perform calculations
-            abs_mat_minus_oat = abs(df[self.mat_col] - df[self.oat_col])
-            mat_oat_sqrted = np.sqrt(
-                self.mix_degf_err_thres**2 + self.outdoor_degf_err_thres**2
-            )
+        # Set fault flag
+        self._set_fault_flag(df, combined_check, "fc10_flag")
 
-            combined_check = (
-                (abs_mat_minus_oat > mat_oat_sqrted)
-                # Verify AHU is running in OS 3 cooling mode with minimum OA
-                & (df[self.cooling_sig_col] > 0.01)
-                & (df[self.economizer_sig_col] > 0.9)
-            )
-
-            # Rolling sum to count consecutive trues
-            rolling_sum = combined_check.rolling(window=self.rolling_window_size).sum()
-
-            # Set flag to 1 if rolling sum equals the window size
-            df["fc10_flag"] = (rolling_sum >= self.rolling_window_size).astype(int)
-
-            return df
-
-        except MissingColumnError as e:
-            print(f"Error: {e.message}")
-            sys.stdout.flush()
-            raise e
-        except InvalidParameterError as e:
-            print(f"Error: {e.message}")
-            sys.stdout.flush()
-            raise e
+        return df
 
 
-class FaultConditionEleven(FaultCondition):
+class FaultConditionEleven(BaseFaultCondition, FaultConditionMixin):
     """Class provides the definitions for Fault Condition 11.
-    Outside air temperature too low for 100% outdoor
-    air cooling in economizer cooling mode.
-    Economizer performance fault
+    Outdoor air temperature and mix air temperature should
+    be approx equal in economizer mode.
 
     py -3.12 -m pytest open_fdd/tests/ahu/test_ahu_fc11.py -rP -s
     """
 
-    def __init__(self, dict_):
-        super().__init__()
-
+    def _init_specific_attributes(self, dict_):
         # Threshold parameters
-        self.delta_t_supply_fan = dict_.get("DELTA_T_SUPPLY_FAN", None)
         self.outdoor_degf_err_thres = dict_.get("OUTDOOR_DEGF_ERR_THRES", None)
-        self.supply_degf_err_thres = dict_.get("SUPPLY_DEGF_ERR_THRES", None)
+        self.mix_degf_err_thres = dict_.get("MIX_DEGF_ERR_THRES", None)
 
         # Validate that threshold parameters are floats
         for param, value in [
-            ("delta_t_supply_fan", self.delta_t_supply_fan),
             ("outdoor_degf_err_thres", self.outdoor_degf_err_thres),
-            ("supply_degf_err_thres", self.supply_degf_err_thres),
+            ("mix_degf_err_thres", self.mix_degf_err_thres),
         ]:
             if not isinstance(value, float):
                 raise InvalidParameterError(
@@ -1390,123 +866,74 @@ class FaultConditionEleven(FaultCondition):
                 )
 
         # Other attributes
-        self.sat_setpoint_col = dict_.get("SAT_SETPOINT_COL", None)
         self.oat_col = dict_.get("OAT_COL", None)
-        self.cooling_sig_col = dict_.get("COOLING_SIG_COL", None)
+        self.mat_col = dict_.get("MAT_COL", None)
         self.economizer_sig_col = dict_.get("ECONOMIZER_SIG_COL", None)
-        self.troubleshoot_mode = dict_.get("TROUBLESHOOT_MODE", False)
-        self.rolling_window_size = dict_.get("ROLLING_WINDOW_SIZE", None)
-
-        self.equation_string = (
-            "fc11_flag = 1 if OAT < (SATSP - ΔT_fan - εSAT) in "
-            "economizer cooling mode for N consecutive values else 0 \n"
-        )
-        self.description_string = (
-            "Fault Condition 11: Outside air temperature too low for 100% outdoor air cooling "
-            "in economizer cooling mode (Economizer performance fault) \n"
-        )
-        self.required_column_description = (
-            "Required inputs are the supply air temperature setpoint, outside air temperature, "
-            "cooling signal, and economizer signal \n"
-        )
-        self.error_string = "One or more required columns are missing or None \n"
-
-        self.set_attributes(dict_)
 
-        # Set required columns specific to this fault condition
-        self.required_columns = [
-            self.sat_setpoint_col,
-            self.oat_col,
-            self.cooling_sig_col,
-            self.economizer_sig_col,
-        ]
-
-        # Check if any of the required columns are None
-        if any(col is None for col in self.required_columns):
-            raise MissingColumnError(
-                f"{self.error_string}"
-                f"{self.equation_string}"
-                f"{self.description_string}"
-                f"{self.required_column_description}"
-                f"{self.required_columns}"
-            )
-
-        # Ensure all required columns are strings
-        self.required_columns = [str(col) for col in self.required_columns]
-
-        self.mapped_columns = (
-            f"Your config dictionary is mapped as: {', '.join(self.required_columns)}"
-        )
-
-    def get_required_columns(self) -> str:
-        """Returns a string representation of the required columns."""
-        return (
-            f"{self.equation_string}"
-            f"{self.description_string}"
-            f"{self.required_column_description}"
-            f"{self.mapped_columns}"
+        # Set documentation strings
+        self.equation_string = (
+            "fc11_flag = 1 if |OAT - MAT| > √(εOAT² + εMAT²) in "
+            "economizer mode for N consecutive values else 0 \n"
+        )
+        self.description_string = (
+            "Fault Condition 11: Outdoor air temperature and mixed air temperature "
+            "should be approximately equal in economizer mode \n"
+        )
+        self.required_column_description = (
+            "Required inputs are the outside air temperature, mixed air temperature, "
+            "and economizer signal \n"
         )
+        self.error_string = "One or more required columns are missing or None \n"
+
+        # Set required columns specific to this fault condition
+        self.required_columns = [
+            self.oat_col,
+            self.mat_col,
+            self.economizer_sig_col,
+        ]
 
+    @FaultConditionMixin._handle_errors
     def apply(self, df: pd.DataFrame) -> pd.DataFrame:
-        try:
-            # Ensure all required columns are present
-            self.check_required_columns(df)
-
-            # Check analog outputs [data with units of %] are floats only
-            columns_to_check = [
-                self.economizer_sig_col,
-                self.cooling_sig_col,
-            ]
-            self.check_analog_pct(df, columns_to_check)
-
-            # Perform calculations without creating DataFrame columns
-            oat_plus_oaterror = df[self.oat_col] + self.outdoor_degf_err_thres
-            satsp_delta_saterr = (
-                df[self.sat_setpoint_col]
-                - self.delta_t_supply_fan
-                - self.supply_degf_err_thres
-            )
+        """Apply the fault condition to the DataFrame."""
+        # Apply common checks
+        self._apply_common_checks(df)
 
-            combined_check = (
-                (oat_plus_oaterror < satsp_delta_saterr)
-                # Verify AHU is running in OS 3 cooling mode with 100% OA
-                & (df[self.cooling_sig_col] > 0.01)
-                & (df[self.economizer_sig_col] > 0.9)
-            )
+        # Check analog outputs [data with units of %] are floats only
+        columns_to_check = [self.economizer_sig_col]
+        self._apply_analog_checks(df, columns_to_check)
 
-            # Rolling sum to count consecutive trues
-            rolling_sum = combined_check.rolling(window=self.rolling_window_size).sum()
+        # Perform calculations
+        abs_mat_minus_oat = abs(df[self.mat_col] - df[self.oat_col])
+        mat_oat_sqrted = np.sqrt(
+            self.mix_degf_err_thres**2 + self.outdoor_degf_err_thres**2
+        )
 
-            # Set flag to 1 if rolling sum equals the window size
-            df["fc11_flag"] = (rolling_sum >= self.rolling_window_size).astype(int)
+        combined_check = (
+            (abs_mat_minus_oat > mat_oat_sqrted)
+            # Verify AHU is running in economizer mode
+            & (df[self.economizer_sig_col] > 0.9)
+        )
 
-            return df
+        # Set fault flag
+        self._set_fault_flag(df, combined_check, "fc11_flag")
 
-        except MissingColumnError as e:
-            print(f"Error: {e.message}")
-            sys.stdout.flush()
-            raise e
-        except InvalidParameterError as e:
-            print(f"Error: {e.message}")
-            sys.stdout.flush()
-            raise e
+        return df
 
 
-class FaultConditionTwelve(FaultCondition):
+class FaultConditionTwelve(BaseFaultCondition, FaultConditionMixin):
     """Class provides the definitions for Fault Condition 12.
-    Supply air temperature too high; should be less than
-    mix air temperature in economizer plus mech cooling mode.
+    Supply air temperature too high; should be less than mixed air temperature
+    in OS3 (economizer + mechanical cooling) and OS4 (mechanical cooling only) modes.
 
     py -3.12 -m pytest open_fdd/tests/ahu/test_ahu_fc12.py -rP -s
     """
 
-    def __init__(self, dict_):
-        super().__init__()
-
+    def _init_specific_attributes(self, dict_):
         # Threshold parameters
         self.delta_t_supply_fan = dict_.get("DELTA_T_SUPPLY_FAN", None)
         self.mix_degf_err_thres = dict_.get("MIX_DEGF_ERR_THRES", None)
         self.supply_degf_err_thres = dict_.get("SUPPLY_DEGF_ERR_THRES", None)
+        self.outdoor_degf_err_thres = dict_.get("OUTDOOR_DEGF_ERR_THRES", None)
         self.ahu_min_oa_dpr = dict_.get("AHU_MIN_OA_DPR", None)
 
         # Validate that threshold parameters are floats
@@ -1514,6 +941,7 @@ class FaultConditionTwelve(FaultCondition):
             ("delta_t_supply_fan", self.delta_t_supply_fan),
             ("mix_degf_err_thres", self.mix_degf_err_thres),
             ("supply_degf_err_thres", self.supply_degf_err_thres),
+            ("outdoor_degf_err_thres", self.outdoor_degf_err_thres),
             ("ahu_min_oa_dpr", self.ahu_min_oa_dpr),
         ]:
             if not isinstance(value, float):
@@ -1524,129 +952,99 @@ class FaultConditionTwelve(FaultCondition):
         # Other attributes
         self.sat_col = dict_.get("SAT_COL", None)
         self.mat_col = dict_.get("MAT_COL", None)
+        self.oat_col = dict_.get("OAT_COL", None)
         self.cooling_sig_col = dict_.get("COOLING_SIG_COL", None)
         self.economizer_sig_col = dict_.get("ECONOMIZER_SIG_COL", None)
-        self.troubleshoot_mode = dict_.get("TROUBLESHOOT_MODE", False)
-        self.rolling_window_size = dict_.get("ROLLING_WINDOW_SIZE", None)
 
+        # Set documentation strings
         self.equation_string = (
-            "fc12_flag = 1 if SAT >= MAT + εMAT in "
-            "economizer + mech cooling mode for N consecutive values else 0 \n"
+            "fc12_flag = 1 if (SAT > MAT + εSAT) and "
+            "((CLG > 0 and ECO > 0.9) or (CLG > 0.9 and ECO = MIN_OA)) "
+            "for N consecutive values else 0 \n"
         )
         self.description_string = (
             "Fault Condition 12: Supply air temperature too high; should be less than "
-            "mixed air temperature in economizer plus mechanical cooling mode \n"
+            "mixed air temperature in OS3 (economizer + mechanical cooling) and "
+            "OS4 (mechanical cooling only) modes \n"
         )
         self.required_column_description = (
             "Required inputs are the supply air temperature, mixed air temperature, "
-            "cooling signal, and economizer signal \n"
+            "outside air temperature, cooling signal, and economizer signal \n"
         )
         self.error_string = "One or more required columns are missing or None \n"
 
-        self.set_attributes(dict_)
-
         # Set required columns specific to this fault condition
         self.required_columns = [
             self.sat_col,
             self.mat_col,
+            self.oat_col,
             self.cooling_sig_col,
             self.economizer_sig_col,
         ]
 
-        # Check if any of the required columns are None
-        if any(col is None for col in self.required_columns):
-            raise MissingColumnError(
-                f"{self.error_string}"
-                f"{self.equation_string}"
-                f"{self.description_string}"
-                f"{self.required_column_description}"
-                f"{self.required_columns}"
-            )
+    @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)
 
-        # Ensure all required columns are strings
-        self.required_columns = [str(col) for col in self.required_columns]
+        # Check analog outputs [data with units of %] are floats only
+        columns_to_check = [
+            self.economizer_sig_col,
+            self.cooling_sig_col,
+        ]
+        self._apply_analog_checks(df, columns_to_check)
 
-        self.mapped_columns = (
-            f"Your config dictionary is mapped as: {', '.join(self.required_columns)}"
+        # Calculate the threshold for SAT vs MAT comparison
+        sat_mat_threshold = np.sqrt(
+            self.supply_degf_err_thres**2 + self.mix_degf_err_thres**2
         )
 
-    def get_required_columns(self) -> str:
-        """Returns a string representation of the required columns."""
-        return (
-            f"{self.equation_string}"
-            f"{self.description_string}"
-            f"{self.required_column_description}"
-            f"{self.mapped_columns}"
+        # Check if SAT is too high compared to MAT (accounting for supply fan heat)
+        sat_too_high = df[self.sat_col] > (
+            df[self.mat_col] + sat_mat_threshold + self.delta_t_supply_fan
         )
 
-    def apply(self, df: pd.DataFrame) -> pd.DataFrame:
-        try:
-            # Ensure all required columns are present
-            self.check_required_columns(df)
-
-            # Check analog outputs [data with units of %] are floats only
-            columns_to_check = [
-                self.economizer_sig_col,
-                self.cooling_sig_col,
-            ]
-            self.check_analog_pct(df, columns_to_check)
-
-            # Perform calculations without creating DataFrame columns
-            sat_minus_saterr_delta_supply_fan = (
-                df[self.sat_col] - self.supply_degf_err_thres - self.delta_t_supply_fan
-            )
-            mat_plus_materr = df[self.mat_col] + self.mix_degf_err_thres
-
-            # Combined check without adding to DataFrame columns
-            combined_check = operator.or_(
-                # OS4 AHU state cooling @ min OA
-                (sat_minus_saterr_delta_supply_fan > mat_plus_materr)
-                # Verify AHU in OS4 mode
-                & (df[self.cooling_sig_col] > 0.01)
-                & (df[self.economizer_sig_col] == self.ahu_min_oa_dpr),
-                # OR
-                (sat_minus_saterr_delta_supply_fan > mat_plus_materr)
-                # Verify AHU is running in OS3 cooling mode in 100% OA
-                & (df[self.cooling_sig_col] > 0.01)
-                & (df[self.economizer_sig_col] > 0.9),
-            )
+        # Check operating modes:
+        # OS3: Economizer + mechanical cooling (ECO > 0.9 and CLG > 0)
+        os3_mode = (df[self.economizer_sig_col] > 0.9) & (df[self.cooling_sig_col] > 0)
 
-            # Rolling sum to count consecutive trues
-            rolling_sum = combined_check.rolling(window=self.rolling_window_size).sum()
+        # OS4: Mechanical cooling only (ECO = MIN_OA and CLG > 0.9)
+        os4_mode = (df[self.economizer_sig_col] <= self.ahu_min_oa_dpr) & (
+            df[self.cooling_sig_col] > 0.9
+        )
 
-            # Set flag to 1 if rolling sum equals the window size
-            df["fc12_flag"] = (rolling_sum >= self.rolling_window_size).astype(int)
+        # Combine conditions:
+        # Fault occurs when SAT is too high in either OS3 or OS4 mode
+        combined_check = sat_too_high & (os3_mode | os4_mode)
 
-            return df
+        # Set fault flag
+        self._set_fault_flag(df, combined_check, "fc12_flag")
 
-        except MissingColumnError as e:
-            print(f"Error: {e.message}")
-            sys.stdout.flush()
-            raise e
-        except InvalidParameterError as e:
-            print(f"Error: {e.message}")
-            sys.stdout.flush()
-            raise e
+        return df
 
 
-class FaultConditionThirteen(FaultCondition):
+class FaultConditionThirteen(BaseFaultCondition, FaultConditionMixin):
     """Class provides the definitions for Fault Condition 13.
-    Supply air temperature too high in full cooling
-    in economizer plus mech cooling mode
+    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
     """
 
-    def __init__(self, dict_):
-        super().__init__()
-
+    def _init_specific_attributes(self, dict_):
         # Threshold parameters
         self.supply_degf_err_thres = dict_.get("SUPPLY_DEGF_ERR_THRES", None)
+        self.mix_degf_err_thres = dict_.get("MIX_DEGF_ERR_THRES", None)
+        self.outdoor_degf_err_thres = dict_.get("OUTDOOR_DEGF_ERR_THRES", None)
         self.ahu_min_oa_dpr = dict_.get("AHU_MIN_OA_DPR", None)
 
         # Validate that threshold parameters are floats
         for param, value in [
             ("supply_degf_err_thres", self.supply_degf_err_thres),
+            ("mix_degf_err_thres", self.mix_degf_err_thres),
+            ("outdoor_degf_err_thres", self.outdoor_degf_err_thres),
             ("ahu_min_oa_dpr", self.ahu_min_oa_dpr),
         ]:
             if not isinstance(value, float):
@@ -1656,19 +1054,19 @@ class FaultConditionThirteen(FaultCondition):
 
         # Other attributes
         self.sat_col = dict_.get("SAT_COL", None)
-        self.sat_setpoint_col = dict_.get("SAT_SETPOINT_COL", None)
+        self.sat_sp_col = dict_.get("SAT_SP_COL", None)
         self.cooling_sig_col = dict_.get("COOLING_SIG_COL", None)
         self.economizer_sig_col = dict_.get("ECONOMIZER_SIG_COL", None)
-        self.troubleshoot_mode = dict_.get("TROUBLESHOOT_MODE", False)
-        self.rolling_window_size = dict_.get("ROLLING_WINDOW_SIZE", None)
 
+        # Set documentation strings
         self.equation_string = (
-            "fc13_flag = 1 if SAT > (SATSP + εSAT) in "
-            "economizer + mech cooling mode for N consecutive values else 0 \n"
+            "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"
         )
         self.description_string = (
-            "Fault Condition 13: Supply air temperature too high in full cooling "
-            "in economizer plus mechanical cooling mode \n"
+            "Fault Condition 13: Supply air temperature too high in full cooling mode "
+            "in OS3 (economizer + mechanical cooling) and OS4 (mechanical cooling only) modes \n"
         )
         self.required_column_description = (
             "Required inputs are the supply air temperature, supply air temperature setpoint, "
@@ -1676,111 +1074,75 @@ class FaultConditionThirteen(FaultCondition):
         )
         self.error_string = "One or more required columns are missing or None \n"
 
-        self.set_attributes(dict_)
-
         # Set required columns specific to this fault condition
         self.required_columns = [
             self.sat_col,
-            self.sat_setpoint_col,
+            self.sat_sp_col,
             self.cooling_sig_col,
             self.economizer_sig_col,
         ]
 
-        # Check if any of the required columns are None
-        if any(col is None for col in self.required_columns):
-            raise MissingColumnError(
-                f"{self.error_string}"
-                f"{self.equation_string}"
-                f"{self.description_string}"
-                f"{self.required_column_description}"
-                f"{self.required_columns}"
-            )
+    @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)
 
-        # Ensure all required columns are strings
-        self.required_columns = [str(col) for col in self.required_columns]
+        # Check analog outputs [data with units of %] are floats only
+        columns_to_check = [
+            self.economizer_sig_col,
+            self.cooling_sig_col,
+        ]
+        self._apply_analog_checks(df, columns_to_check)
 
-        self.mapped_columns = (
-            f"Your config dictionary is mapped as: {', '.join(self.required_columns)}"
+        # Check if SAT is too high compared to setpoint
+        sat_too_high = df[self.sat_col] > (
+            df[self.sat_sp_col] + self.supply_degf_err_thres
         )
 
-    def get_required_columns(self) -> str:
-        """Returns a string representation of the required columns."""
-        return (
-            f"{self.equation_string}"
-            f"{self.description_string}"
-            f"{self.required_column_description}"
-            f"{self.mapped_columns}"
+        # Check operating modes:
+        # OS3: Economizer + full mechanical cooling (ECO > 0.9 and CLG > 0.9)
+        os3_mode = (df[self.economizer_sig_col] > 0.9) & (
+            df[self.cooling_sig_col] > 0.9
         )
 
-    def apply(self, df: pd.DataFrame) -> pd.DataFrame:
-        try:
-            # Ensure all required columns are present
-            self.check_required_columns(df)
-
-            # Check analog outputs [data with units of %] are floats only
-            columns_to_check = [
-                self.economizer_sig_col,
-                self.cooling_sig_col,
-            ]
-            self.check_analog_pct(df, columns_to_check)
-
-            # Perform calculation without creating DataFrame columns
-            sat_greater_than_sp_calc = (
-                df[self.sat_col]
-                > df[self.sat_setpoint_col] + self.supply_degf_err_thres
-            )
-
-            # Combined check without adding to DataFrame columns
-            combined_check = operator.or_(
-                # OS4 AHU state cooling @ min OA
-                (sat_greater_than_sp_calc)
-                & (df[self.cooling_sig_col] > 0.01)
-                & (df[self.economizer_sig_col] == self.ahu_min_oa_dpr),
-                # OR verify AHU is running in OS 3 cooling mode in 100% OA
-                (sat_greater_than_sp_calc)
-                & (df[self.cooling_sig_col] > 0.01)
-                & (df[self.economizer_sig_col] > 0.9),
-            )
-
-            # Rolling sum to count consecutive trues
-            rolling_sum = combined_check.rolling(window=self.rolling_window_size).sum()
+        # OS4: Full mechanical cooling only (ECO = MIN_OA and CLG > 0.9)
+        os4_mode = (df[self.economizer_sig_col] <= self.ahu_min_oa_dpr) & (
+            df[self.cooling_sig_col] > 0.9
+        )
 
-            # Set flag to 1 if rolling sum equals the window size
-            df["fc13_flag"] = (rolling_sum >= self.rolling_window_size).astype(int)
+        # 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)
 
-            return df
+        # Set fault flag
+        self._set_fault_flag(df, combined_check, "fc13_flag")
 
-        except MissingColumnError as e:
-            print(f"Error: {e.message}")
-            sys.stdout.flush()
-            raise e
-        except InvalidParameterError as e:
-            print(f"Error: {e.message}")
-            sys.stdout.flush()
-            raise e
+        return df
 
 
-class FaultConditionFourteen(FaultCondition):
+class FaultConditionFourteen(BaseFaultCondition, FaultConditionMixin):
     """Class provides the definitions for Fault Condition 14.
-    Temperature drop across inactive cooling coil.
-    Requires coil leaving temp sensor.
+    Temperature drop across inactive cooling coil in OS1 (heating) and OS2 (economizer) modes.
+    This fault checks if there is an unexpected temperature drop across the cooling coil
+    when it should be inactive.
 
     py -3.12 -m pytest open_fdd/tests/ahu/test_ahu_fc14.py -rP -s
     """
 
-    def __init__(self, dict_):
-        super().__init__()
-
+    def _init_specific_attributes(self, dict_):
         # Threshold parameters
         self.delta_t_supply_fan = dict_.get("DELTA_T_SUPPLY_FAN", None)
         self.coil_temp_enter_err_thres = dict_.get("COIL_TEMP_ENTER_ERR_THRES", None)
-        self.coil_temp_leav_err_thres = dict_.get("COIL_TEMP_LEAV_ERR_THRES", None)
+        self.coil_temp_leave_err_thres = dict_.get("COIL_TEMP_LEAV_ERR_THRES", None)
+        self.ahu_min_oa_dpr = dict_.get("AHU_MIN_OA_DPR", None)
 
         # Validate that threshold parameters are floats
         for param, value in [
             ("delta_t_supply_fan", self.delta_t_supply_fan),
             ("coil_temp_enter_err_thres", self.coil_temp_enter_err_thres),
-            ("coil_temp_leav_err_thres", self.coil_temp_leav_err_thres),
+            ("coil_temp_leave_err_thres", self.coil_temp_leave_err_thres),
+            ("ahu_min_oa_dpr", self.ahu_min_oa_dpr),
         ]:
             if not isinstance(value, float):
                 raise InvalidParameterError(
@@ -1790,30 +1152,26 @@ class FaultConditionFourteen(FaultCondition):
         # Other attributes
         self.clg_coil_enter_temp_col = dict_.get("CLG_COIL_ENTER_TEMP_COL", None)
         self.clg_coil_leave_temp_col = dict_.get("CLG_COIL_LEAVE_TEMP_COL", None)
-        self.ahu_min_oa_dpr = dict_.get("AHU_MIN_OA_DPR", None)
         self.cooling_sig_col = dict_.get("COOLING_SIG_COL", None)
         self.heating_sig_col = dict_.get("HEATING_SIG_COL", None)
         self.economizer_sig_col = dict_.get("ECONOMIZER_SIG_COL", None)
         self.supply_vfd_speed_col = dict_.get("SUPPLY_VFD_SPEED_COL", None)
-        self.troubleshoot_mode = dict_.get("TROUBLESHOOT_MODE", False)
-        self.rolling_window_size = dict_.get("ROLLING_WINDOW_SIZE", None)
 
+        # Set documentation strings
         self.equation_string = (
-            "fc14_flag = 1 if ΔT_coil >= √(εcoil_enter² + εcoil_leave²) + ΔT_fan "
-            "in inactive cooling coil mode for N consecutive values else 0 \n"
+            "fc14_flag = 1 if (CLG_LEAVE < CLG_ENTER - √(εENTER² + εLEAVE²)) "
+            "in OS1 (heating) or OS2 (economizer) modes for N consecutive values else 0 \n"
         )
         self.description_string = (
             "Fault Condition 14: Temperature drop across inactive cooling coil "
-            "detected, requiring coil leaving temperature sensor \n"
+            "in OS1 (heating) and OS2 (economizer) modes \n"
         )
         self.required_column_description = (
-            "Required inputs are the cooling coil entering temperature, cooling coil leaving temperature, "
+            "Required inputs are the cooling coil entering and leaving air temperatures, "
             "cooling signal, heating signal, economizer signal, and supply fan VFD speed \n"
         )
         self.error_string = "One or more required columns are missing or None \n"
 
-        self.set_attributes(dict_)
-
         # Set required columns specific to this fault condition
         self.required_columns = [
             self.clg_coil_enter_temp_col,
@@ -1824,106 +1182,79 @@ class FaultConditionFourteen(FaultCondition):
             self.supply_vfd_speed_col,
         ]
 
-        # Check if any of the required columns are None
-        if any(col is None for col in self.required_columns):
-            raise MissingColumnError(
-                f"{self.error_string}"
-                f"{self.equation_string}"
-                f"{self.description_string}"
-                f"{self.required_column_description}"
-                f"{self.required_columns}"
-            )
-
-        # Ensure all required columns are strings
-        self.required_columns = [str(col) for col in self.required_columns]
+    @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)
 
-        self.mapped_columns = (
-            f"Your config dictionary is mapped as: {', '.join(self.required_columns)}"
-        )
+        # Check analog outputs [data with units of %] are floats only
+        columns_to_check = [
+            self.cooling_sig_col,
+            self.heating_sig_col,
+            self.economizer_sig_col,
+            self.supply_vfd_speed_col,
+        ]
+        self._apply_analog_checks(df, columns_to_check)
 
-    def get_required_columns(self) -> str:
-        """Returns a string representation of the required columns."""
-        return (
-            f"{self.equation_string}"
-            f"{self.description_string}"
-            f"{self.required_column_description}"
-            f"{self.mapped_columns}"
+        # Calculate the threshold for temperature drop
+        temp_drop_threshold = np.sqrt(
+            self.coil_temp_enter_err_thres**2 + self.coil_temp_leave_err_thres**2
         )
 
-    def apply(self, df: pd.DataFrame) -> pd.DataFrame:
-        try:
-            # Ensure all required columns are present
-            self.check_required_columns(df)
-
-            # Check analog outputs [data with units of %] are floats only
-            columns_to_check = [
-                self.economizer_sig_col,
-                self.cooling_sig_col,
-                self.heating_sig_col,
-                self.supply_vfd_speed_col,
-            ]
-            self.check_analog_pct(df, columns_to_check)
-
-            # Calculate necessary checks
-            clg_delta_temp = (
-                df[self.clg_coil_enter_temp_col] - df[self.clg_coil_leave_temp_col]
-            )
-            clg_delta_sqrted = (
-                np.sqrt(
-                    self.coil_temp_enter_err_thres**2 + self.coil_temp_leav_err_thres**2
-                )
-                + self.delta_t_supply_fan
-            )
+        # Check if there's a significant temperature drop across the cooling coil
+        temp_drop = df[self.clg_coil_enter_temp_col] - df[self.clg_coil_leave_temp_col]
+        significant_temp_drop = temp_drop > temp_drop_threshold
 
-            # Perform combined checks without adding intermediate columns to DataFrame
-            combined_check = operator.or_(
-                (clg_delta_temp >= clg_delta_sqrted)
-                & (df[self.economizer_sig_col] > self.ahu_min_oa_dpr)
-                & (df[self.cooling_sig_col] < 0.1),  # OR
-                (clg_delta_temp >= clg_delta_sqrted)
-                & (df[self.heating_sig_col] > 0.0)
-                & (df[self.supply_vfd_speed_col] > 0.0),
-            )
+        # Check operating modes:
+        # OS1: Heating mode (HTG > 0, CLG = 0, ECO = MIN_OA)
+        os1_mode = (
+            (df[self.heating_sig_col] > 0.0)
+            & (df[self.cooling_sig_col] == 0.0)
+            & (df[self.economizer_sig_col] <= self.ahu_min_oa_dpr)
+        )
 
-            # Rolling sum to count consecutive trues
-            rolling_sum = combined_check.rolling(window=self.rolling_window_size).sum()
+        # OS2: Economizer mode (HTG = 0, CLG = 0, ECO > MIN_OA)
+        os2_mode = (
+            (df[self.heating_sig_col] == 0.0)
+            & (df[self.cooling_sig_col] == 0.0)
+            & (df[self.economizer_sig_col] > self.ahu_min_oa_dpr)
+        )
 
-            # Set flag to 1 if rolling sum equals the window size
-            df["fc14_flag"] = (rolling_sum >= self.rolling_window_size).astype(int)
+        # Combine conditions:
+        # Fault occurs when there's a significant temperature drop across an inactive cooling coil
+        # in either OS1 (heating) or OS2 (economizer) mode
+        combined_check = significant_temp_drop & (os1_mode | os2_mode)
 
-            return df
+        # Set fault flag
+        self._set_fault_flag(df, combined_check, "fc14_flag")
 
-        except MissingColumnError as e:
-            print(f"Error: {e.message}")
-            sys.stdout.flush()
-            raise e
-        except InvalidParameterError as e:
-            print(f"Error: {e.message}")
-            sys.stdout.flush()
-            raise e
+        return df
 
 
-class FaultConditionFifteen(FaultCondition):
+class FaultConditionFifteen(BaseFaultCondition, FaultConditionMixin):
     """Class provides the definitions for Fault Condition 15.
-    Temperature rise across inactive heating coil.
-    Requires coil leaving temp sensor.
+    Temperature rise across inactive heating coil in OS2 (economizer),
+    OS3 (economizer + mechanical cooling), and OS4 (mechanical cooling only) modes.
+    This fault checks if there is an unexpected temperature rise across the heating coil
+    when it should be inactive.
 
-    > py -3.12 -m pytest open_fdd/tests/ahu/test_ahu_fc15.py -rP -s
+    py -3.12 -m pytest open_fdd/tests/ahu/test_ahu_fc15.py -rP -s
     """
 
-    def __init__(self, dict_):
-        super().__init__()
-
+    def _init_specific_attributes(self, dict_):
         # Threshold parameters
-        self.delta_supply_fan = dict_.get("DELTA_SUPPLY_FAN", None)
+        self.delta_t_supply_fan = dict_.get("DELTA_SUPPLY_FAN", None)
         self.coil_temp_enter_err_thres = dict_.get("COIL_TEMP_ENTER_ERR_THRES", None)
-        self.coil_temp_leav_err_thres = dict_.get("COIL_TEMP_LEAV_ERR_THRES", None)
+        self.coil_temp_leave_err_thres = dict_.get("COIL_TEMP_LEAV_ERR_THRES", None)
+        self.ahu_min_oa_dpr = dict_.get("AHU_MIN_OA_DPR", None)
 
         # Validate that threshold parameters are floats
         for param, value in [
-            ("delta_supply_fan", self.delta_supply_fan),
+            ("delta_t_supply_fan", self.delta_t_supply_fan),
             ("coil_temp_enter_err_thres", self.coil_temp_enter_err_thres),
-            ("coil_temp_leav_err_thres", self.coil_temp_leav_err_thres),
+            ("coil_temp_leave_err_thres", self.coil_temp_leave_err_thres),
+            ("ahu_min_oa_dpr", self.ahu_min_oa_dpr),
         ]:
             if not isinstance(value, float):
                 raise InvalidParameterError(
@@ -1933,30 +1264,28 @@ class FaultConditionFifteen(FaultCondition):
         # Other attributes
         self.htg_coil_enter_temp_col = dict_.get("HTG_COIL_ENTER_TEMP_COL", None)
         self.htg_coil_leave_temp_col = dict_.get("HTG_COIL_LEAVE_TEMP_COL", None)
-        self.ahu_min_oa_dpr = dict_.get("AHU_MIN_OA_DPR", None)
         self.cooling_sig_col = dict_.get("COOLING_SIG_COL", None)
         self.heating_sig_col = dict_.get("HEATING_SIG_COL", None)
         self.economizer_sig_col = dict_.get("ECONOMIZER_SIG_COL", None)
         self.supply_vfd_speed_col = dict_.get("SUPPLY_VFD_SPEED_COL", None)
-        self.troubleshoot_mode = dict_.get("TROUBLESHOOT_MODE", False)
-        self.rolling_window_size = dict_.get("ROLLING_WINDOW_SIZE", None)
 
+        # Set documentation strings
         self.equation_string = (
-            "fc15_flag = 1 if ΔT_coil >= √(εcoil_enter² + εcoil_leave²) + ΔT_fan "
-            "in inactive heating coil mode for N consecutive values else 0 \n"
+            "fc15_flag = 1 if (HTG_LEAVE > HTG_ENTER + √(εENTER² + εLEAVE²) + ΔTfan) "
+            "in OS2 (economizer), OS3 (economizer + mechanical cooling), or "
+            "OS4 (mechanical cooling only) modes for N consecutive values else 0 \n"
         )
         self.description_string = (
             "Fault Condition 15: Temperature rise across inactive heating coil "
-            "detected, requiring coil leaving temperature sensor \n"
+            "in OS2 (economizer), OS3 (economizer + mechanical cooling), and "
+            "OS4 (mechanical cooling only) modes \n"
         )
         self.required_column_description = (
-            "Required inputs are the heating coil entering temperature, heating coil leaving temperature, "
+            "Required inputs are the heating coil entering and leaving air temperatures, "
             "cooling signal, heating signal, economizer signal, and supply fan VFD speed \n"
         )
         self.error_string = "One or more required columns are missing or None \n"
 
-        self.set_attributes(dict_)
-
         # Set required columns specific to this fault condition
         self.required_columns = [
             self.htg_coil_enter_temp_col,
@@ -1967,129 +1296,86 @@ class FaultConditionFifteen(FaultCondition):
             self.supply_vfd_speed_col,
         ]
 
-        # Check if any of the required columns are None
-        if any(col is None for col in self.required_columns):
-            raise MissingColumnError(
-                f"{self.error_string}"
-                f"{self.equation_string}"
-                f"{self.description_string}"
-                f"{self.required_column_description}"
-                f"{self.required_columns}"
-            )
-
-        # Ensure all required columns are strings
-        self.required_columns = [str(col) for col in self.required_columns]
-
-        self.mapped_columns = (
-            f"Your config dictionary is mapped as: {', '.join(self.required_columns)}"
-        )
+    @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)
 
-    def get_required_columns(self) -> str:
-        """Returns a string representation of the required columns."""
-        return (
-            f"{self.equation_string}"
-            f"{self.description_string}"
-            f"{self.required_column_description}"
-            f"{self.mapped_columns}"
-        )
+        # Check analog outputs [data with units of %] are floats only
+        columns_to_check = [
+            self.cooling_sig_col,
+            self.heating_sig_col,
+            self.economizer_sig_col,
+            self.supply_vfd_speed_col,
+        ]
+        self._apply_analog_checks(df, columns_to_check)
 
-    def apply(self, df: pd.DataFrame) -> pd.DataFrame:
-        try:
-            # Ensure all required columns are present
-            self.check_required_columns(df)
-
-            if self.troubleshoot_mode:
-                self.troubleshoot_cols(df)
-
-            # Check analog outputs [data with units of %] are floats only
-            columns_to_check = [
-                self.economizer_sig_col,
-                self.cooling_sig_col,
-                self.heating_sig_col,
-                self.supply_vfd_speed_col,
-            ]
-            self.check_analog_pct(df, columns_to_check)
-
-            # Create helper columns
-            df["htg_delta_temp"] = (
-                df[self.htg_coil_leave_temp_col] - df[self.htg_coil_enter_temp_col]
+        # Calculate the threshold for temperature rise, including supply fan heat
+        temp_rise_threshold = (
+            np.sqrt(
+                self.coil_temp_enter_err_thres**2 + self.coil_temp_leave_err_thres**2
             )
+            + self.delta_t_supply_fan
+        )
 
-            df["htg_delta_sqrted"] = (
-                np.sqrt(
-                    self.coil_temp_enter_err_thres**2 + self.coil_temp_leav_err_thres**2
-                )
-                + self.delta_supply_fan
-            )
+        # Check if there's a significant temperature rise across the heating coil
+        temp_rise = df[self.htg_coil_leave_temp_col] - df[self.htg_coil_enter_temp_col]
+        significant_temp_rise = temp_rise > temp_rise_threshold
 
-            df["combined_check"] = (
-                (
-                    (df["htg_delta_temp"] >= df["htg_delta_sqrted"])
-                    # verify AHU is in OS2 only free cooling mode
-                    & (df[self.economizer_sig_col] > self.ahu_min_oa_dpr)
-                    & (df[self.cooling_sig_col] < 0.1)
-                )
-                | (
-                    (df["htg_delta_temp"] >= df["htg_delta_sqrted"])
-                    # OS4 AHU state clg @ min OA
-                    & (df[self.cooling_sig_col] > 0.01)
-                    & (df[self.economizer_sig_col] == self.ahu_min_oa_dpr)
-                )
-                | (
-                    (df["htg_delta_temp"] >= df["htg_delta_sqrted"])
-                    # verify AHU is running in OS 3 clg mode in 100 OA
-                    & (df[self.cooling_sig_col] > 0.01)
-                    & (df[self.economizer_sig_col] > 0.9)
-                )
-            )
+        # Check operating modes:
+        # OS2: Economizer mode (HTG = 0, CLG = 0, ECO > MIN_OA)
+        os2_mode = (
+            (df[self.heating_sig_col] == 0.0)
+            & (df[self.cooling_sig_col] == 0.0)
+            & (df[self.economizer_sig_col] > self.ahu_min_oa_dpr)
+        )
 
-            # Rolling sum to count consecutive trues
-            rolling_sum = (
-                df["combined_check"].rolling(window=self.rolling_window_size).sum()
-            )
-            # Set flag to 1 if rolling sum equals the window size
-            df["fc15_flag"] = (rolling_sum >= self.rolling_window_size).astype(int)
+        # OS3: Economizer + mechanical cooling (HTG = 0, CLG > 0, ECO > 0.9)
+        os3_mode = (
+            (df[self.heating_sig_col] == 0.0)
+            & (df[self.cooling_sig_col] > 0.0)
+            & (df[self.economizer_sig_col] > 0.9)
+        )
 
-            if self.troubleshoot_mode:
-                print("Troubleshoot mode enabled - not removing helper columns")
-                sys.stdout.flush()
+        # OS4: Mechanical cooling only (HTG = 0, CLG > 0, ECO = MIN_OA)
+        os4_mode = (
+            (df[self.heating_sig_col] == 0.0)
+            & (df[self.cooling_sig_col] > 0.0)
+            & (df[self.economizer_sig_col] <= self.ahu_min_oa_dpr)
+        )
 
-            # Optionally remove temporary columns
-            df.drop(
-                columns=["htg_delta_temp", "htg_delta_sqrted", "combined_check"],
-                inplace=True,
-            )
+        # Combine conditions:
+        # Fault occurs when there's a significant temperature rise across an inactive heating coil
+        # in OS2 (economizer), OS3 (economizer + mechanical cooling), or OS4 (mechanical cooling only) mode
+        combined_check = significant_temp_rise & (os2_mode | os3_mode | os4_mode)
 
-            return df
+        # Set fault flag
+        self._set_fault_flag(df, combined_check, "fc15_flag")
 
-        except MissingColumnError as e:
-            print(f"Error: {e.message}")
-            sys.stdout.flush()
-            raise e
-        except InvalidParameterError as e:
-            print(f"Error: {e.message}")
-            sys.stdout.flush()
-            raise e
+        return df
 
 
-class FaultConditionSixteen(FaultCondition):
+class FaultConditionSixteen(BaseFaultCondition, FaultConditionMixin):
     """Class provides the definitions for Fault Condition 16.
-    ERV Ineffective Process based on outdoor air temperature ranges.
-    """
+    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.
 
-    def __init__(self, dict_):
-        super().__init__()
-
-        # Threshold parameters for efficiency ranges based on heating and cooling
-        self.erv_efficiency_min_heating = dict_.get("ERV_EFFICIENCY_MIN_HEATING", 0.7)
-        self.erv_efficiency_max_heating = dict_.get("ERV_EFFICIENCY_MAX_HEATING", 0.8)
-        self.erv_efficiency_min_cooling = dict_.get("ERV_EFFICIENCY_MIN_COOLING", 0.5)
-        self.erv_efficiency_max_cooling = dict_.get("ERV_EFFICIENCY_MAX_COOLING", 0.6)
+    py -3.12 -m pytest open_fdd/tests/ahu/test_ahu_fc16.py -rP -s
+    """
 
-        self.oat_low_threshold = dict_.get("OAT_LOW_THRES", 32.0)
-        self.oat_high_threshold = dict_.get("OAT_HIGH_THRES", 80.0)
+    def _init_specific_attributes(self, dict_):
+        # Threshold parameters
+        self.erv_efficiency_min_heating = dict_.get("ERV_EFFICIENCY_MIN_HEATING", None)
+        self.erv_efficiency_max_heating = dict_.get("ERV_EFFICIENCY_MAX_HEATING", None)
+        self.erv_efficiency_min_cooling = dict_.get("ERV_EFFICIENCY_MIN_COOLING", None)
+        self.erv_efficiency_max_cooling = dict_.get("ERV_EFFICIENCY_MAX_COOLING", None)
+        self.oat_low_threshold = dict_.get("OAT_LOW_THRESHOLD", None)
+        self.oat_high_threshold = dict_.get("OAT_HIGH_THRESHOLD", None)
+        self.oat_rat_delta_min = dict_.get("OAT_RAT_DELTA_MIN", None)
 
-        # Validate that threshold parameters are floats and within 0.0 and 1.0 for efficiency values
+        # Validate that threshold parameters are floats
         for param, value in [
             ("erv_efficiency_min_heating", self.erv_efficiency_min_heating),
             ("erv_efficiency_max_heating", self.erv_efficiency_max_heating),
@@ -2097,49 +1383,47 @@ class FaultConditionSixteen(FaultCondition):
             ("erv_efficiency_max_cooling", self.erv_efficiency_max_cooling),
             ("oat_low_threshold", self.oat_low_threshold),
             ("oat_high_threshold", self.oat_high_threshold),
+            ("oat_rat_delta_min", self.oat_rat_delta_min),
         ]:
             if not isinstance(value, float):
                 raise InvalidParameterError(
                     f"The parameter '{param}' should be a float, but got {type(value).__name__}."
                 )
-            if "erv_efficiency" in param and not (0.0 <= value <= 1.0):
+
+        # Validate that efficiency values are between 0.0 and 1.0
+        for param, value in [
+            ("ERV_EFFICIENCY_MIN_HEATING", self.erv_efficiency_min_heating),
+            ("ERV_EFFICIENCY_MAX_HEATING", self.erv_efficiency_max_heating),
+            ("ERV_EFFICIENCY_MIN_COOLING", self.erv_efficiency_min_cooling),
+            ("ERV_EFFICIENCY_MAX_COOLING", self.erv_efficiency_max_cooling),
+        ]:
+            if not 0.0 <= value <= 1.0:
                 raise InvalidParameterError(
-                    f"The parameter '{param}' should be a float between 0.0 and 1.0 to represent a percentage, but got {value}."
+                    f"The parameter '{param}' should be a float between 0.0 and 1.0, but got {value}."
                 )
 
         # Other attributes
-        self.erv_oat_enter_col = dict_.get("ERV_OAT_ENTER_COL", "erv_oat_enter")
-        self.erv_oat_leaving_col = dict_.get("ERV_OAT_LEAVING_COL", "erv_oat_leaving")
-        self.erv_eat_enter_col = dict_.get("ERV_EAT_ENTER_COL", "erv_eat_enter")
-        self.erv_eat_leaving_col = dict_.get("ERV_EAT_LEAVING_COL", "erv_eat_leaving")
-        self.supply_vfd_speed_col = dict_.get(
-            "SUPPLY_VFD_SPEED_COL", "supply_vfd_speed"
-        )
-        self.rolling_window_size = dict_.get("ROLLING_WINDOW_SIZE", 1)
-        self.troubleshoot_mode = dict_.get("TROUBLESHOOT_MODE", False)
+        self.erv_oat_enter_col = dict_.get("ERV_OAT_ENTER_COL", None)
+        self.erv_oat_leaving_col = dict_.get("ERV_OAT_LEAVING_COL", None)
+        self.erv_eat_enter_col = dict_.get("ERV_EAT_ENTER_COL", None)
+        self.erv_eat_leaving_col = dict_.get("ERV_EAT_LEAVING_COL", None)
+        self.supply_vfd_speed_col = dict_.get("SUPPLY_VFD_SPEED_COL", None)
 
+        # Set documentation strings
         self.equation_string = (
-            "fc16_flag = 1 if temperature deltas and expected efficiency is ineffective "
+            "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"
         )
         self.description_string = (
-            "Fault Condition 16: ERV is an ineffective heat transfer fault. "
-            "This fault occurs when the ERV's efficiency "
-            "is outside the acceptable range based on the delta temperature across the "
-            "ERV outside air enter temperature and ERV outside air leaving temperature, "
-            "indicating poor heat transfer. "
-            "It considers both heating and cooling conditions where each have acceptable "
-            "ranges in percentage for expected heat transfer efficiency. The percentage needs "
-            "to be a float between 0.0 and 1.0."
+            "Fault Condition 16: ERV effectiveness should be within specified "
+            "thresholds based on OAT \n"
         )
         self.required_column_description = (
-            "Required inputs are the ERV outside air entering temperature, ERV outside air leaving temperature, "
-            "ERV exhaust entering temperature, ERV exhaust leaving temperature, "
-            "and AHU supply fan VFD speed."
+            "Required inputs are the ERV outdoor air entering and leaving temperatures, "
+            "ERV exhaust air entering and leaving temperatures, and supply fan VFD speed \n"
         )
-        self.error_string = "One or more required columns are missing or None."
-
-        self.set_attributes(dict_)
+        self.error_string = "One or more required columns are missing or None \n"
 
         # Set required columns specific to this fault condition
         self.required_columns = [
@@ -2150,104 +1434,54 @@ class FaultConditionSixteen(FaultCondition):
             self.supply_vfd_speed_col,
         ]
 
-        # Check if any of the required columns are None
-        if any(col is None for col in self.required_columns):
-            raise MissingColumnError(
-                f"{self.error_string}\n"
-                f"{self.equation_string}\n"
-                f"{self.description_string}\n"
-                f"{self.required_column_description}\n"
-                f"Missing columns: {self.required_columns}"
-            )
-
-        # Ensure all required columns are strings
-        self.required_columns = [str(col) for col in self.required_columns]
-
-        self.mapped_columns = (
-            f"Your config dictionary is mapped as: {', '.join(self.required_columns)}"
-        )
-
-    def get_required_columns(self) -> str:
-        """Returns a string representation of the required columns."""
-        return (
-            f"{self.equation_string}"
-            f"{self.description_string}\n"
-            f"{self.required_column_description}\n"
-            f"{self.mapped_columns}"
-        )
-
-    def calculate_erv_efficiency(self, df: pd.DataFrame) -> pd.DataFrame:
-        # Calculate the temperature differences
-        delta_temp_oa = df[self.erv_oat_leaving_col] - df[self.erv_oat_enter_col]
-        delta_temp_ea = df[self.erv_eat_enter_col] - df[self.erv_oat_enter_col]
-
-        # Use the absolute value to handle both heating and cooling applications
-        df["erv_efficiency_oa"] = np.abs(delta_temp_oa) / np.abs(delta_temp_ea)
-
-        return df
-
+    @FaultConditionMixin._handle_errors
     def apply(self, df: pd.DataFrame) -> pd.DataFrame:
-        try:
-            # Calculate ERV efficiency
-            df = self.calculate_erv_efficiency(df)
-
-            # Fan must be on for a fault to be considered
-            fan_on = df[self.supply_vfd_speed_col] > 0.1
+        """Apply the fault condition to the DataFrame."""
+        # Apply common checks
+        self._apply_common_checks(df)
 
-            # Combined heating and cooling checks
-            cold_outside = df[self.erv_oat_enter_col] <= self.oat_low_threshold
-            hot_outside = df[self.erv_oat_enter_col] >= self.oat_high_threshold
+        # Check analog outputs [data with units of %] are floats only
+        columns_to_check = [self.supply_vfd_speed_col]
+        self._apply_analog_checks(df, columns_to_check)
 
-            heating_fault = (
-                (
-                    (df["erv_efficiency_oa"] < self.erv_efficiency_min_heating)
-                    | (df["erv_efficiency_oa"] > self.erv_efficiency_max_heating)
-                )
-                & cold_outside
-                & fan_on
-            )
+        # Calculate temperature differences
+        oat_rat_delta = abs(df[self.erv_oat_enter_col] - df[self.erv_eat_enter_col])
 
-            cooling_fault = (
-                (
-                    (df["erv_efficiency_oa"] < self.erv_efficiency_min_cooling)
-                    | (df["erv_efficiency_oa"] > self.erv_efficiency_max_cooling)
-                )
-                & hot_outside
-                & fan_on
-            )
+        # Calculate ERV effectiveness
+        # ε = (T_leaving - T_entering) / (T_exhaust - T_entering)
+        erv_effectiveness = (
+            df[self.erv_oat_leaving_col] - df[self.erv_oat_enter_col]
+        ) / (df[self.erv_eat_enter_col] - df[self.erv_oat_enter_col])
 
-            df["combined_checks"] = heating_fault | cooling_fault
+        # Determine operating mode based on OAT
+        heating_mode = df[self.erv_oat_enter_col] < self.oat_low_threshold
+        cooling_mode = df[self.erv_oat_enter_col] > self.oat_high_threshold
 
-            # Apply rolling sum
-            df["fc16_flag"] = (
-                df["combined_checks"]
-                .rolling(window=self.rolling_window_size)
-                .sum()
-                .ge(self.rolling_window_size)
-                .astype(int)
-            )
+        # Check effectiveness against thresholds
+        low_effectiveness_htg = heating_mode & (
+            erv_effectiveness < self.erv_efficiency_min_heating
+        )
+        high_effectiveness_htg = heating_mode & (
+            erv_effectiveness > self.erv_efficiency_max_heating
+        )
+        low_effectiveness_clg = cooling_mode & (
+            erv_effectiveness < self.erv_efficiency_min_cooling
+        )
+        high_effectiveness_clg = cooling_mode & (
+            erv_effectiveness > self.erv_efficiency_max_cooling
+        )
 
-            if self.troubleshoot_mode:
-                print("Troubleshoot mode enabled - not removing helper columns")
-                sys.stdout.flush()
-
-            # Drop helper cols if not in troubleshoot mode
-            if not self.troubleshoot_mode:
-                df.drop(
-                    columns=[
-                        "combined_checks",
-                        "erv_efficiency_oa",
-                    ],
-                    inplace=True,
-                )
+        # 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 >= self.oat_rat_delta_min) & (
+            low_effectiveness_htg
+            | high_effectiveness_htg
+            | low_effectiveness_clg
+            | high_effectiveness_clg
+        )
 
-            return df
+        # Set fault flag
+        self._set_fault_flag(df, combined_check, "fc16_flag")
 
-        except MissingColumnError as e:
-            print(f"Error: {e.message}")
-            sys.stdout.flush()
-            raise e
-        except InvalidParameterError as e:
-            print(f"Error: {e.message}")
-            sys.stdout.flush()
-            raise e
+        return df