open-fdd 0.1.0__py3-none-any.whl

open_fdd/air_handling_unit/faults/helper_utils.py

@@ -0,0 +1,191 @@
+import sys
+from open_fdd.air_handling_unit.faults.shared_utils import SharedUtils
+import pandas as pd
+
+
+class HelperUtils:
+    def float_int_check_err(self, col):
+        return SharedUtils.float_int_check_err(col)
+
+    def float_max_check_err(self, col):
+        return SharedUtils.float_max_check_err(col)
+
+    def isfloat(self, num):
+        return SharedUtils.isfloat(num)
+
+    def isLessThanOnePointOne(self, num):
+        return SharedUtils.isLessThanOnePointOne(num)
+
+    def convert_to_float(self, df, col):
+        return SharedUtils.convert_to_float(df, col)
+
+    def apply_rolling_average_if_needed(self, df, freq="1min", rolling_window="5min"):
+        return SharedUtils.apply_rolling_average_if_needed(df, freq, rolling_window)
+
+    def process_all_faults(self, df, config_dict):
+        # Import fault conditions
+        from open_fdd.air_handling_unit.faults.fault_condition_one import (
+            FaultConditionOne,
+        )
+        from open_fdd.air_handling_unit.faults.fault_condition_two import (
+            FaultConditionTwo,
+        )
+        from open_fdd.air_handling_unit.faults.fault_condition_three import (
+            FaultConditionThree,
+        )
+        from open_fdd.air_handling_unit.faults.fault_condition_four import (
+            FaultConditionFour,
+        )
+        from open_fdd.air_handling_unit.faults.fault_condition_five import (
+            FaultConditionFive,
+        )
+        from open_fdd.air_handling_unit.faults.fault_condition_six import (
+            FaultConditionSix,
+        )
+        from open_fdd.air_handling_unit.faults.fault_condition_seven import (
+            FaultConditionSeven,
+        )
+        from open_fdd.air_handling_unit.faults.fault_condition_eight import (
+            FaultConditionEight,
+        )
+        from open_fdd.air_handling_unit.faults.fault_condition_nine import (
+            FaultConditionNine,
+        )
+        from open_fdd.air_handling_unit.faults.fault_condition_ten import (
+            FaultConditionTen,
+        )
+        from open_fdd.air_handling_unit.faults.fault_condition_eleven import (
+            FaultConditionEleven,
+        )
+        from open_fdd.air_handling_unit.faults.fault_condition_twelve import (
+            FaultConditionTwelve,
+        )
+        from open_fdd.air_handling_unit.faults.fault_condition_thirteen import (
+            FaultConditionThirteen,
+        )
+        from open_fdd.air_handling_unit.faults.fault_condition_fourteen import (
+            FaultConditionFourteen,
+        )
+        from open_fdd.air_handling_unit.faults.fault_condition_fifteen import (
+            FaultConditionFifteen,
+        )
+
+        fault_counts = {}
+
+        # Apply rolling average if needed
+        df = self.apply_rolling_average_if_needed(df)
+
+        # Initialize Fault Condition Classes
+        fc1 = FaultConditionOne(config_dict)
+        fc2 = FaultConditionTwo(config_dict)
+        fc3 = FaultConditionThree(config_dict)
+        fc4 = FaultConditionFour(config_dict)
+        fc5 = FaultConditionFive(config_dict)
+        fc7 = FaultConditionSeven(config_dict)
+        fc8 = FaultConditionEight(config_dict)
+        fc9 = FaultConditionNine(config_dict)
+        fc10 = FaultConditionTen(config_dict)
+        fc11 = FaultConditionEleven(config_dict)
+        fc12 = FaultConditionTwelve(config_dict)
+        fc13 = FaultConditionThirteen(config_dict)
+
+        # Optionally initialize Fault Condition Six
+        fc6 = None
+        if config_dict.get("SUPPLY_FAN_AIR_VOLUME_COL") is not None:
+            fc6 = FaultConditionSix(config_dict)
+
+        # Optionally initialize Fault Condition Fourteen
+        fc14 = None
+        if (
+            config_dict.get("COOLING_SIG_COL") is not None
+            and config_dict.get("CLG_COIL_LEAVE_TEMP_COL") is not None
+        ):
+            fc14 = FaultConditionFourteen(config_dict)
+
+        # Optionally initialize Fault Condition Fifteen
+        fc15 = None
+        if (
+            config_dict.get("HTG_COIL_ENTER_TEMP_COL") is not None
+            and config_dict.get("HTG_COIL_LEAVE_TEMP_COL") is not None
+        ):
+            fc15 = FaultConditionFifteen(config_dict)
+
+        # Apply fault conditions and calculate fault counts
+        df_fc1 = fc1.apply(df.copy())
+        fault_counts["fc1_fault_sum"] = df_fc1["fc1_flag"].sum()
+
+        df_fc2 = fc2.apply(df.copy())
+        fault_counts["fc2_fault_sum"] = df_fc2["fc2_flag"].sum()
+
+        df_fc3 = fc3.apply(df.copy())
+        fault_counts["fc3_fault_sum"] = df_fc3["fc3_flag"].sum()
+
+        df_fc4 = fc4.apply(df.copy())
+        fault_counts["fc4_fault_sum"] = df_fc4["fc4_flag"].sum()
+
+        df_fc5 = fc5.apply(df.copy())
+        fault_counts["fc5_fault_sum"] = df_fc5["fc5_flag"].sum()
+
+        if fc6 is not None:
+            df_fc6 = fc6.apply(df.copy())
+            fault_counts["fc6_fault_sum"] = df_fc6["fc6_flag"].sum()
+
+        df_fc7 = fc7.apply(df.copy())
+        fault_counts["fc7_fault_sum"] = df_fc7["fc7_flag"].sum()
+
+        df_fc8 = fc8.apply(df.copy())
+        fault_counts["fc8_fault_sum"] = df_fc8["fc8_flag"].sum()
+
+        df_fc9 = fc9.apply(df.copy())
+        fault_counts["fc9_fault_sum"] = df_fc9["fc9_flag"].sum()
+
+        df_fc10 = fc10.apply(df.copy())
+        fault_counts["fc10_fault_sum"] = df_fc10["fc10_flag"].sum()
+
+        df_fc11 = fc11.apply(df.copy())
+        fault_counts["fc11_fault_sum"] = df_fc11["fc11_flag"].sum()
+
+        df_fc12 = fc12.apply(df.copy())
+        fault_counts["fc12_fault_sum"] = df_fc12["fc12_flag"].sum()
+
+        df_fc13 = fc13.apply(df.copy())
+        fault_counts["fc13_fault_sum"] = df_fc13["fc13_flag"].sum()
+
+        if fc14 is not None:
+            df_fc14 = fc14.apply(df.copy())
+            fault_counts["fc14_fault_sum"] = df_fc14["fc14_flag"].sum()
+
+        if fc15 is not None:
+            df_fc15 = fc15.apply(df.copy())
+            fault_counts["fc15_fault_sum"] = df_fc15["fc15_flag"].sum()
+
+        # Combine fault condition results
+        df_combined = df_fc1.copy()
+        df_combined["fc2_flag"] = df_fc2["fc2_flag"]
+        df_combined["fc3_flag"] = df_fc3["fc3_flag"]
+        df_combined["fc4_flag"] = df_fc4["fc4_flag"]
+        df_combined["fc5_flag"] = df_fc5["fc5_flag"]
+
+        if fc6 is not None:
+            df_combined["fc6_flag"] = df_fc6["fc6_flag"]
+
+        df_combined["fc7_flag"] = df_fc7["fc7_flag"]
+        df_combined["fc8_flag"] = df_fc8["fc8_flag"]
+        df_combined["fc9_flag"] = df_fc9["fc9_flag"]
+        df_combined["fc10_flag"] = df_fc10["fc10_flag"]
+        df_combined["fc11_flag"] = df_fc11["fc11_flag"]
+        df_combined["fc12_flag"] = df_fc12["fc12_flag"]
+        df_combined["fc13_flag"] = df_fc13["fc13_flag"]
+
+        if fc14 is not None:
+            df_combined["fc14_flag"] = df_fc14["fc14_flag"]
+
+        if fc15 is not None:
+            df_combined["fc15_flag"] = df_fc15["fc15_flag"]
+
+        # Save fault counts to CSV
+        fault_counts_df = pd.DataFrame(
+            list(fault_counts.items()), columns=["Fault Condition", "Count"]
+        )
+
+        return df_combined, df_fc4, fault_counts_df

