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

open_fdd/air_handling_unit/faults/helper_utils.py

@@ -11,6 +11,9 @@ class HelperUtils:
     def set_config_dict(self, config_dict):
         self.config_dict = config_dict
 
+    def clean_nan_values(self, df):
+        return SharedUtils.clean_nan_values(df)
+
     def float_int_check_err(self, col):
         return SharedUtils.float_int_check_err(col)
 

open_fdd/air_handling_unit/faults/shared_utils.py

@@ -48,8 +48,10 @@ class SharedUtils:
         """
 
         print(
-            "Warning: If data has a one minute or less sampling frequency a rolling average will be automatically applied"
+            "Warning: If data has a one minute or less sampling \n"
+            "frequency a rolling average will be automatically applied"
         )
+
         sys.stdout.flush()
 
         time_diff = df.index.to_series().diff().iloc[1:]
@@ -73,3 +75,16 @@ class SharedUtils:
             )
             sys.stdout.flush()
         return df
+
+    @staticmethod
+    def clean_nan_values(df: pd.DataFrame) -> pd.DataFrame:
+        for col in df.columns:
+            if df[col].isnull().any():
+                print(f"NaN values found in column: {col}")
+
+                # Remove rows with any NaN values, then forward and backfill
+                df = df.dropna().ffill().bfill()
+                print("DataFrame has been cleaned for NaNs")
+                print("and has also been forward and backfilled.")
+                sys.stdout.flush()
+        return df

open_fdd/air_handling_unit/reports/__init__.py

@@ -1,6 +1,9 @@
 import matplotlib.pyplot as plt
 from open_fdd.air_handling_unit.reports.fault_report import BaseFaultReport
+from open_fdd.air_handling_unit.faults import FaultConditionSixteen
 import pandas as pd
+import numpy as np
+import sys
 
 
 class FaultCodeOneReport(BaseFaultReport):
@@ -892,3 +895,107 @@ class FaultCodeFifteenReport(BaseFaultReport):
             ),
         }
         return summary
+
+
+class FaultCodeSixteenReport(BaseFaultReport):
+    def __init__(self, config):
+        super().__init__(config, "fc16_flag")
+
+        self.supply_vfd_speed_col = config["SUPPLY_VFD_SPEED_COL"]
+        self.erv_oat_enter_col = config["ERV_OAT_ENTER_COL"]
+        self.erv_oat_leaving_col = config["ERV_OAT_LEAVING_COL"]
+        self.erv_eat_enter_col = config["ERV_EAT_ENTER_COL"]
+        self.erv_eat_leaving_col = config["ERV_EAT_LEAVING_COL"]
+
+        # Instantiate FaultConditionSixteen to access its methods
+        self.fc16 = FaultConditionSixteen(config)
+
+    def create_plot(self, df: pd.DataFrame):
+        # Calculate the efficiency before plotting using FaultConditionSixteen method
+        df = self.fc16.calculate_erv_efficiency(df)
+
+        # Create the plot with five subplots
+        fig, (ax1, ax2, ax3, ax4, ax5) = plt.subplots(5, 1, figsize=(25, 14))
+        fig.suptitle("Fault Conditions 16 Plot")
+
+        # Plot ERV Outdoor Air Side Temps
+        ax1.plot(df.index, df[self.erv_oat_enter_col], label="Enter", color="blue")
+        ax1.plot(df.index, df[self.erv_oat_leaving_col], label="Leaving", color="green")
+        ax1.legend(loc="best")
+        ax1.set_ylabel("ERV Outdoor Air Side Temps °F")
+
+        # Plot ERV Exhaust Air Side Temps
+        ax2.plot(df.index, df[self.erv_eat_enter_col], label="Enter", color="red")
+        ax2.plot(
+            df.index, df[self.erv_eat_leaving_col], label="Leaving", color="purple"
+        )
+        ax2.legend(loc="best")
+        ax2.set_ylabel("ERV Exhaust Air Side Temps °F")
+
+        # Plot ERV Efficiency
+        ax3.plot(
+            df.index, df["erv_efficiency_oa"], label="ERV Efficiency OA", color="b"
+        )
+        ax3.legend(loc="best")
+        ax3.set_ylabel("ERV Efficiency OA")
+
+        # Plot Fault Flags
+        ax4.plot(df.index, df[self.fault_col], label="Fault", color="k")
+        ax4.set_xlabel("Date")
+        ax4.set_ylabel("Fault Flags")
+        ax4.legend(loc="best")
+
+        # New Plot: Compare Distribution of OAT (Overall vs Fault True)
+        fault_true_df = df[df[self.fault_col] == 1]
+        data_to_plot = [
+            df[self.erv_oat_enter_col].dropna(),  # Overall OAT
+            fault_true_df[self.erv_oat_enter_col].dropna(),  # OAT when Fault is True
+        ]
+        ax5.boxplot(
+            data_to_plot,
+            vert=False,
+            patch_artist=True,
+            labels=["Overall OAT", "OAT when Fault 16 is True"],
+            boxprops=dict(facecolor="lightblue"),
+            medianprops=dict(color="red"),
+            showmeans=True,
+            meanline=True,
+            meanprops=dict(color="green"),
+        )
+        ax5.set_xlabel("Outside Air Temperature (°F)")
+        ax5.set_title("Comparison of OAT Distribution")
+        ax5.grid(True)
+
+        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_fc16_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_erv_oat_enter_temp": round(
+                df[self.erv_oat_enter_col].where(df[self.fault_col] == 1).mean(), 2
+            ),
+            "flag_true_erv_oat_leave_temp": round(
+                df[self.erv_oat_leaving_col].where(df[self.fault_col] == 1).mean(), 2
+            ),
+            "flag_true_erv_eat_enter_temp": round(
+                df[self.erv_eat_enter_col].where(df[self.fault_col] == 1).mean(), 2
+            ),
+            "flag_true_erv_eat_leave_temp": round(
+                df[self.erv_eat_leaving_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

@@ -35,6 +35,7 @@ class BaseFaultReport:
             sys.stdout.flush()
 
         if df[self.fault_col].max() != 0:
+            self.create_plot(df)
             self.create_hist_plot(df)
         else:
             print("NO FAULTS FOUND - Skipping time-of-day Histogram plot")

open_fdd/tests/ahu/test_ahu_fc1.py

@@ -12,6 +12,7 @@ TEST_DUCT_STATIC_ERR_THRESHOLD = 0.1
 TEST_DUCT_STATIC_COL = "duct_static"
 TEST_DUCT_STATIC_SETPOINT_COL = "duct_static_setpoint"
 TEST_SUPPLY_VFD_SPEED_COL = "supply_vfd_speed"
+
 ROLLING_WINDOW_SIZE = 5
 
 # Initialize FaultConditionOne with a dictionary

open_fdd/tests/ahu/test_ahu_fc16.py

@@ -0,0 +1,205 @@
+import pandas as pd
+import pytest
+from open_fdd.air_handling_unit.faults import FaultConditionSixteen
+from open_fdd.air_handling_unit.faults.fault_condition import (
+    InvalidParameterError,
+    MissingColumnError,
+)
+
+"""
+To see print statements in pytest run with:
+$ py -3.12 -m pytest open_fdd/tests/ahu/test_ahu_fc16.py -rP -s
+
+ERV effectiveness should be within specified thresholds based on OAT.
+"""
+
+# Constants
+TEST_ERV_EFFICIENCY_MIN_HEATING = 0.65
+TEST_ERV_EFFICIENCY_MAX_HEATING = 0.8
+TEST_ERV_EFFICIENCY_MIN_COOLING = 0.45
+TEST_ERV_EFFICIENCY_MAX_COOLING = 0.6
+TEST_OAT_LOW_THRESHOLD = 32.0
+TEST_OAT_HIGH_THRESHOLD = 80.0
+TEST_OAT_RAT_DELTA_THRES = 15.0
+TEST_ERV_OAT_ENTER_COL = "erv_oat_enter"
+TEST_ERV_OAT_LEAVING_COL = "erv_oat_leaving"
+TEST_ERV_EAT_ENTER_COL = "erv_eat_enter"
+TEST_ERV_EAT_LEAVING_COL = "erv_eat_leaving"
+TEST_SUPPLY_VFD_SPEED_COL = "supply_vfd_speed"
+ROLLING_WINDOW_SIZE = 1
+
+# Initialize FaultConditionSixteen with a dictionary
+fault_condition_params = {
+    "ERV_EFFICIENCY_MIN_HEATING": TEST_ERV_EFFICIENCY_MIN_HEATING,
+    "ERV_EFFICIENCY_MAX_HEATING": TEST_ERV_EFFICIENCY_MAX_HEATING,
+    "ERV_EFFICIENCY_MIN_COOLING": TEST_ERV_EFFICIENCY_MIN_COOLING,
+    "ERV_EFFICIENCY_MAX_COOLING": TEST_ERV_EFFICIENCY_MAX_COOLING,
+    "OAT_LOW_THRESHOLD": TEST_OAT_LOW_THRESHOLD,
+    "OAT_HIGH_THRESHOLD": TEST_OAT_HIGH_THRESHOLD,
+    "OAT_RAT_DELTA_MIN": TEST_OAT_RAT_DELTA_THRES,
+    "ERV_OAT_ENTER_COL": TEST_ERV_OAT_ENTER_COL,
+    "ERV_OAT_LEAVING_COL": TEST_ERV_OAT_LEAVING_COL,
+    "ERV_EAT_ENTER_COL": TEST_ERV_EAT_ENTER_COL,
+    "ERV_EAT_LEAVING_COL": TEST_ERV_EAT_LEAVING_COL,
+    "SUPPLY_VFD_SPEED_COL": TEST_SUPPLY_VFD_SPEED_COL,
+    "TROUBLESHOOT_MODE": False,
+    "ROLLING_WINDOW_SIZE": ROLLING_WINDOW_SIZE,
+}
+
+fc16 = FaultConditionSixteen(fault_condition_params)
+
+
+class TestFaultConditionSixteen:
+
+    def no_fault_htg_df(self) -> pd.DataFrame:
+        data = {
+            TEST_ERV_OAT_ENTER_COL: [10, 10, 10, 10, 10, 10],
+            TEST_ERV_OAT_LEAVING_COL: [50.0, 50.5, 50.8, 50.6, 50.2, 50.4],
+            TEST_ERV_EAT_ENTER_COL: [70, 70, 70, 70, 70, 70],
+            TEST_ERV_EAT_LEAVING_COL: [60, 60.5, 60.2, 60.4, 60.1, 60.3],
+            TEST_SUPPLY_VFD_SPEED_COL: [0.5, 0.6, 0.5, 0.7, 0.5, 0.6],
+        }
+        return pd.DataFrame(data)
+
+    def fault_htg_df_low_eff(self) -> pd.DataFrame:
+        data = {
+            TEST_ERV_OAT_ENTER_COL: [10, 10, 10, 10, 10, 10],
+            TEST_ERV_OAT_LEAVING_COL: [20.0, 20.5, 20.8, 20.6, 20.2, 20.4],
+            TEST_ERV_EAT_ENTER_COL: [70, 70, 70, 70, 70, 70],
+            TEST_ERV_EAT_LEAVING_COL: [60, 60.5, 60.2, 60.4, 60.1, 60.3],
+            TEST_SUPPLY_VFD_SPEED_COL: [0.5, 0.6, 0.5, 0.7, 0.5, 0.6],
+        }
+        return pd.DataFrame(data)
+
+    def fault_htg_df_high_eff(self) -> pd.DataFrame:
+        data = {
+            TEST_ERV_OAT_ENTER_COL: [10, 10, 10, 10, 10, 10],
+            TEST_ERV_OAT_LEAVING_COL: [90.0, 90.5, 90.8, 90.6, 90.2, 90.4],
+            TEST_ERV_EAT_ENTER_COL: [70, 70, 70, 70, 70, 70],
+            TEST_ERV_EAT_LEAVING_COL: [60, 60.5, 60.2, 60.4, 60.1, 60.3],
+            TEST_SUPPLY_VFD_SPEED_COL: [0.5, 0.6, 0.5, 0.7, 0.5, 0.6],
+        }
+        return pd.DataFrame(data)
+
+    def test_no_fault_htg(self):
+        results = fc16.apply(self.no_fault_htg_df())
+        actual = results["fc16_flag"].sum()
+        expected = 0
+        message = f"FC16 no_fault_htg actual is {actual} and expected is {expected}"
+        assert actual == expected, message
+
+    def test_fault_htg_low_eff(self):
+        results = fc16.apply(self.fault_htg_df_low_eff())
+        actual = results["fc16_flag"].sum()
+        expected = 6
+        message = (
+            f"FC16 fault_htg_low_eff actual is {actual} and expected is {expected}"
+        )
+        assert actual == expected, message
+
+    def test_fault_htg_high_eff(self):
+        results = fc16.apply(self.fault_htg_df_high_eff())
+        actual = results["fc16_flag"].sum()
+        expected = 6
+        message = (
+            f"FC16 fault_htg_high_eff actual is {actual} and expected is {expected}"
+        )
+        assert actual == expected, message
+
+    def test_fault_with_insufficient_oat_rat_delta(self):
+        """Test that no fault is raised when the OAT-RAT delta is below the minimum threshold."""
+        data = {
+            TEST_ERV_OAT_ENTER_COL: [10, 10, 10, 10, 10, 10],
+            TEST_ERV_OAT_LEAVING_COL: [20.0, 20.5, 20.8, 20.6, 20.2, 20.4],
+            TEST_ERV_EAT_ENTER_COL: [24, 24, 24, 24, 24, 24],  # Low delta with OAT
+            TEST_ERV_EAT_LEAVING_COL: [22, 22.5, 22.2, 22.4, 22.1, 22.3],
+            TEST_SUPPLY_VFD_SPEED_COL: [0.5, 0.6, 0.5, 0.7, 0.5, 0.6],
+        }
+        df = pd.DataFrame(data)
+        results = fc16.apply(df)
+        actual = results["fc16_flag"].sum()
+        expected = 0  # No fault should be triggered due to insufficient delta
+        message = f"FC16 fault_with_insufficient_oat_rat_delta actual is {actual} and expected is {expected}"
+        assert actual == expected, message
+
+
+class TestFaultOnInvalidParams:
+
+    def test_invalid_param_type(self):
+        """Test that InvalidParameterError is raised for non-float parameters."""
+        with pytest.raises(InvalidParameterError) as excinfo:
+            FaultConditionSixteen(
+                {
+                    "ERV_EFFICIENCY_MIN_HEATING": "0.65",  # Invalid, should be float
+                    "ERV_EFFICIENCY_MAX_HEATING": 0.8,
+                    "ERV_EFFICIENCY_MIN_COOLING": 0.45,
+                    "ERV_EFFICIENCY_MAX_COOLING": 0.6,
+                    "OAT_LOW_THRESHOLD": 32.0,
+                    "OAT_HIGH_THRESHOLD": 80.0,
+                    "OAT_RAT_DELTA_MIN": TEST_OAT_RAT_DELTA_THRES,
+                    "ERV_OAT_ENTER_COL": TEST_ERV_OAT_ENTER_COL,
+                    "ERV_OAT_LEAVING_COL": TEST_ERV_OAT_LEAVING_COL,
+                    "ERV_EAT_ENTER_COL": TEST_ERV_EAT_ENTER_COL,
+                    "ERV_EAT_LEAVING_COL": TEST_ERV_EAT_LEAVING_COL,
+                    "SUPPLY_VFD_SPEED_COL": TEST_SUPPLY_VFD_SPEED_COL,
+                }
+            )
+        assert "should be a float" in str(excinfo.value)
+
+    def test_invalid_efficiency_value(self):
+        """Test that InvalidParameterError is raised if efficiency values are out of 0.0 - 1.0 range."""
+        with pytest.raises(InvalidParameterError) as excinfo:
+            FaultConditionSixteen(
+                {
+                    "ERV_EFFICIENCY_MIN_HEATING": 75.0,  # Invalid, should be between 0.0 and 1.0
+                    "ERV_EFFICIENCY_MAX_HEATING": 0.8,
+                    "ERV_EFFICIENCY_MIN_COOLING": 0.45,
+                    "ERV_EFFICIENCY_MAX_COOLING": 0.6,
+                    "OAT_LOW_THRESHOLD": 32.0,
+                    "OAT_HIGH_THRESHOLD": 80.0,
+                    "OAT_RAT_DELTA_MIN": TEST_OAT_RAT_DELTA_THRES,
+                    "ERV_OAT_ENTER_COL": TEST_ERV_OAT_ENTER_COL,
+                    "ERV_OAT_LEAVING_COL": TEST_ERV_OAT_LEAVING_COL,
+                    "ERV_EAT_ENTER_COL": TEST_ERV_EAT_ENTER_COL,
+                    "ERV_EAT_LEAVING_COL": TEST_ERV_EAT_LEAVING_COL,
+                    "SUPPLY_VFD_SPEED_COL": TEST_SUPPLY_VFD_SPEED_COL,
+                }
+            )
+        assert "should be a float between 0.0 and 1.0" in str(excinfo.value)
+
+
+class TestFaultOnMissingColumns:
+
+    def test_missing_column(self):
+        """Test that MissingColumnError is raised if any required column is None or missing."""
+        with pytest.raises(MissingColumnError) as excinfo:
+            FaultConditionSixteen(
+                {
+                    "ERV_EFFICIENCY_MIN_HEATING": 0.65,
+                    "ERV_EFFICIENCY_MAX_HEATING": 0.8,
+                    "ERV_EFFICIENCY_MIN_COOLING": 0.45,
+                    "ERV_EFFICIENCY_MAX_COOLING": 0.6,
+                    "OAT_LOW_THRESHOLD": 32.0,
+                    "OAT_HIGH_THRESHOLD": 80.0,
+                    "OAT_RAT_DELTA_MIN": TEST_OAT_RAT_DELTA_THRES,
+                    "ERV_OAT_ENTER_COL": TEST_ERV_OAT_ENTER_COL,
+                    "ERV_OAT_LEAVING_COL": None,  # Missing column
+                    "ERV_EAT_ENTER_COL": TEST_ERV_EAT_ENTER_COL,
+                    "ERV_EAT_LEAVING_COL": TEST_ERV_EAT_LEAVING_COL,
+                    "SUPPLY_VFD_SPEED_COL": TEST_SUPPLY_VFD_SPEED_COL,
+                }
+            ).apply(
+                pd.DataFrame(
+                    {
+                        TEST_ERV_OAT_ENTER_COL: [10, 10, 10],
+                        TEST_ERV_EAT_ENTER_COL: [70, 70, 70],
+                        TEST_ERV_EAT_LEAVING_COL: [60, 60, 60],
+                        TEST_SUPPLY_VFD_SPEED_COL: [0.5, 0.5, 0.5],
+                    }
+                )
+            )
+        assert "One or more required columns are missing or None" in str(excinfo.value)
+
+
+if __name__ == "__main__":
+    pytest.main()

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: open_fdd
-Version: 0.1.5
+Version: 0.1.7
 Summary: A package for fault detection and diagnosis in HVAC systems
 Home-page: https://github.com/bbartling/open-fdd
 Author: Ben Bartling
@@ -47,10 +47,10 @@ The following are key objectives to enhance this project into a fully interactiv
 
 ### 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.
+ - [ ] Extend the project to include `central_plant` fault conditions, IPython reports, and example applications for boiler and chiller systems.
+
 
 ### 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.
@@ -58,6 +58,7 @@ The following are key objectives to enhance this project into a fully interactiv
 ### Future Considerations
  Explore additional features and enhancements as the project evolves.
  - [ ] Explore additional features and enhancements as the project evolves.
+ - [ ] Develop a comprehensive guide on a github.io website (or other?) for defining fault parameters, including error thresholds and other critical settings.
 
 
 ## Contribute

open_fdd-0.1.7.dist-info/RECORD

@@ -0,0 +1,31 @@
+open_fdd/__init__.py,sha256=iGj8QTOZJUTE4nNnBiCHXEXsOdV6YvKcGiLrnOusJCg,1411
+open_fdd/air_handling_unit/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+open_fdd/air_handling_unit/faults/__init__.py,sha256=Gc2VjfRDEX0-JcIrPuV692T3Ek3GGlTgrscqUXslrwY,93217
+open_fdd/air_handling_unit/faults/fault_condition.py,sha256=UN2_k2AZWMDoO4oPAnJW3fvhkHlMkLXZikzU2lXAOuQ,2364
+open_fdd/air_handling_unit/faults/helper_utils.py,sha256=el_s2BC9Q14GXUGnazOiBBhzVUMsPBP9sxEG1UIQ6Gw,12668
+open_fdd/air_handling_unit/faults/shared_utils.py,sha256=rAx27IsG_7OEHLLFHool6o9LAuaMyYisit9gLu8ZVQk,2802
+open_fdd/air_handling_unit/reports/__init__.py,sha256=JccL19Spj6vE0Jo_57CmZEFucu4WbCPj1-pIwR5LmPg,40741
+open_fdd/air_handling_unit/reports/fault_report.py,sha256=QxYLJzoLTwf1N0nls2XMmhHJvBSgGCBNT0KxA59QG4Y,1442
+open_fdd/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+open_fdd/tests/ahu/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+open_fdd/tests/ahu/test_ahu_fc1.py,sha256=Pw5XlQ19c5Sit0Lyuor8L8lKgxl5PFn4UhruIHyKDfc,5439
+open_fdd/tests/ahu/test_ahu_fc10.py,sha256=niYL7fi6OlgP0wnF8hNh9A07PLzHiRZkyRkrA1zoL2s,4577
+open_fdd/tests/ahu/test_ahu_fc11.py,sha256=mdXlGiEMPkPfshf3NN_nJavL74e4HCmkJQMu86aZc6Q,4723
+open_fdd/tests/ahu/test_ahu_fc12.py,sha256=5T-XcM6xm9KHrc121uPGC9JWLCYehrAYk0KcbmGgYjw,5848
+open_fdd/tests/ahu/test_ahu_fc13.py,sha256=vJlSy4e2WV9hx02P0SiJ75I1DWL2lZ0p7-AWlw97pks,5725
+open_fdd/tests/ahu/test_ahu_fc14.py,sha256=MU0LKqIuoQ_dJ0Kij8_A0YyimCMvUwL6IlMwpQhDbqI,8052
+open_fdd/tests/ahu/test_ahu_fc15.py,sha256=SIolJ9vnJwnpKfRW2ALugYWySuIiZ9_repWP9fdb5H4,7661
+open_fdd/tests/ahu/test_ahu_fc16.py,sha256=f656EZCWEKOXE2GZHUayaLc8bjMZWX_QB99QDBJxF4Y,9020
+open_fdd/tests/ahu/test_ahu_fc2.py,sha256=CjmO_WUyaSHs17ifCCew3GBJ43nYG55uGL0vHDZpAq8,4736
+open_fdd/tests/ahu/test_ahu_fc3.py,sha256=NB6pOXDS-R4P0LNoRN8ItAqhhLnGnGuAHZha32Qw-hE,4658
+open_fdd/tests/ahu/test_ahu_fc4.py,sha256=vV8jEnFuNGLfhCoTVz29RsIcoDpDOMWg722G0aBEXaE,6304
+open_fdd/tests/ahu/test_ahu_fc5.py,sha256=TpSQTBIF591Q3mVaBeJ6HyqPWhVHmD_gSZNEIFT6yyg,6538
+open_fdd/tests/ahu/test_ahu_fc6.py,sha256=66dwv0EBU_ujZK-J9Ki5a3fnXlk17nOwmtKDiQOHdbM,10351
+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.7.dist-info/LICENSE,sha256=eghao_GGx_0gB2Sll3x2vV29knONEzUQKrkaXpX1F7w,1087
+open_fdd-0.1.7.dist-info/METADATA,sha256=891NmSrFes9HOcjBiW0Lp7ixCbjN4lhorEWtOWICg0E,6958
+open_fdd-0.1.7.dist-info/WHEEL,sha256=uCRv0ZEik_232NlR4YDw4Pv3Ajt5bKvMH13NUU7hFuI,91
+open_fdd-0.1.7.dist-info/top_level.txt,sha256=Q7sB6UB2d8Ch1v_xIsTiNegmgcCXPkwkrxK3ug6VEOs,9
+open_fdd-0.1.7.dist-info/RECORD,,

{open_fdd-0.1.5.dist-info → open_fdd-0.1.7.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (72.1.0)
+Generator: setuptools (74.1.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

open_fdd/air_handling_unit/faults/fault_condition_eight.py

@@ -1,127 +0,0 @@
-import pandas as pd
-import numpy as np
-from open_fdd.air_handling_unit.faults.fault_condition import (
-    FaultCondition,
-    MissingColumnError,
-)
-import sys
-
-
-class FaultConditionEight(FaultCondition):
-    """Class provides the definitions for Fault Condition 8.
-    Supply air temperature and mix air temperature should
-    be approx equal in economizer mode.
-    """
-
-    def __init__(self, dict_):
-        super().__init__()
-        self.delta_t_supply_fan = float
-        self.mix_degf_err_thres = float
-        self.supply_degf_err_thres = float
-        self.ahu_min_oa_dpr = float
-        self.mat_col = str
-        self.sat_col = str
-        self.economizer_sig_col = str
-        self.cooling_sig_col = str
-        self.troubleshoot_mode = bool  # default should be False
-        self.rolling_window_size = int
-
-        self.equation_string = (
-            "fc8_flag = 1 if |SAT - MAT - ΔT_fan| > √(εSAT² + εMAT²) "
-            "in economizer mode for N consecutive values else 0 \n"
-        )
-        self.description_string = (
-            "Fault Condition 8: Supply air temperature and mixed air temperature should "
-            "be approximately equal in economizer mode \n"
-        )
-        self.required_column_description = (
-            "Required inputs are the mixed air temperature, supply air temperature, "
-            "economizer signal, and cooling signal \n"
-        )
-        self.error_string = f"One or more required columns are missing or None \n"
-
-        self.set_attributes(dict_)
-
-        # Set required columns specific to this fault condition
-        self.required_columns = [
-            self.mat_col,
-            self.sat_col,
-            self.economizer_sig_col,
-            self.cooling_sig_col,
-        ]
-
-        # Check if any of the required columns are None
-        if any(col is None for col in self.required_columns):
-            raise MissingColumnError(
-                f"{self.error_string}"
-                f"{self.equation_string}"
-                f"{self.description_string}"
-                f"{self.required_column_description}"
-                f"{self.required_columns}"
-            )
-
-        # Ensure all required columns are strings
-        self.required_columns = [str(col) for col in self.required_columns]
-
-        self.mapped_columns = (
-            f"Your config dictionary is mapped as: {', '.join(self.required_columns)}"
-        )
-
-    def get_required_columns(self) -> str:
-        """Returns a string representation of the required columns."""
-        return (
-            f"{self.equation_string}"
-            f"{self.description_string}"
-            f"{self.required_column_description}"
-            f"{self.mapped_columns}"
-        )
-
-    def apply(self, df: pd.DataFrame) -> pd.DataFrame:
-        try:
-            # Ensure all required columns are present
-            self.check_required_columns(df)
-
-            if self.troubleshoot_mode:
-                self.troubleshoot_cols(df)
-
-            # Check analog outputs [data with units of %] are floats only
-            columns_to_check = [
-                self.economizer_sig_col,
-                self.cooling_sig_col,
-            ]
-
-            self.check_analog_pct(df, columns_to_check)
-
-            df["sat_fan_mat"] = abs(
-                df[self.sat_col] - self.delta_t_supply_fan - df[self.mat_col]
-            )
-            df["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"])
-                & (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()
-            )
-            # 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()
-                del df["sat_fan_mat"]
-                del df["sat_mat_sqrted"]
-                del df["combined_check"]
-
-            return df
-
-        except MissingColumnError as e:
-            print(f"Error: {e.message}")
-            sys.stdout.flush()
-            raise e