open-fdd 0.1.5__py3-none-any.whl → 0.1.7__py3-none-any.whl

open_fdd/air_handling_unit/faults/__init__.py

@@ -5,6 +5,7 @@ from open_fdd.air_handling_unit.faults.fault_condition import (
     MissingColumnError,
     InvalidParameterError,
 )
+from open_fdd.air_handling_unit.faults.helper_utils import SharedUtils
 import operator
 import sys
 
@@ -12,6 +13,8 @@ import sys
 class FaultConditionOne(FaultCondition):
     """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_):
@@ -101,34 +104,25 @@ class FaultConditionOne(FaultCondition):
             columns_to_check = [self.supply_vfd_speed_col]
             self.check_analog_pct(df, columns_to_check)
 
-            df["static_check_"] = (
+            # Perform checks
+            static_check = (
                 df[self.duct_static_col]
                 < df[self.duct_static_setpoint_col] - self.duct_static_inches_err_thres
             )
-            df["fan_check_"] = (
+            fan_check = (
                 df[self.supply_vfd_speed_col]
                 >= self.vfd_speed_percent_max - self.vfd_speed_percent_err_thres
             )
 
             # Combined condition check
-            df["combined_check"] = df["static_check_"] & df["fan_check_"]
+            combined_check = static_check & fan_check
 
             # Rolling sum to count consecutive trues
-            rolling_sum = (
-                df["combined_check"].rolling(window=self.rolling_window_size).sum()
-            )
+            rolling_sum = combined_check.rolling(window=self.rolling_window_size).sum()
+
             # Set flag to 1 if rolling sum equals the window size
             df["fc1_flag"] = (rolling_sum == self.rolling_window_size).astype(int)
 
-            if self.troubleshoot_mode:
-                print("Troubleshoot mode enabled - not removing helper columns")
-                sys.stdout.flush()
-
-            # Optionally remove temporary columns
-            df.drop(
-                columns=["static_check_", "fan_check_", "combined_check"], inplace=True
-            )
-
             return df
 
         except MissingColumnError as e:
@@ -232,33 +226,23 @@ class FaultConditionTwo(FaultCondition):
             columns_to_check = [self.supply_vfd_speed_col]
             self.check_analog_pct(df, columns_to_check)
 
-            # Fault condition-specific checks / flags
-            df["mat_check"] = df[self.mat_col] + self.mix_degf_err_thres
-            df["temp_min_check"] = np.minimum(
+            # 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,
             )
 
-            df["combined_check"] = (df["mat_check"] < df["temp_min_check"]) & (
+            combined_check = (mat_check < temp_min_check) & (
                 df[self.supply_vfd_speed_col] > 0.01
             )
 
             # Rolling sum to count consecutive trues
-            rolling_sum = (
-                df["combined_check"].rolling(window=self.rolling_window_size).sum()
-            )
+            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)
 
-            if self.troubleshoot_mode:
-                print("Troubleshoot mode enabled - not removing helper columns")
-                sys.stdout.flush()
-
-            # Optionally remove temporary columns
-            df.drop(
-                columns=["mat_check", "temp_min_check", "combined_check"], inplace=True
-            )
-
             return df
 
         except MissingColumnError as e:
@@ -362,33 +346,23 @@ class FaultConditionThree(FaultCondition):
             columns_to_check = [self.supply_vfd_speed_col]
             self.check_analog_pct(df, columns_to_check)
 
-            # Fault condition-specific checks / flags
-            df["mat_check"] = df[self.mat_col] - self.mix_degf_err_thres
-            df["temp_max_check"] = np.maximum(
+            # 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,
             )
 
-            df["combined_check"] = (df["mat_check"] > df["temp_max_check"]) & (
+            combined_check = (mat_check > temp_max_check) & (
                 df[self.supply_vfd_speed_col] > 0.01
             )
 
             # Rolling sum to count consecutive trues
-            rolling_sum = (
-                df["combined_check"].rolling(window=self.rolling_window_size).sum()
-            )
+            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)
 
-            if self.troubleshoot_mode:
-                print("Troubleshoot mode enabled - not removing helper columns")
-                sys.stdout.flush()
-
-            # Optionally remove temporary columns
-            df.drop(
-                columns=["mat_check", "temp_max_check", "combined_check"], inplace=True
-            )
-
             return df
 
         except MissingColumnError as e:
@@ -675,40 +649,28 @@ class FaultConditionFive(FaultCondition):
             # 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.heating_sig_col]
+            self.check_analog_pct(df, columns_to_check)
 
-            for col in columns_to_check:
-                self.check_analog_pct(df, [col])
-
-            df["sat_check"] = df[self.sat_col] + self.supply_degf_err_thres
-            df["mat_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
             )
 
-            df["combined_check"] = (
-                (df["sat_check"] <= df["mat_check"])
+            combined_check = (
+                (sat_check <= mat_check)
                 & (df[self.heating_sig_col] > 0.01)
                 & (df[self.supply_vfd_speed_col] > 0.01)
             )
 
             # Rolling sum to count consecutive trues
-            rolling_sum = (
-                df["combined_check"].rolling(window=self.rolling_window_size).sum()
-            )
+            rolling_sum = combined_check.rolling(window=self.rolling_window_size).sum()
+
             # Set flag to 1 if rolling sum equals the window size
             df["fc5_flag"] = (rolling_sum == self.rolling_window_size).astype(int)
 
-            if self.troubleshoot_mode:
-                print("Troubleshoot mode enabled - not removing helper columns")
-                sys.stdout.flush()
-
-            # Optionally remove temporary columns
-            df.drop(columns=["mat_check", "sat_check", "combined_check"], inplace=True)
-
             return df
 
         except MissingColumnError as e:
@@ -839,8 +801,12 @@ class FaultConditionSix(FaultCondition):
             # Ensure all required columns are present
             self.check_required_columns(df)
 
-            if self.troubleshoot_mode:
-                self.troubleshoot_cols(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()
 
             # Check analog outputs [data with units of %] are floats only
             columns_to_check = [
@@ -849,75 +815,45 @@ class FaultConditionSix(FaultCondition):
                 self.heating_sig_col,
                 self.cooling_sig_col,
             ]
+            self.check_analog_pct(df, columns_to_check)
 
-            for col in columns_to_check:
-                self.check_analog_pct(df, [col])
-
-            # Create helper columns
-            df["rat_minus_oat"] = abs(df[self.rat_col] - df[self.oat_col])
-            df["percent_oa_calc"] = (df[self.mat_col] - df[self.rat_col]) / (
+            # 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]
             )
 
-            # Weed out any negative values
-            df["percent_oa_calc"] = df["percent_oa_calc"].apply(
-                lambda x: x if x > 0 else 0
-            )
+            # Replace negative values in percent_oa_calc with zero using vectorized operation
+            percent_oa_calc = percent_oa_calc.clip(lower=0)
 
-            df["perc_OAmin"] = (
-                self.ahu_min_oa_cfm_design / df[self.supply_fan_air_volume_col]
-            )
+            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)
 
-            df["percent_oa_calc_minus_perc_OAmin"] = abs(
-                df["percent_oa_calc"] - df["perc_OAmin"]
+            # 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)
             )
 
-            df["combined_check"] = operator.or_(
-                # OS 1 htg mode
-                (
-                    (df["rat_minus_oat"] >= self.oat_rat_delta_min)
-                    & (df["percent_oa_calc_minus_perc_OAmin"] > self.airflow_err_thres)
-                )
-                # Verify AHU is running in OS 1 htg mode in min OA
-                & (
-                    (df[self.heating_sig_col] > 0.0)
-                    & (df[self.supply_vfd_speed_col] > 0.0)
-                ),  # OR
-                # OS 4 mech clg mode
-                (
-                    (df["rat_minus_oat"] >= self.oat_rat_delta_min)
-                    & (df["percent_oa_calc_minus_perc_OAmin"] > self.airflow_err_thres)
-                )
-                # Verify AHU is running in OS 4 clg mode in min OA
+            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),
+                & (df[self.economizer_sig_col] == self.ahu_min_oa_dpr)
             )
 
+            combined_check = os1_htg_mode_check | os4_clg_mode_check
+
             # Rolling sum to count consecutive trues
-            rolling_sum = (
-                df["combined_check"].rolling(window=self.rolling_window_size).sum()
-            )
+            rolling_sum = combined_check.rolling(window=self.rolling_window_size).sum()
+
             # Set flag to 1 if rolling sum equals the window size
             df["fc6_flag"] = (rolling_sum == self.rolling_window_size).astype(int)
 
-            if self.troubleshoot_mode:
-                print("Troubleshoot mode enabled - not removing helper columns")
-                sys.stdout.flush()
-
-            # Optionally remove temporary columns
-            df.drop(
-                columns=[
-                    "rat_minus_oat",
-                    "percent_oa_calc",
-                    "perc_OAmin",
-                    "percent_oa_calc_minus_perc_OAmin",
-                    "combined_check",
-                ],
-                inplace=True,
-            )
-
             return df
 
         except MissingColumnError as e:
@@ -1013,36 +949,25 @@ class FaultConditionSeven(FaultCondition):
             # 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.heating_sig_col]
             self.check_analog_pct(df, columns_to_check)
 
-            # Fault condition-specific checks / flags
-            df["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
 
-            df["combined_check"] = (
-                (df[self.sat_col] < df["sat_check"])
+            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 = (
-                df["combined_check"].rolling(window=self.rolling_window_size).sum()
-            )
+            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)
 
-            if self.troubleshoot_mode:
-                print("Troubleshoot mode enabled - not removing helper columns")
-                sys.stdout.flush()
-
-            # Optionally remove temporary columns
-            df.drop(columns=["sat_check", "combined_check"], inplace=True)
-
             return df
 
         except MissingColumnError as e:
@@ -1147,9 +1072,6 @@ class FaultConditionEight(FaultCondition):
             # 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,
@@ -1157,36 +1079,26 @@ class FaultConditionEight(FaultCondition):
             ]
             self.check_analog_pct(df, columns_to_check)
 
-            df["sat_fan_mat"] = abs(
+            # Perform checks
+            sat_fan_mat = abs(
                 df[self.sat_col] - self.delta_t_supply_fan - df[self.mat_col]
             )
-            df["sat_mat_sqrted"] = np.sqrt(
+            sat_mat_sqrted = np.sqrt(
                 self.supply_degf_err_thres**2 + self.mix_degf_err_thres**2
             )
 
-            df["combined_check"] = (
-                (df["sat_fan_mat"] > df["sat_mat_sqrted"])
+            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)
             )
 
             # Rolling sum to count consecutive trues
-            rolling_sum = (
-                df["combined_check"].rolling(window=self.rolling_window_size).sum()
-            )
+            rolling_sum = combined_check.rolling(window=self.rolling_window_size).sum()
+
             # Set flag to 1 if rolling sum equals the window size
             df["fc8_flag"] = (rolling_sum >= self.rolling_window_size).astype(int)
 
-            if self.troubleshoot_mode:
-                print("Troubleshoot mode enabled - not removing helper columns")
-                sys.stdout.flush()
-
-            # Optionally remove temporary columns
-            df.drop(
-                columns=["sat_fan_mat", "sat_mat_sqrted", "combined_check"],
-                inplace=True,
-            )
-
             return df
 
         except MissingColumnError as e:
@@ -1291,9 +1203,6 @@ class FaultConditionNine(FaultCondition):
             # 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,
@@ -1301,38 +1210,27 @@ class FaultConditionNine(FaultCondition):
             ]
             self.check_analog_pct(df, columns_to_check)
 
-            # Create helper columns
-            df["oat_minus_oaterror"] = df[self.oat_col] - self.outdoor_degf_err_thres
-            df["satsp_delta_saterr"] = (
+            # 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
             )
 
-            df["combined_check"] = (
-                (df["oat_minus_oaterror"] > df["satsp_delta_saterr"])
+            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)
             )
 
             # Rolling sum to count consecutive trues
-            rolling_sum = (
-                df["combined_check"].rolling(window=self.rolling_window_size).sum()
-            )
+            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)
 
-            if self.troubleshoot_mode:
-                print("Troubleshoot mode enabled - not removing helper columns")
-                sys.stdout.flush()
-
-            # Optionally remove temporary columns
-            df.drop(
-                columns=["oat_minus_oaterror", "satsp_delta_saterr", "combined_check"],
-                inplace=True,
-            )
-
             return df
 
         except MissingColumnError as e:
@@ -1433,9 +1331,6 @@ class FaultConditionTen(FaultCondition):
             # 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,
@@ -1443,35 +1338,25 @@ class FaultConditionTen(FaultCondition):
             ]
             self.check_analog_pct(df, columns_to_check)
 
-            df["abs_mat_minus_oat"] = abs(df[self.mat_col] - df[self.oat_col])
-            df["mat_oat_sqrted"] = np.sqrt(
+            # 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
             )
 
-            df["combined_check"] = (
-                (df["abs_mat_minus_oat"] > df["mat_oat_sqrted"])
-                # verify AHU is running in OS 3 clg mode in min OA
+            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 = (
-                df["combined_check"].rolling(window=self.rolling_window_size).sum()
-            )
+            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)
 
-            if self.troubleshoot_mode:
-                print("Troubleshoot mode enabled - not removing helper columns")
-                sys.stdout.flush()
-
-            # Optionally remove temporary columns
-            df.drop(
-                columns=["abs_mat_minus_oat", "mat_oat_sqrted", "combined_check"],
-                inplace=True,
-            )
-
             return df
 
         except MissingColumnError as e:
@@ -1575,9 +1460,6 @@ class FaultConditionEleven(FaultCondition):
             # 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,
@@ -1585,37 +1467,27 @@ class FaultConditionEleven(FaultCondition):
             ]
             self.check_analog_pct(df, columns_to_check)
 
-            df["oat_plus_oaterror"] = df[self.oat_col] + self.outdoor_degf_err_thres
-            df["satsp_delta_saterr"] = (
+            # 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
             )
 
-            df["combined_check"] = (
-                (df["oat_plus_oaterror"] < df["satsp_delta_saterr"])
-                # verify ahu is running in OS 3 clg mode in 100 OA
+            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)
             )
 
             # Rolling sum to count consecutive trues
-            rolling_sum = (
-                df["combined_check"].rolling(window=self.rolling_window_size).sum()
-            )
+            rolling_sum = combined_check.rolling(window=self.rolling_window_size).sum()
+
             # Set flag to 1 if rolling sum equals the window size
             df["fc11_flag"] = (rolling_sum >= self.rolling_window_size).astype(int)
 
-            if self.troubleshoot_mode:
-                print("Troubleshoot mode enabled - not removing helper columns")
-                sys.stdout.flush()
-
-            # Optionally remove temporary columns
-            df.drop(
-                columns=["oat_plus_oaterror", "satsp_delta_saterr", "combined_check"],
-                inplace=True,
-            )
-
             return df
 
         except MissingColumnError as e:
@@ -1720,9 +1592,6 @@ class FaultConditionTwelve(FaultCondition):
             # 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,
@@ -1730,45 +1599,32 @@ class FaultConditionTwelve(FaultCondition):
             ]
             self.check_analog_pct(df, columns_to_check)
 
-            # Create helper columns
-            df["sat_minus_saterr_delta_supply_fan"] = (
+            # 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
             )
-            df["mat_plus_materr"] = df[self.mat_col] + self.mix_degf_err_thres
+            mat_plus_materr = df[self.mat_col] + self.mix_degf_err_thres
 
-            df["combined_check"] = operator.or_(
-                # OS4 AHU state clg @ min OA
-                (df["sat_minus_saterr_delta_supply_fan"] > df["mat_plus_materr"])
-                # verify AHU in OS4 mode
+            # 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
-                (df["sat_minus_saterr_delta_supply_fan"] > df["mat_plus_materr"])
-                # verify AHU is running in OS 3 clg mode in 100 OA
+                & (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),
             )
 
             # Rolling sum to count consecutive trues
-            rolling_sum = (
-                df["combined_check"].rolling(window=self.rolling_window_size).sum()
-            )
+            rolling_sum = combined_check.rolling(window=self.rolling_window_size).sum()
+
             # Set flag to 1 if rolling sum equals the window size
             df["fc12_flag"] = (rolling_sum >= self.rolling_window_size).astype(int)
 
-            if self.troubleshoot_mode:
-                print("Troubleshoot mode enabled - not removing helper columns")
-                sys.stdout.flush()
-
-            # Optionally remove temporary columns
-            df.drop(
-                columns=[
-                    "sat_minus_saterr_delta_supply_fan",
-                    "mat_plus_materr",
-                    "combined_check",
-                ],
-                inplace=True,
-            )
-
             return df
 
         except MissingColumnError as e:
@@ -1869,9 +1725,6 @@ class FaultConditionThirteen(FaultCondition):
             # 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,
@@ -1879,40 +1732,30 @@ class FaultConditionThirteen(FaultCondition):
             ]
             self.check_analog_pct(df, columns_to_check)
 
-            # Create helper columns
-            df["sat_greater_than_sp_calc"] = (
+            # 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
             )
 
-            df["combined_check"] = operator.or_(
-                ((df["sat_greater_than_sp_calc"]))
-                # OS4 AHU state clg @ min OA
+            # 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
-                ((df["sat_greater_than_sp_calc"]))
-                # verify ahu is running in OS 3 clg mode in 100 OA
+                & (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 = (
-                df["combined_check"].rolling(window=self.rolling_window_size).sum()
-            )
+            rolling_sum = combined_check.rolling(window=self.rolling_window_size).sum()
+
             # Set flag to 1 if rolling sum equals the window size
             df["fc13_flag"] = (rolling_sum >= self.rolling_window_size).astype(int)
 
-            if self.troubleshoot_mode:
-                print("Troubleshoot mode enabled - not removing helper columns")
-                sys.stdout.flush()
-
-            # Optionally remove temporary columns
-            df.drop(
-                columns=["sat_greater_than_sp_calc", "combined_check"],
-                inplace=True,
-            )
-
             return df
 
         except MissingColumnError as e:
@@ -2020,9 +1863,6 @@ class FaultConditionFourteen(FaultCondition):
             # 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,
@@ -2032,46 +1872,33 @@ class FaultConditionFourteen(FaultCondition):
             ]
             self.check_analog_pct(df, columns_to_check)
 
-            # Create helper columns
-            df["clg_delta_temp"] = (
+            # Calculate necessary checks
+            clg_delta_temp = (
                 df[self.clg_coil_enter_temp_col] - df[self.clg_coil_leave_temp_col]
             )
-
-            df["clg_delta_sqrted"] = (
+            clg_delta_sqrted = (
                 np.sqrt(
                     self.coil_temp_enter_err_thres**2 + self.coil_temp_leav_err_thres**2
                 )
                 + self.delta_t_supply_fan
             )
 
-            df["combined_check"] = operator.or_(
-                (df["clg_delta_temp"] >= df["clg_delta_sqrted"])
-                # verify AHU is in OS2 only free cooling mode
+            # 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
-                (df["clg_delta_temp"] >= df["clg_delta_sqrted"])
-                # verify AHU is running in OS 1 at near full heat
+                (clg_delta_temp >= clg_delta_sqrted)
                 & (df[self.heating_sig_col] > 0.0)
                 & (df[self.supply_vfd_speed_col] > 0.0),
             )
 
             # Rolling sum to count consecutive trues
-            rolling_sum = (
-                df["combined_check"].rolling(window=self.rolling_window_size).sum()
-            )
+            rolling_sum = combined_check.rolling(window=self.rolling_window_size).sum()
+
             # Set flag to 1 if rolling sum equals the window size
             df["fc14_flag"] = (rolling_sum >= self.rolling_window_size).astype(int)
 
-            if self.troubleshoot_mode:
-                print("Troubleshoot mode enabled - not removing helper columns")
-                sys.stdout.flush()
-
-            # Optionally remove temporary columns
-            df.drop(
-                columns=["clg_delta_temp", "clg_delta_sqrted", "combined_check"],
-                inplace=True,
-            )
-
             return df
 
         except MissingColumnError as e:
@@ -2251,3 +2078,207 @@ class FaultConditionFifteen(FaultCondition):
             print(f"Error: {e.message}")
             sys.stdout.flush()
             raise e
+
+
+class FaultConditionSixteen(FaultCondition):
+    """Class provides the definitions for Fault Condition 16.
+    ERV Ineffective Process based on outdoor air temperature ranges.
+    """
+
+    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)
+
+        self.oat_low_threshold = dict_.get("OAT_LOW_THRES", 32.0)
+        self.oat_high_threshold = dict_.get("OAT_HIGH_THRES", 80.0)
+        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
+        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),
+            ("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):
+                raise InvalidParameterError(
+                    f"The parameter '{param}' should be a float between 0.0 and 1.0 to represent a percentage, 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.equation_string = (
+            "fc16_flag = 1 if temperature deltas and expected efficiency is ineffective "
+            "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."
+        )
+        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."
+        )
+        self.error_string = "One or more required columns are missing or None."
+
+        self.set_attributes(dict_)
+
+        # Set required columns specific to this fault condition
+        self.required_columns = [
+            self.erv_oat_enter_col,
+            self.erv_oat_leaving_col,
+            self.erv_eat_enter_col,
+            self.erv_eat_leaving_col,
+            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:
+
+        df = SharedUtils.clean_nan_values(df)
+
+        cols_to_check = [self.erv_eat_enter_col, self.erv_oat_enter_col]
+        if df[cols_to_check].eq(0).any().any():
+            print(f"Warning: Zero values found in columns: {cols_to_check}")
+            print(f"This may cause division by zero errors.")
+            sys.stdout.flush()
+
+        # 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
+
+    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
+
+            # Determine if the conditions are for heating or cooling based on OAT
+            cold_outside = df[self.erv_oat_enter_col] <= self.oat_low_threshold
+            hot_outside = df[self.erv_oat_enter_col] >= self.oat_high_threshold
+
+            # Calculate the temperature difference between the exhaust air entering and outside air entering
+            rat_minus_oat = abs(df[self.erv_eat_enter_col] - df[self.erv_oat_enter_col])
+            good_delta_check = rat_minus_oat >= self.oat_rat_delta_min
+
+            # Initialize the fault condition to False (no fault)
+            df["fc16_flag"] = 0
+
+            # Apply heating fault logic
+            heating_fault = (
+                (
+                    (df["erv_efficiency_oa"] < self.erv_efficiency_min_heating)
+                    | (df["erv_efficiency_oa"] > self.erv_efficiency_max_heating)
+                )
+                & cold_outside
+                & good_delta_check
+                & fan_on
+            )
+
+            # Apply cooling fault logic
+            cooling_fault = (
+                (
+                    (df["erv_efficiency_oa"] < self.erv_efficiency_min_cooling)
+                    | (df["erv_efficiency_oa"] > self.erv_efficiency_max_cooling)
+                )
+                & hot_outside
+                & good_delta_check
+                & fan_on
+            )
+
+            # Combine the faults
+            df["combined_checks"] = heating_fault | cooling_fault
+
+            # Apply rolling sum to combined checks to account for rolling window
+            df["fc16_flag"] = (
+                df["combined_checks"]
+                .rolling(window=self.rolling_window_size)
+                .sum()
+                .ge(self.rolling_window_size)
+                .astype(int)
+            )
+
+            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,
+                )
+
+            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