open_fdd/air_handling_unit/faults/shared_utils.py

@@ -0,0 +1,75 @@
+import pandas as pd
+import pandas.api.types as pdtypes
+import sys
+
+
+class SharedUtils:
+    @staticmethod
+    def float_int_check_err(col):
+        err_str = " column failed with a check that the data is a float"
+        return str(col) + err_str
+
+    @staticmethod
+    def float_max_check_err(col):
+        err_str = (
+            " column failed with a check that the data is a float between 0.0 and 1.0"
+        )
+        return str(col) + err_str
+
+    @staticmethod
+    def isfloat(num):
+        try:
+            float(num)
+            return True
+        except:
+            return False
+
+    @staticmethod
+    def isLessThanOnePointOne(num):
+        try:
+            if num <= 1.0:
+                return True
+        except:
+            return False
+
+    @staticmethod
+    def convert_to_float(df, col):
+        if not pdtypes.is_float_dtype(df[col]):
+            try:
+                df[col] = df[col].astype(float)
+            except ValueError:
+                raise TypeError(SharedUtils.float_int_check_err(col))
+        return df
+
+    @staticmethod
+    def apply_rolling_average_if_needed(df, freq="1min", rolling_window="5min"):
+        """Apply rolling average if time difference between consecutive
+        timestamps is not greater than the specified frequency.
+        """
+
+        print(
+            "Warning: If data has a one minute or less sampling frequency a rolling average will be automatically applied"
+        )
+        sys.stdout.flush()
+
+        time_diff = df.index.to_series().diff().iloc[1:]
+
+        # Calculate median time difference to avoid being affected by outliers
+        median_diff = time_diff.median()
+
+        print(
+            f"Warning: Median time difference between consecutive timestamps is {median_diff}."
+        )
+        sys.stdout.flush()
+
+        if median_diff > pd.Timedelta(freq):
+            print(f"Warning: Skipping any rolling averaging...")
+            sys.stdout.flush()
+
+        else:
+            df = df.rolling(rolling_window).mean()
+            print(
+                f"Warning: A {rolling_window} rolling average has been applied to the data."
+            )
+            sys.stdout.flush()
+        return df

