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

open_fdd/air_handling_unit/reports/__init__.py

@@ -0,0 +1,894 @@
+import matplotlib.pyplot as plt
+from open_fdd.air_handling_unit.reports.fault_report import BaseFaultReport
+import pandas as pd
+
+
+class FaultCodeOneReport(BaseFaultReport):
+    def __init__(self, config):
+        super().__init__(config, "fc1_flag")
+        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):
+        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[self.fault_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) -> dict:
+        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[self.fault_col]).sum() / pd.Timedelta(hours=1)
+            ),
+            "percent_true": round(df[self.fault_col].mean() * 100, 2),
+            "percent_false": round((100 - df[self.fault_col].mean() * 100), 2),
+            "flag_true_duct_static": round(
+                df[self.duct_static_col].where(df[self.fault_col] == 1).mean(), 2
+            ),
+            "flag_true_duct_static_spt": round(
+                df[self.duct_static_setpoint_col].where(df[self.fault_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
+
+
+class FaultCodeTwoReport(BaseFaultReport):
+    def __init__(self, config):
+        super().__init__(config, "fc2_flag")
+        self.mix_degf_err_thres = config["MIX_DEGF_ERR_THRES"]
+        self.return_degf_err_thres = config["RETURN_DEGF_ERR_THRES"]
+        self.outdoor_degf_err_thres = config["OUTDOOR_DEGF_ERR_THRES"]
+        self.mat_col = config["MAT_COL"]
+        self.rat_col = config["RAT_COL"]
+        self.oat_col = config["OAT_COL"]
+        self.supply_vfd_speed_col = config["SUPPLY_VFD_SPEED_COL"]
+
+    def create_plot(self, df: pd.DataFrame):
+        fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(25, 8))
+        fig.suptitle("Fault Conditions 2 Plot")
+
+        ax1.plot(df.index, df[self.mat_col], color="r", label="Mix Temp")
+        ax1.plot(df.index, df[self.rat_col], color="b", label="Return Temp")
+        ax1.plot(df.index, df[self.oat_col], color="g", label="Out Temp")
+        ax1.legend(loc="best")
+        ax1.set_ylabel("°F")
+
+        ax2.plot(df.index, df[self.fault_col], label="Fault", color="k")
+        ax2.set_xlabel("Date")
+        ax2.set_ylabel("Fault Flags")
+        ax2.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) -> dict:
+        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_fc2_mode": round(
+                (delta * df[self.fault_col]).sum() / pd.Timedelta(hours=1)
+            ),
+            "percent_true": round(df[self.fault_col].mean() * 100, 2),
+            "percent_false": round((100 - df[self.fault_col].mean() * 100), 2),
+            "flag_true_mat": round(
+                df[self.mat_col].where(df[self.fault_col] == 1).mean(), 2
+            ),
+            "flag_true_oat": round(
+                df[self.oat_col].where(df[self.fault_col] == 1).mean(), 2
+            ),
+            "flag_true_rat": round(
+                df[self.rat_col].where(df[self.fault_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
+
+
+class FaultCodeThreeReport(BaseFaultReport):
+    def __init__(self, config):
+        super().__init__(config, "fc3_flag")
+        self.mix_degf_err_thres = config["MIX_DEGF_ERR_THRES"]
+        self.return_degf_err_thres = config["RETURN_DEGF_ERR_THRES"]
+        self.outdoor_degf_err_thres = config["OUTDOOR_DEGF_ERR_THRES"]
+        self.mat_col = config["MAT_COL"]
+        self.rat_col = config["RAT_COL"]
+        self.oat_col = config["OAT_COL"]
+        self.supply_vfd_speed_col = config["SUPPLY_VFD_SPEED_COL"]
+
+    def create_plot(self, df: pd.DataFrame):
+        fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(25, 8))
+        fig.suptitle("Fault Conditions 3 Plot")
+
+        ax1.plot(df.index, df[self.mat_col], color="r", label="Mix Temp")
+        ax1.plot(df.index, df[self.rat_col], color="b", label="Return Temp")
+        ax1.plot(df.index, df[self.oat_col], color="g", label="Out Temp")
+        ax1.legend(loc="best")
+        ax1.set_ylabel("°F")
+
+        ax2.plot(df.index, df[self.fault_col], label="Fault", color="k")
+        ax2.set_xlabel("Date")
+        ax2.set_ylabel("Fault Flags")
+        ax2.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) -> dict:
+        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_fc3_mode": round(
+                (delta * df[self.fault_col]).sum() / pd.Timedelta(hours=1)
+            ),
+            "percent_true": round(df[self.fault_col].mean() * 100, 2),
+            "percent_false": round((100 - df[self.fault_col].mean() * 100), 2),
+            "flag_true_mat": round(
+                df[self.mat_col].where(df[self.fault_col] == 1).mean(), 2
+            ),
+            "flag_true_oat": round(
+                df[self.oat_col].where(df[self.fault_col] == 1).mean(), 2
+            ),
+            "flag_true_rat": round(
+                df[self.rat_col].where(df[self.fault_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
+
+
+class FaultCodeFourReport(BaseFaultReport):
+    def __init__(self, config):
+        super().__init__(config, "fc4_flag")
+        self.delta_os_max = config["DELTA_OS_MAX"]
+        self.heating_mode_calc_col = "heating_mode"
+        self.econ_only_cooling_mode_calc_col = "econ_only_cooling_mode"
+        self.econ_plus_mech_cooling_mode_calc_col = "econ_plus_mech_cooling_mode"
+        self.mech_cooling_only_mode_calc_col = "mech_cooling_only_mode"
+
+    def create_plot(self, df: pd.DataFrame):
+        fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(25, 8))
+        fig.suptitle("Fault Condition 4 Plots")
+
+        ax1.plot(df.index, df[self.heating_mode_calc_col], label="Heat", color="orange")
+        ax1.plot(
+            df.index,
+            df[self.econ_only_cooling_mode_calc_col],
+            label="Econ Clg",
+            color="olive",
+        )
+        ax1.plot(
+            df.index,
+            df[self.econ_plus_mech_cooling_mode_calc_col],
+            label="Econ + Mech Clg",
+            color="c",
+        )
+        ax1.plot(
+            df.index,
+            df[self.mech_cooling_only_mode_calc_col],
+            label="Mech Clg",
+            color="m",
+        )
+        ax1.set_xlabel("Date")
+        ax1.set_ylabel("Calculated AHU Operating States")
+        ax1.legend(loc="best")
+
+        ax2.plot(df.index, df[self.fault_col], label="Fault", color="k")
+        ax2.set_xlabel("Date")
+        ax2.set_ylabel("Fault Flags")
+        ax2.legend(loc="best")
+
+        plt.tight_layout()
+        plt.show()
+        plt.close()
+
+    def summarize_fault_times(self, df: pd.DataFrame) -> dict:
+        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_fc4_mode": round(
+                (delta * df[self.fault_col]).sum() / pd.Timedelta(hours=1)
+            ),
+            "percent_true": round(df[self.fault_col].mean() * 100, 2),
+            "percent_false": round((100 - df[self.fault_col].mean() * 100), 2),
+            "percent_of_time_AHU_in_mech_clg_mode": round(
+                df[self.mech_cooling_only_mode_calc_col].mean() * 100, 2
+            ),
+            "percent_of_time_AHU_in_econ_plus_mech_clg_mode": round(
+                df[self.econ_plus_mech_cooling_mode_calc_col].mean() * 100, 2
+            ),
+            "percent_of_time_AHU_in_econ_free_clg_mode": round(
+                df[self.econ_only_cooling_mode_calc_col].mean() * 100, 2
+            ),
+            "percent_of_time_AHU_in_heating_mode": round(
+                df[self.heating_mode_calc_col].mean() * 100, 2
+            ),
+            "total_hours_heating_mode": round(
+                (delta * df[self.heating_mode_calc_col]).sum() / pd.Timedelta(hours=1),
+                2,
+            ),
+            "total_hours_econ_mode": round(
+                (delta * df[self.econ_only_cooling_mode_calc_col]).sum()
+                / pd.Timedelta(hours=1),
+                2,
+            ),
+            "total_hours_econ_mech_clg_mode": round(
+                (delta * df[self.econ_plus_mech_cooling_mode_calc_col]).sum()
+                / pd.Timedelta(hours=1),
+                2,
+            ),
+            "total_hours_mech_clg_mode": round(
+                (delta * df[self.mech_cooling_only_mode_calc_col]).sum()
+                / pd.Timedelta(hours=1),
+                2,
+            ),
+        }
+        return summary
+
+
+class FaultCodeFiveReport(BaseFaultReport):
+    def __init__(self, config):
+        super().__init__(config, "fc5_flag")
+        self.mix_degf_err_thres = config["MIX_DEGF_ERR_THRES"]
+        self.supply_degf_err_thres = config["SUPPLY_DEGF_ERR_THRES"]
+        self.delta_t_supply_fan = config["DELTA_T_SUPPLY_FAN"]
+        self.mat_col = config["MAT_COL"]
+        self.sat_col = config["SAT_COL"]
+        self.heating_sig_col = config["HEATING_SIG_COL"]
+        self.supply_vfd_speed_col = config["SUPPLY_VFD_SPEED_COL"]
+
+    def create_plot(self, df: pd.DataFrame):
+        fig, (ax1, ax2, ax3) = plt.subplots(3, 1, figsize=(25, 8))
+        fig.suptitle("Fault Conditions 5 Plot")
+
+        ax1.plot(df.index, df[self.mat_col], color="g", label="Mix Temp")
+        ax1.plot(df.index, df[self.sat_col], color="b", label="Supply Temp")
+        ax1.legend(loc="best")
+        ax1.set_ylabel("°F")
+
+        ax2.plot(df.index, df[self.heating_sig_col], label="Htg Valve", color="r")
+        ax2.set_xlabel("Date")
+        ax2.set_ylabel("%")
+        ax2.legend(loc="best")
+
+        ax3.plot(df.index, df[self.fault_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) -> dict:
+        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_fc5_mode": round(
+                (delta * df[self.fault_col]).sum() / pd.Timedelta(hours=1)
+            ),
+            "percent_true": round(df[self.fault_col].mean() * 100, 2),
+            "percent_false": round((100 - df[self.fault_col].mean() * 100), 2),
+            "flag_true_mat": round(
+                df[self.mat_col].where(df[self.fault_col] == 1).mean(), 2
+            ),
+            "flag_true_sat": round(
+                df[self.sat_col].where(df[self.fault_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
+
+
+class FaultCodeSixReport(BaseFaultReport):
+    def __init__(self, config):
+        super().__init__(config, "fc6_flag")
+        self.supply_fan_air_volume_col = config["SUPPLY_FAN_AIR_VOLUME_COL"]
+        self.mat_col = config["MAT_COL"]
+        self.oat_col = config["OAT_COL"]
+        self.rat_col = config["RAT_COL"]
+        self.supply_vfd_speed_col = config["SUPPLY_VFD_SPEED_COL"]
+
+    def create_plot(self, df: pd.DataFrame):
+        fig, (ax1, ax2, ax3, ax4, ax5) = plt.subplots(5, 1, figsize=(25, 8))
+        fig.suptitle("Fault Conditions 6 Plot")
+
+        ax1.plot(df.index, df["rat_minus_oat"], label="Rat Minus Oat")
+        ax1.legend(loc="best")
+        ax1.set_ylabel("°F")
+
+        ax2.plot(
+            df.index,
+            df[self.supply_fan_air_volume_col],
+            label="Total Air Flow",
+            color="r",
+        )
+        ax2.set_xlabel("Date")
+        ax2.set_ylabel("CFM")
+        ax2.legend(loc="best")
+
+        ax3.plot(df.index, df["percent_oa_calc"], label="OA Frac Calc", color="m")
+        ax3.plot(df.index, df["perc_OAmin"], label="OA Perc Min Calc", color="y")
+        ax3.set_xlabel("Date")
+        ax3.set_ylabel("%")
+        ax3.legend(loc="best")
+
+        ax4.plot(
+            df.index,
+            df["percent_oa_calc_minus_perc_OAmin"],
+            label="OA Error Frac Vs Perc Min Calc",
+            color="g",
+        )
+        ax4.set_xlabel("Date")
+        ax4.set_ylabel("%")
+        ax4.legend(loc="best")
+
+        ax5.plot(df.index, df[self.fault_col], label="Fault", color="k")
+        ax5.set_xlabel("Date")
+        ax5.set_ylabel("Fault Flags")
+        ax5.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) -> dict:
+        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_fc6_mode": round(
+                (delta * df[self.fault_col]).sum() / pd.Timedelta(hours=1)
+            ),
+            "percent_true": round(df[self.fault_col].mean() * 100, 2),
+            "percent_false": round((100 - df[self.fault_col].mean() * 100), 2),
+            "flag_true_mat": round(
+                df[self.mat_col].where(df[self.fault_col] == 1).mean(), 2
+            ),
+            "flag_true_rat": round(
+                df[self.rat_col].where(df[self.fault_col] == 1).mean(), 2
+            ),
+            "flag_true_oat": round(
+                df[self.oat_col].where(df[self.fault_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
+
+
+class FaultCodeSevenReport(BaseFaultReport):
+    def __init__(self, config):
+        super().__init__(config, "fc7_flag")
+        self.sat_col = config["SAT_COL"]
+        self.sat_setpoint_col = config["SAT_SETPOINT_COL"]
+        self.heating_sig_col = config["HEATING_SIG_COL"]
+        self.supply_vfd_speed_col = config["SUPPLY_VFD_SPEED_COL"]
+
+    def create_plot(self, df: pd.DataFrame):
+        fig, (ax1, ax2, ax3) = plt.subplots(3, 1, figsize=(25, 8))
+        fig.suptitle("Fault Conditions 7 Plot")
+
+        ax1.plot(df.index, df[self.sat_col], label="SAT")
+        ax1.plot(df.index, df[self.sat_setpoint_col], label="SATsp")
+        ax1.legend(loc="best")
+        ax1.set_ylabel("AHU Supply Temps °F")
+
+        ax2.plot(df.index, df[self.heating_sig_col], color="r", label="AHU Heat Vlv")
+        ax2.legend(loc="best")
+        ax2.set_ylabel("%")
+
+        ax3.plot(df.index, df[self.fault_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) -> dict:
+        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_fc7_mode": round(
+                (delta * df[self.fault_col]).sum() / pd.Timedelta(hours=1)
+            ),
+            "percent_true": round(df[self.fault_col].mean() * 100, 2),
+            "percent_false": round((100 - df[self.fault_col].mean() * 100), 2),
+            "flag_true_satsp": round(
+                df[self.sat_setpoint_col].where(df[self.fault_col] == 1).mean(), 2
+            ),
+            "flag_true_sat": round(
+                df[self.sat_col].where(df[self.fault_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
+
+
+class FaultCodeEightReport(BaseFaultReport):
+    def __init__(self, config):
+        super().__init__(config, "fc8_flag")
+        self.sat_col = config["SAT_COL"]
+        self.mat_col = config["MAT_COL"]
+        self.supply_vfd_speed_col = config["SUPPLY_VFD_SPEED_COL"]
+        self.economizer_sig_col = config["ECONOMIZER_SIG_COL"]
+
+    def create_plot(self, df: pd.DataFrame):
+        fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(25, 8))
+        fig.suptitle("Fault Conditions 8 Plot")
+
+        ax1.plot(df.index, df[self.sat_col], label="SAT")
+        ax1.plot(df.index, df[self.mat_col], label="MAT")
+        ax1.legend(loc="best")
+        ax1.set_ylabel("AHU Temps °F")
+
+        ax2.plot(df.index, df[self.fault_col], label="Fault", color="k")
+        ax2.set_xlabel("Date")
+        ax2.set_ylabel("Fault Flags")
+        ax2.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) -> dict:
+        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_fc8_mode": round(
+                (delta * df[self.fault_col]).sum() / pd.Timedelta(hours=1)
+            ),
+            "percent_true": round(df[self.fault_col].mean() * 100, 2),
+            "percent_false": round((100 - df[self.fault_col].mean() * 100), 2),
+            "flag_true_mat": round(
+                df[self.mat_col].where(df[self.fault_col] == 1).mean(), 2
+            ),
+            "flag_true_sat": round(
+                df[self.sat_col].where(df[self.fault_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
+
+
+class FaultCodeNineReport(BaseFaultReport):
+    def __init__(self, config):
+        super().__init__(config, "fc9_flag")
+        self.sat_setpoint_col = config["SAT_SETPOINT_COL"]
+        self.oat_col = config["OAT_COL"]
+        self.supply_vfd_speed_col = config["SUPPLY_VFD_SPEED_COL"]
+        self.economizer_sig_col = config["ECONOMIZER_SIG_COL"]
+
+    def create_plot(self, df: pd.DataFrame):
+        fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(25, 8))
+        fig.suptitle("Fault Conditions 9 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.fault_col], label="Fault", color="k")
+        ax2.set_xlabel("Date")
+        ax2.set_ylabel("Fault Flags")
+        ax2.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) -> dict:
+        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_fc9_mode": round(
+                (delta * df[self.fault_col]).sum() / pd.Timedelta(hours=1)
+            ),
+            "percent_true": round(df[self.fault_col].mean() * 100, 2),
+            "percent_false": round((100 - df[self.fault_col].mean() * 100), 2),
+            "flag_true_oat": round(
+                df[self.oat_col].where(df[self.fault_col] == 1).mean(), 2
+            ),
+            "flag_true_satsp": round(
+                df[self.sat_setpoint_col].where(df[self.fault_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
+
+
+class FaultCodeTenReport(BaseFaultReport):
+    def __init__(self, config):
+        super().__init__(config, "fc10_flag")
+        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):
+        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[self.fault_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) -> dict:
+        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[self.fault_col]).sum() / pd.Timedelta(hours=1)
+            ),
+            "percent_true": round(df[self.fault_col].mean() * 100, 2),
+            "percent_false": round((100 - df[self.fault_col].mean() * 100), 2),
+            "flag_true_oat": round(
+                df[self.oat_col].where(df[self.fault_col] == 1).mean(), 2
+            ),
+            "flag_true_mat": round(
+                df[self.mat_col].where(df[self.fault_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
+
+
+class FaultCodeElevenReport(BaseFaultReport):
+    def __init__(self, config):
+        super().__init__(config, "fc11_flag")
+        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):
+        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[self.fault_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) -> dict:
+        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[self.fault_col]).sum() / pd.Timedelta(hours=1)
+            ),
+            "percent_true": round(df[self.fault_col].mean() * 100, 2),
+            "percent_false": round((100 - df[self.fault_col].mean() * 100), 2),
+            "flag_true_oat": round(
+                df[self.oat_col].where(df[self.fault_col] == 1).mean(), 2
+            ),
+            "flag_true_sat_sp": round(
+                df[self.sat_setpoint_col].where(df[self.fault_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
+
+
+class FaultCodeTwelveReport(BaseFaultReport):
+    def __init__(self, config):
+        super().__init__(config, "fc12_flag")
+        self.sat_col = config["SAT_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):
+        fig, (ax1, ax2, ax3) = plt.subplots(3, 1, figsize=(25, 8))
+        fig.suptitle("Fault Conditions 12 Plot")
+
+        ax1.plot(df.index, df[self.sat_col], label="SAT")
+        ax1.plot(df.index, df[self.mat_col], label="MAT")
+        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[self.fault_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) -> dict:
+        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_fc12_mode": round(
+                (delta * df[self.fault_col]).sum() / pd.Timedelta(hours=1)
+            ),
+            "percent_true": round(df[self.fault_col].mean() * 100, 2),
+            "percent_false": round((100 - df[self.fault_col].mean() * 100), 2),
+            "flag_true_mat": round(
+                df[self.mat_col].where(df[self.fault_col] == 1).mean(), 2
+            ),
+            "flag_true_sat": round(
+                df[self.sat_col].where(df[self.fault_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
+
+
+class FaultCodeThirteenReport(BaseFaultReport):
+    def __init__(self, config):
+        super().__init__(config, "fc13_flag")
+        self.sat_col = config["SAT_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):
+        fig, (ax1, ax2, ax3) = plt.subplots(3, 1, figsize=(25, 8))
+        fig.suptitle("Fault Conditions 13 Plot")
+
+        ax1.plot(df.index, df[self.sat_col], label="SAT")
+        ax1.plot(df.index, df[self.mat_col], label="MAT")
+        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[self.fault_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) -> dict:
+        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_fc13_mode": round(
+                (delta * df[self.fault_col]).sum() / pd.Timedelta(hours=1)
+            ),
+            "percent_true": round(df[self.fault_col].mean() * 100, 2),
+            "percent_false": round((100 - df[self.fault_col].mean() * 100), 2),
+            "flag_true_mat": round(
+                df[self.mat_col].where(df[self.fault_col] == 1).mean(), 2
+            ),
+            "flag_true_sat": round(
+                df[self.sat_col].where(df[self.fault_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
+
+
+class FaultCodeFourteenReport(BaseFaultReport):
+    def __init__(self, config):
+        super().__init__(config, "fc14_flag")
+        self.sat_col = config["SAT_COL"]
+        self.clt_col = config["CLT_COL"]
+        self.cooling_sig_col = config["COOLING_SIG_COL"]
+        self.supply_vfd_speed_col = config["SUPPLY_VFD_SPEED_COL"]
+
+    def create_plot(self, df: pd.DataFrame):
+        fig, (ax1, ax2, ax3) = plt.subplots(3, 1, figsize=(25, 8))
+        fig.suptitle("Fault Conditions 14 Plot")
+
+        ax1.plot(df.index, df[self.sat_col], label="SAT")
+        ax1.plot(df.index, df[self.clt_col], label="CLT")
+        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.legend(loc="best")
+        ax2.set_ylabel("%")
+
+        ax3.plot(df.index, df[self.fault_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) -> dict:
+        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_fc14_mode": round(
+                (delta * df[self.fault_col]).sum() / pd.Timedelta(hours=1)
+            ),
+            "percent_true": round(df[self.fault_col].mean() * 100, 2),
+            "percent_false": round((100 - df[self.fault_col].mean() * 100), 2),
+            "flag_true_clt": round(
+                df[self.clt_col].where(df[self.fault_col] == 1).mean(), 2
+            ),
+            "flag_true_sat": round(
+                df[self.sat_col].where(df[self.fault_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
+
+
+class FaultCodeFifteenReport(BaseFaultReport):
+    def __init__(self, config):
+        super().__init__(config, "fc15_flag")
+        self.sat_col = config["SAT_COL"]
+        self.hlt_col = config["HLT_COL"]
+        self.heating_sig_col = config["HEATING_SIG_COL"]
+        self.supply_vfd_speed_col = config["SUPPLY_VFD_SPEED_COL"]
+
+    def create_plot(self, df: pd.DataFrame):
+        fig, (ax1, ax2, ax3) = plt.subplots(3, 1, figsize=(25, 8))
+        fig.suptitle("Fault Conditions 15 Plot")
+
+        ax1.plot(df.index, df[self.sat_col], label="SAT")
+        ax1.plot(df.index, df[self.hlt_col], label="HLT")
+        ax1.legend(loc="best")
+        ax1.set_ylabel("AHU Temps °F")
+
+        ax2.plot(df.index, df[self.heating_sig_col], label="AHU Heat Vlv", color="r")
+        ax2.legend(loc="best")
+        ax2.set_ylabel("%")
+
+        ax3.plot(df.index, df[self.fault_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) -> dict:
+        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_fc15_mode": round(
+                (delta * df[self.fault_col]).sum() / pd.Timedelta(hours=1)
+            ),
+            "percent_true": round(df[self.fault_col].mean() * 100, 2),
+            "percent_false": round((100 - df[self.fault_col].mean() * 100), 2),
+            "flag_true_hlt": round(
+                df[self.hlt_col].where(df[self.fault_col] == 1).mean(), 2
+            ),
+            "flag_true_sat": round(
+                df[self.sat_col].where(df[self.fault_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

open_fdd/air_handling_unit/reports/fault_report.py

@@ -0,0 +1,41 @@
+import matplotlib.pyplot as plt
+import pandas as pd
+import numpy as np
+import sys
+
+
+class BaseFaultReport:
+    def __init__(self, config, fault_col):
+        self.config = config
+        self.fault_col = fault_col
+
+    def create_plot(self, df: pd.DataFrame):
+        raise NotImplementedError
+
+    def summarize_fault_times(self, df: pd.DataFrame) -> dict:
+        raise NotImplementedError
+
+    def create_hist_plot(self, df: pd.DataFrame):
+        df[f"hour_of_the_day_{self.fault_col}"] = df.index.hour.where(
+            df[self.fault_col] == 1
+        )
+        fig, ax = plt.subplots(tight_layout=True, figsize=(25, 8))
+        ax.hist(df[f"hour_of_the_day_{self.fault_col}"].dropna())
+        ax.set_xlabel("Hour of the Day")
+        ax.set_ylabel("Frequency")
+        ax.set_title(f"Hour-Of-Day When Fault Flag {self.fault_col} is TRUE")
+        plt.show()
+        plt.close()
+
+    def display_report_in_ipython(self, df: pd.DataFrame):
+        summary = self.summarize_fault_times(df)
+        for key, value in summary.items():
+            formatted_key = key.replace("_", " ")
+            print(f"{formatted_key}: {value}")
+            sys.stdout.flush()
+
+        if df[self.fault_col].max() != 0:
+            self.create_hist_plot(df)
+        else:
+            print("NO FAULTS FOUND - Skipping time-of-day Histogram plot")
+            sys.stdout.flush()

{open_fdd-0.1.4.dist-info → open_fdd-0.1.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: open_fdd
-Version: 0.1.4
+Version: 0.1.5
 Summary: A package for fault detection and diagnosis in HVAC systems
 Home-page: https://github.com/bbartling/open-fdd
 Author: Ben Bartling
@@ -39,20 +39,28 @@ pip install open-fdd
 For running Jupyter notebooks, I recommend using Visual Studio Code with the Jupyter notebook extension installed, which offers a seamless experience directly within the editor. Be sure to explore the `examples` directory for Jupyter notebook tutorials. If you have your own FDD experiences to share, feel free to contribute by creating a notebook (`.ipynb`). You’re welcome to reach out to me directly, and I can push your example to GitHub on your behalf, which might be a simpler process than submitting a pull request (PR), especially if you're just sharing an example rather than developing `open-fdd`.
 
 ## Project goals
-These are some basic project goals to make this into an interactive FDD application.
- - [x] finish `air_handling_unit` faults and reports based on ASHRAE and NIST
- - [x] publish to PyPI as Python library
- - [ ] make a few IPython notebook tutorials AHU FDD examples with `BRICK` meta data integration.
- - [ ] make a guide for fault `parameters` like error thresholds, etc.
- - [ ] make `central_plant` faults, IPython reports, and examples.
- - [ ] make `energy_efficiency` faults, IPython reports, and examples to `optimize` in reducing energy consumption.
- - [ ] make `metering`, faults, IPython reports, and examples to possibly model utility metering data.
- - [ ] create SQL example to read data from time series db and write back to SQL to then read faults in Grafana.
- - [ ] other? Certainly! As ChatGPT would eagerly say!
+The following are key objectives to enhance this project into a fully interactive Fault Detection and Diagnostics (FDD) application.
 
+### Completed
+ - [x] Develop and finalize `air_handling_unit` fault conditions and reports, aligning with ASHRAE and NIST standards.
+ - [x] Publish the project as a Python library on PyPI.
 
-## Contribute
+### In Progress
+ - [ ] Create IPython notebook tutorials showcasing AHU FDD examples, incorporating BRICK metadata integration.
+ - [ ] Develop a comprehensive guide on a github.io website (or other?) for defining fault parameters, including error thresholds and other critical settings.
+
+### Upcoming
+ - [ ] Extend the project to include `central_plant` fault conditions, IPython reports, and example applications.
+ - [ ] Design `energy_efficiency` fault detection modules, including IPython reports and examples focused on optimizing energy consumption.
+ - [ ] Develop `metering` fault conditions, along with IPython reports and examples, potentially modeling utility metering data.
+ - [ ] Implement SQL integration examples for reading data from a time series database, writing back to SQL, and visualizing faults in Grafana.
+
+### Future Considerations
+ Explore additional features and enhancements as the project evolves.
+ - [ ] Explore additional features and enhancements as the project evolves.
 
+
+## Contribute
 If you have suggestions for improving developer best practices or solutions, please feel free to reach out to me directly using my contact information or Git issue/discussion. I primarily work on Windows with multiple versions of Python installed, with Python 3.12.x as my default version. You can download the latest version of Python here:
 * https://www.python.org/downloads/
 

{open_fdd-0.1.4.dist-info → open_fdd-0.1.5.dist-info}/RECORD

@@ -41,8 +41,9 @@ open_fdd/air_handling_unit/images/latex_generator.py,sha256=9kotpUZjQrECXiB8ewcv
 open_fdd/air_handling_unit/images/params.docx,sha256=_mh1G-avi-lsssaW_qH33vGVaYwS_XL_IOQweYpQvAo,157634
 open_fdd/air_handling_unit/images/params.pdf,sha256=2rmxh2yxuB7x3Q2Jyq0MnFoTJAQqxwIoxGvzzJirWkU,175678
 open_fdd/air_handling_unit/images/plot_for_repo.png,sha256=u4OIzZUyGk6G4o1AusEERUU6aen4vVX-CGPl14P3qkA,651969
-open_fdd/air_handling_unit/reports/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+open_fdd/air_handling_unit/reports/__init__.py,sha256=tIU1N_3cH7A6tWeoAIsVLLFUlnizIOiMCgMVDeoFGL4,36276
 open_fdd/air_handling_unit/reports/base_report.py,sha256=oZX6_qXUjuPEHKpF89DhgpPbAkhHeoo3jpDL30u4njs,1778
+open_fdd/air_handling_unit/reports/fault_report.py,sha256=v2yki8kFWsGmHdgY15kbH_mS-8KFGAqtEuHenFn0Ils,1408
 open_fdd/air_handling_unit/reports/report_fc1.py,sha256=ZlfTP4Pzv0l0hBHRWmTFMXKWPnuMNW38mHPPD8QW460,4565
 open_fdd/air_handling_unit/reports/report_fc10.py,sha256=Dgh0L4A-D-VYqTfVcMwhxdw67R-31c24ydtrpJ-gLyU,5179
 open_fdd/air_handling_unit/reports/report_fc11.py,sha256=fLb004y59i_2LegfGlpgEpEzQadqsCWrJPNLZ6obgqg,5197
@@ -75,8 +76,8 @@ open_fdd/tests/ahu/test_ahu_fc6.py,sha256=66dwv0EBU_ujZK-J9Ki5a3fnXlk17nOwmtKDiQ
 open_fdd/tests/ahu/test_ahu_fc7.py,sha256=sABbw2m7WlAXbsqfDD323vfEfg606ThI0QzQyB-OjFo,2469
 open_fdd/tests/ahu/test_ahu_fc8.py,sha256=UZy6BP2PgV1FROUPqMORTx8YnT5ZvqVDhut_Ar81494,4663
 open_fdd/tests/ahu/test_ahu_fc9.py,sha256=b-eIzhNzjZUjVNsP0JAHkOgZu-BtDuPeNnblVVm-jU8,4796
-open_fdd-0.1.4.dist-info/LICENSE,sha256=eghao_GGx_0gB2Sll3x2vV29knONEzUQKrkaXpX1F7w,1087
-open_fdd-0.1.4.dist-info/METADATA,sha256=mnTD5a5-ob9hYjWMbcfxHdB8RAIJ-GOWC33kWtc_JJw,6420
-open_fdd-0.1.4.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
-open_fdd-0.1.4.dist-info/top_level.txt,sha256=Q7sB6UB2d8Ch1v_xIsTiNegmgcCXPkwkrxK3ug6VEOs,9
-open_fdd-0.1.4.dist-info/RECORD,,
+open_fdd-0.1.5.dist-info/LICENSE,sha256=eghao_GGx_0gB2Sll3x2vV29knONEzUQKrkaXpX1F7w,1087
+open_fdd-0.1.5.dist-info/METADATA,sha256=rQBnlFoVuYXgFtGbTJ7VKWiSI62DHpTK2TOzA3-XqmI,6925
+open_fdd-0.1.5.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
+open_fdd-0.1.5.dist-info/top_level.txt,sha256=Q7sB6UB2d8Ch1v_xIsTiNegmgcCXPkwkrxK3ug6VEOs,9
+open_fdd-0.1.5.dist-info/RECORD,,