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

open_fdd/air_handling_unit/reports/fault_report.py

@@ -0,0 +1,42 @@
+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_plot(df)
+            self.create_hist_plot(df)
+        else:
+            print("NO FAULTS FOUND - Skipping time-of-day Histogram plot")
+            sys.stdout.flush()

open_fdd/tests/ahu/test_ahu_fc16.py

@@ -0,0 +1,190 @@
+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_ERV_DEGF_ERR_THRES = 2.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,
+    "ERV_DEGF_ERR_THRES": TEST_ERV_DEGF_ERR_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
+
+
+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,
+                    "ERV_DEGF_ERR_THRES": 2.0,
+                    "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,
+                    "ERV_DEGF_ERR_THRES": 2.0,
+                    "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,
+                    "ERV_DEGF_ERR_THRES": 2.0,
+                    "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.4.dist-info → open_fdd-0.1.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: open_fdd
-Version: 0.1.4
+Version: 0.1.6
 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,29 @@ 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.
+ - [ ] Extend the project to include `central_plant` fault conditions, IPython reports, and example applications for boiler and chiller systems.
+
+
+### Upcoming
+ - [ ] 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.
+ - [ ] Develop a comprehensive guide on a github.io website (or other?) for defining fault parameters, including error thresholds and other critical settings.
+
+
+## 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.6.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=NBdGNlp0MTUPNB-43zgnYs3iYqFhEeNa3q_VgDPGAoo,91603
+open_fdd/air_handling_unit/faults/fault_condition.py,sha256=UN2_k2AZWMDoO4oPAnJW3fvhkHlMkLXZikzU2lXAOuQ,2364
+open_fdd/air_handling_unit/faults/helper_utils.py,sha256=-Bd1mMMLnFmpNPe7eC23kMJxPtazsIyz5P7W6Yqlu4w,12580
+open_fdd/air_handling_unit/faults/shared_utils.py,sha256=Kp8ZUBhtrh-jU2Q_bbXTpnbVVUAyacp41tDMknY50i4,2252
+open_fdd/air_handling_unit/reports/__init__.py,sha256=iXIqEaaO_8yRnlVUuYMcc_L0xQf3iqSYi3ykIzeGBf8,40124
+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=ojpdYGZtuIYAKnZ4W9KhxQuoyXnGEI5N7braQXh3kAw,5437
+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=3xhNfN2pKon-2_jyCUSh_JEKSv9jYGiTxRjLOL7uvVI,8052
+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.6.dist-info/LICENSE,sha256=eghao_GGx_0gB2Sll3x2vV29knONEzUQKrkaXpX1F7w,1087
+open_fdd-0.1.6.dist-info/METADATA,sha256=IER_eG7nwqbDIoDA2a9LyFgh20pOeBYhAGHlhT1PFLo,6958
+open_fdd-0.1.6.dist-info/WHEEL,sha256=UvcQYKBHoFqaQd6LKyqHw9fxEolWLQnlzP0h_LgJAfI,91
+open_fdd-0.1.6.dist-info/top_level.txt,sha256=Q7sB6UB2d8Ch1v_xIsTiNegmgcCXPkwkrxK3ug6VEOs,9
+open_fdd-0.1.6.dist-info/RECORD,,

{open_fdd-0.1.4.dist-info → open_fdd-0.1.6.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (72.1.0)
+Generator: setuptools (74.0.0)
 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

open_fdd/air_handling_unit/faults/fault_condition_eleven.py

@@ -1,126 +0,0 @@
-import pandas as pd
-from open_fdd.air_handling_unit.faults.fault_condition import (
-    FaultCondition,
-    MissingColumnError,
-)
-import sys
-
-
-class FaultConditionEleven(FaultCondition):
-    """Class provides the definitions for Fault Condition 11.
-    Outside air temperature too low for 100% outdoor
-    air cooling in economizer cooling mode.
-    Economizer performance fault
-    """
-
-    def __init__(self, dict_):
-        super().__init__()
-        self.delta_t_supply_fan = float
-        self.outdoor_degf_err_thres = float
-        self.supply_degf_err_thres = float
-        self.sat_setpoint_col = str
-        self.oat_col = str
-        self.cooling_sig_col = str
-        self.economizer_sig_col = str
-        self.troubleshoot_mode = bool  # default False
-        self.rolling_window_size = int
-
-        self.equation_string = (
-            "fc11_flag = 1 if OAT < (SATSP - ΔT_fan - εSAT) in "
-            "economizer cooling mode for N consecutive values else 0 \n"
-        )
-        self.description_string = (
-            "Fault Condition 11: Outside air temperature too low for 100% outdoor air cooling "
-            "in economizer cooling mode (Economizer performance fault) \n"
-        )
-        self.required_column_description = (
-            "Required inputs are the supply air temperature setpoint, outside air temperature, "
-            "cooling signal, and economizer signal \n"
-        )
-        self.error_string = 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.sat_setpoint_col,
-            self.oat_col,
-            self.cooling_sig_col,
-            self.economizer_sig_col,
-        ]
-
-        # Check if any of the required columns are None
-        if any(col is None for col in self.required_columns):
-            raise MissingColumnError(
-                f"{self.error_string}"
-                f"{self.equation_string}"
-                f"{self.description_string}"
-                f"{self.required_column_description}"
-                f"{self.required_columns}"
-            )
-
-        # Ensure all required columns are strings
-        self.required_columns = [str(col) for col in self.required_columns]
-
-        self.mapped_columns = (
-            f"Your config dictionary is mapped as: {', '.join(self.required_columns)}"
-        )
-
-    def get_required_columns(self) -> str:
-        """Returns a string representation of the required columns."""
-        return (
-            f"{self.equation_string}"
-            f"{self.description_string}"
-            f"{self.required_column_description}"
-            f"{self.mapped_columns}"
-        )
-
-    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["oat_plus_oaterror"] = df[self.oat_col] + self.outdoor_degf_err_thres
-            df["satsp_delta_saterr"] = (
-                df[self.sat_setpoint_col]
-                - self.delta_t_supply_fan
-                - self.supply_degf_err_thres
-            )
-
-            df["combined_check"] = (
-                (df["oat_plus_oaterror"] < df["satsp_delta_saterr"])
-                # verify ahu is running in OS 3 clg mode in 100 OA
-                & (df[self.cooling_sig_col] > 0.01)
-                & (df[self.economizer_sig_col] > 0.9)
-            )
-
-            # Rolling sum to count consecutive trues
-            rolling_sum = (
-                df["combined_check"].rolling(window=self.rolling_window_size).sum()
-            )
-            # Set flag to 1 if rolling sum equals the window size
-            df["fc11_flag"] = (rolling_sum >= self.rolling_window_size).astype(int)
-
-            if self.troubleshoot_mode:
-                print("Troubleshoot mode enabled - not removing helper columns")
-                sys.stdout.flush()
-                del df["oat_plus_oaterror"]
-                del df["satsp_delta_saterr"]
-                del df["combined_check"]
-
-            return df
-
-        except MissingColumnError as e:
-            print(f"Error: {e.message}")
-            sys.stdout.flush()
-            raise e