open_fdd/air_handling_unit/reports/report_fc1.py

@@ -0,0 +1,115 @@
+import matplotlib.pyplot as plt
+import pandas as pd
+import sys
+
+
+class FaultCodeOneReport:
+    def __init__(self, config):
+        self.vfd_speed_percent_err_thres = config["VFD_SPEED_PERCENT_ERR_THRES"]
+        self.duct_static_col = config["DUCT_STATIC_COL"]
+        self.supply_vfd_speed_col = config["SUPPLY_VFD_SPEED_COL"]
+        self.duct_static_setpoint_col = config["DUCT_STATIC_SETPOINT_COL"]
+
+    def create_plot(self, df: pd.DataFrame, output_col: str = None):
+        if output_col is None:
+            output_col = "fc1_flag"
+
+        fig, (ax1, ax2, ax3) = plt.subplots(3, 1, figsize=(25, 8))
+        fig.suptitle("Fault Conditions 1 Plot")
+
+        ax1.plot(df.index, df[self.duct_static_col], label="STATIC")
+        ax1.legend(loc="best")
+        ax1.set_ylabel("Inch WC")
+
+        ax2.plot(df.index, df[self.supply_vfd_speed_col], color="g", label="FAN")
+        ax2.legend(loc="best")
+        ax2.set_ylabel("%")
+
+        ax3.plot(df.index, df[output_col], label="Fault", color="k")
+        ax3.set_xlabel("Date")
+        ax3.set_ylabel("Fault Flags")
+        ax3.legend(loc="best")
+
+        plt.tight_layout(rect=[0, 0.03, 1, 0.95])
+        plt.show()
+        plt.close()
+
+    def summarize_fault_times(self, df: pd.DataFrame, output_col: str = None) -> dict:
+        if output_col is None:
+            output_col = "fc1_flag"
+
+        delta = df.index.to_series().diff()
+        summary = {
+            "total_days": round(delta.sum() / pd.Timedelta(days=1), 2),
+            "total_hours": round(delta.sum() / pd.Timedelta(hours=1)),
+            "hours_fc1_mode": round(
+                (delta * df[output_col]).sum() / pd.Timedelta(hours=1)
+            ),
+            "percent_true": round(df[output_col].mean() * 100, 2),
+            "percent_false": round((100 - round(df[output_col].mean() * 100, 2)), 2),
+            "flag_true_duct_static": round(
+                df[self.duct_static_col].where(df[output_col] == 1).mean(), 2
+            ),
+            "flag_true_duct_static_spt": round(
+                df[self.duct_static_setpoint_col].where(df[output_col] == 1).mean(), 2
+            ),
+            "hours_motor_runtime": round(
+                (delta * df[self.supply_vfd_speed_col].gt(0.01).astype(int)).sum()
+                / pd.Timedelta(hours=1),
+                2,
+            ),
+        }
+
+        return summary
+
+    def create_hist_plot(self, df: pd.DataFrame, output_col: str = None):
+        if output_col is None:
+            output_col = "fc1_flag"
+
+        df["hour_of_the_day_fc1"] = df.index.hour.where(df[output_col] == 1)
+
+        fig, ax = plt.subplots(tight_layout=True, figsize=(25, 8))
+        ax.hist(df.hour_of_the_day_fc1.dropna())
+        ax.set_xlabel("24 Hour Number in Day")
+        ax.set_ylabel("Frequency")
+        ax.set_title(f"Hour-Of-Day When Fault Flag 1 is TRUE")
+        plt.show()
+        plt.close()
+
+    def display_report_in_ipython(self, df: pd.DataFrame, output_col: str = "fc1_flag"):
+        print("Fault Condition 1: Duct static too low at fan at full speed")
+
+        self.create_plot(df, output_col)
+
+        summary = self.summarize_fault_times(df, output_col)
+
+        for key, value in summary.items():
+            formatted_key = key.replace("_", " ")
+            print(f"{formatted_key}: {value}")
+            sys.stdout.flush()
+
+        fc_max_faults_found = df[output_col].max()
+        print("Fault Flag Count: ", fc_max_faults_found)
+        sys.stdout.flush()
+
+        if fc_max_faults_found != 0:
+            self.create_hist_plot(df, output_col)
+
+            print("Duct Static Mean When In Fault: ", summary["flag_true_duct_static"])
+            print(
+                "Duct Static Setpoint Mean When In Fault: ",
+                summary["flag_true_duct_static_spt"],
+            )
+
+            if summary["percent_true"] > 5.0:
+                print(
+                    "The percent True metric that represents the amount of time for when the fault flag is True is high, indicating potential duct issues. Verify system calibration and investigate possible mechanical problems."
+                )
+            else:
+                print(
+                    "The percent True metric that represents the amount of time for when the fault flag is True is low, indicating the system is likely functioning correctly."
+                )
+
+        else:
+            print("NO FAULTS FOUND - Skipping time-of-day Histogram plot")
+            sys.stdout.flush()

open_fdd/air_handling_unit/reports/report_fc10.py

@@ -0,0 +1,126 @@
+import matplotlib.pyplot as plt
+import pandas as pd
+import sys
+
+
+class FaultCodeTenReport:
+    """Class provides the definitions for Fault Condition 10 Report."""
+
+    def __init__(self, config):
+        self.oat_col = config["OAT_COL"]
+        self.mat_col = config["MAT_COL"]
+        self.cooling_sig_col = config["COOLING_SIG_COL"]
+        self.economizer_sig_col = config["ECONOMIZER_SIG_COL"]
+        self.supply_vfd_speed_col = config["SUPPLY_VFD_SPEED_COL"]
+
+    def create_plot(self, df: pd.DataFrame, output_col: str = None):
+        if output_col is None:
+            output_col = "fc10_flag"
+
+        fig, (ax1, ax2, ax3) = plt.subplots(3, 1, figsize=(25, 8))
+        fig.suptitle("Fault Conditions 10 Plot")
+
+        ax1.plot(df.index, df[self.mat_col], label="MAT")
+        ax1.plot(df.index, df[self.oat_col], label="OAT")
+        ax1.legend(loc="best")
+        ax1.set_ylabel("AHU Temps °F")
+
+        ax2.plot(df.index, df[self.cooling_sig_col], label="AHU Cool Vlv", color="r")
+        ax2.plot(df.index, df[self.economizer_sig_col], label="AHU Dpr Cmd", color="g")
+        ax2.legend(loc="best")
+        ax2.set_ylabel("%")
+
+        ax3.plot(df.index, df[output_col], label="Fault", color="k")
+        ax3.set_xlabel("Date")
+        ax3.set_ylabel("Fault Flags")
+        ax3.legend(loc="best")
+
+        plt.tight_layout(rect=[0, 0.03, 1, 0.95])
+        plt.show()
+        plt.close()
+
+    def summarize_fault_times(self, df: pd.DataFrame, output_col: str = None) -> dict:
+        if output_col is None:
+            output_col = "fc10_flag"
+
+        delta = df.index.to_series().diff()
+        summary = {
+            "total_days": round(delta.sum() / pd.Timedelta(days=1), 2),
+            "total_hours": round(delta.sum() / pd.Timedelta(hours=1)),
+            "hours_fc10_mode": round(
+                (delta * df[output_col]).sum() / pd.Timedelta(hours=1)
+            ),
+            "percent_true": round(df[output_col].mean() * 100, 2),
+            "percent_false": round((100 - round(df[output_col].mean() * 100, 2)), 2),
+            "flag_true_oat": round(
+                df[self.oat_col].where(df[output_col] == 1).mean(), 2
+            ),
+            "flag_true_mat": round(
+                df[self.mat_col].where(df[output_col] == 1).mean(), 2
+            ),
+            "hours_motor_runtime": round(
+                (delta * df[self.supply_vfd_speed_col].gt(0.01).astype(int)).sum()
+                / pd.Timedelta(hours=1),
+                2,
+            ),
+        }
+
+        return summary
+
+    def create_hist_plot(self, df: pd.DataFrame, output_col: str = None):
+        if output_col is None:
+            output_col = "fc10_flag"
+
+        df["hour_of_the_day_fc10"] = df.index.hour.where(df[output_col] == 1)
+
+        fig, ax = plt.subplots(tight_layout=True, figsize=(25, 8))
+        ax.hist(df.hour_of_the_day_fc10.dropna())
+        ax.set_xlabel("24 Hour Number in Day")
+        ax.set_ylabel("Frequency")
+        ax.set_title(f"Hour-Of-Day When Fault Flag 10 is TRUE")
+        plt.show()
+        plt.close()
+
+    def display_report_in_ipython(
+        self, df: pd.DataFrame, output_col: str = "fc10_flag"
+    ):
+        print(
+            "Fault Condition 10: Outdoor air temperature and mix air temperature should be approximately equal in economizer plus mech cooling mode"
+        )
+
+        self.create_plot(df, output_col)
+
+        summary = self.summarize_fault_times(df, output_col)
+
+        for key, value in summary.items():
+            formatted_key = key.replace("_", " ")
+            print(f"{formatted_key}: {value}")
+            sys.stdout.flush()
+
+        fc_max_faults_found = df[output_col].max()
+        print("Fault Flag Count: ", fc_max_faults_found)
+        sys.stdout.flush()
+
+        if fc_max_faults_found != 0:
+            self.create_hist_plot(df, output_col)
+
+            flag_true_oat = round(df[self.oat_col].where(df[output_col] == 1).mean(), 2)
+            print("Outside Air Temp Mean When In Fault: ", flag_true_oat)
+
+            flag_true_mat = round(df[self.mat_col].where(df[output_col] == 1).mean(), 2)
+            print("Mix Air Temp Mean When In Fault: ", flag_true_mat)
+
+            sys.stdout.flush()
+
+            if summary["percent_true"] > 5.0:
+                print(
+                    "The percent True metric that represents the amount of time for when the fault flag is True is high indicating temperature sensor error or the mixing air dampers are stuck or broken with the inability for the AHU to go into a proper 100 percent outside air mode. Verify the actual installation of temperature sensors, damper operation, and related equipment to address potential issues."
+                )
+            else:
+                print(
+                    "The percent True metric that represents the amount of time for when the fault flag is True is low indicating the AHU components are within calibration for this fault equation."
+                )
+
+        else:
+            print("NO FAULTS FOUND - Skipping time-of-day Histogram plot")
+            sys.stdout.flush()

open_fdd/air_handling_unit/reports/report_fc11.py

@@ -0,0 +1,128 @@
+import matplotlib.pyplot as plt
+import pandas as pd
+import sys
+
+
+class FaultCodeElevenReport:
+    """Class provides the definitions for Fault Condition 11 Report."""
+
+    def __init__(self, config):
+        self.sat_setpoint_col = config["SAT_SETPOINT_COL"]
+        self.oat_col = config["OAT_COL"]
+        self.cooling_sig_col = config["COOLING_SIG_COL"]
+        self.economizer_sig_col = config["ECONOMIZER_SIG_COL"]
+        self.supply_vfd_speed_col = config["SUPPLY_VFD_SPEED_COL"]
+
+    def create_plot(self, df: pd.DataFrame, output_col: str = None):
+        if output_col is None:
+            output_col = "fc11_flag"
+
+        fig, (ax1, ax2, ax3) = plt.subplots(3, 1, figsize=(25, 8))
+        fig.suptitle("Fault Conditions 11 Plot")
+
+        ax1.plot(df.index, df[self.sat_setpoint_col], label="SATSP")
+        ax1.plot(df.index, df[self.oat_col], label="OAT")
+        ax1.legend(loc="best")
+        ax1.set_ylabel("AHU Temps °F")
+
+        ax2.plot(df.index, df[self.cooling_sig_col], label="AHU Cool Vlv", color="r")
+        ax2.plot(df.index, df[self.economizer_sig_col], label="AHU Dpr Cmd", color="g")
+        ax2.legend(loc="best")
+        ax2.set_ylabel("%")
+
+        ax3.plot(df.index, df[output_col], label="Fault", color="k")
+        ax3.set_xlabel("Date")
+        ax3.set_ylabel("Fault Flags")
+        ax3.legend(loc="best")
+
+        plt.tight_layout(rect=[0, 0.03, 1, 0.95])
+        plt.show()
+        plt.close()
+
+    def summarize_fault_times(self, df: pd.DataFrame, output_col: str = None) -> dict:
+        if output_col is None:
+            output_col = "fc11_flag"
+
+        delta = df.index.to_series().diff()
+        summary = {
+            "total_days": round(delta.sum() / pd.Timedelta(days=1), 2),
+            "total_hours": round(delta.sum() / pd.Timedelta(hours=1)),
+            "hours_fc11_mode": round(
+                (delta * df[output_col]).sum() / pd.Timedelta(hours=1)
+            ),
+            "percent_true": round(df[output_col].mean() * 100, 2),
+            "percent_false": round((100 - round(df[output_col].mean() * 100, 2)), 2),
+            "flag_true_oat": round(
+                df[self.oat_col].where(df[output_col] == 1).mean(), 2
+            ),
+            "flag_true_sat_sp": round(
+                df[self.sat_setpoint_col].where(df[output_col] == 1).mean(), 2
+            ),
+            "hours_motor_runtime": round(
+                (delta * df[self.supply_vfd_speed_col].gt(0.01).astype(int)).sum()
+                / pd.Timedelta(hours=1),
+                2,
+            ),
+        }
+
+        return summary
+
+    def create_hist_plot(self, df: pd.DataFrame, output_col: str = None):
+        if output_col is None:
+            output_col = "fc11_flag"
+
+        df["hour_of_the_day_fc11"] = df.index.hour.where(df[output_col] == 1)
+
+        fig, ax = plt.subplots(tight_layout=True, figsize=(25, 8))
+        ax.hist(df.hour_of_the_day_fc11.dropna())
+        ax.set_xlabel("24 Hour Number in Day")
+        ax.set_ylabel("Frequency")
+        ax.set_title(f"Hour-Of-Day When Fault Flag 11 is TRUE")
+        plt.show()
+        plt.close()
+
+    def display_report_in_ipython(
+        self, df: pd.DataFrame, output_col: str = "fc11_flag"
+    ):
+        print(
+            "Fault Condition 11: Outside air temperature too low for 100% outside air cooling in economizer mode"
+        )
+
+        self.create_plot(df, output_col)
+
+        summary = self.summarize_fault_times(df, output_col)
+
+        for key, value in summary.items():
+            formatted_key = key.replace("_", " ")
+            print(f"{formatted_key}: {value}")
+            sys.stdout.flush()
+
+        fc_max_faults_found = df[output_col].max()
+        print("Fault Flag Count: ", fc_max_faults_found)
+        sys.stdout.flush()
+
+        if fc_max_faults_found != 0:
+            self.create_hist_plot(df, output_col)
+
+            flag_true_oat = round(df[self.oat_col].where(df[output_col] == 1).mean(), 2)
+            print("Outside Air Temp Mean When In Fault: ", flag_true_oat)
+
+            flag_true_sat_sp = round(
+                df[self.sat_setpoint_col].where(df[output_col] == 1).mean(), 2
+            )
+            print("Supply Air Temp Setpoint Mean When In Fault: ", flag_true_sat_sp)
+
+            sys.stdout.flush()
+
+            if summary["percent_true"] > 5.0:
+                print(
+                    "The percent True metric that represents the amount of time for when the fault flag is True is high, indicating temperature sensor error or the heating coil could be leaking, potentially creating simultaneous heating/cooling scenarios. Visually verify damper operation, and consider tuning the BAS programming for proper AHU operation."
+                )
+            else:
+                print(
+                    "The percent True metric that represents the amount of time for when the fault flag is True is low, indicating the AHU components are within calibration for this fault equation."
+                )
+
+        else:
+            print("NO FAULTS FOUND - Skipping time-of-day Histogram plot")
+            sys.stdout.flush()