open-fdd 0.1.0__py3-none-any.whl → 0.1.3__py3-none-any.whl

open_fdd/air_handling_unit/faults/fault_condition_four.py

@@ -1,6 +1,8 @@
 import pandas as pd
-from open_fdd.air_handling_unit.faults.fault_condition import FaultCondition
-from open_fdd.air_handling_unit.faults.helper_utils import HelperUtils
+from open_fdd.air_handling_unit.faults.fault_condition import (
+    FaultCondition,
+    MissingColumnError,
+)
 import sys
 
 
@@ -8,14 +10,14 @@ class FaultConditionFour(FaultCondition):
     """Class provides the definitions for Fault Condition 4.
 
     This fault flags excessive operating states on the AHU
-    if its hunting between heating, econ, econ+mech, and
+    if it's hunting between heating, econ, econ+mech, and
     a mech clg modes. The code counts how many operating
     changes in an hour and will throw a fault if there is
     excessive OS changes to flag control sys hunting.
-
     """
 
     def __init__(self, dict_):
+        super().__init__()
         self.delta_os_max = float
         self.ahu_min_oa_dpr = float
         self.economizer_sig_col = str
@@ -26,68 +28,109 @@ class FaultConditionFour(FaultCondition):
 
         self.set_attributes(dict_)
 
-    # adds in these boolean columns to the dataframe
-    def apply(self, df: pd.DataFrame) -> pd.DataFrame:
-        if self.troubleshoot_mode:
-            self.troubleshoot_cols(df)
-
-        # check analog outputs [data with units of %] are floats only
-        columns_to_check = [
+        # Set required columns, making heating and cooling optional
+        self.required_columns = [
             self.economizer_sig_col,
-            self.heating_sig_col,
-            self.cooling_sig_col,
             self.supply_vfd_speed_col,
         ]
 
-        for col in columns_to_check:
-            self.check_analog_pct(df, [col])
-
-        print("=" * 50)
-        print("Warning: The program is in FC4 and resampling the data")
-        print("to compute AHU OS state changes per hour")
-        print("to flag any hunting issue")
-        print("and this usually takes a while to run...")
-        print("=" * 50)
-
-        sys.stdout.flush()
-
-        # AHU htg only mode based on OA damper @ min oa and only htg pid/vlv modulating
-        df["heating_mode"] = (
-            (df[self.heating_sig_col] > 0)
-            & (df[self.cooling_sig_col] == 0)
-            & (df[self.supply_vfd_speed_col] > 0)
-            & (df[self.economizer_sig_col] == self.ahu_min_oa_dpr)
-        )
-
-        # AHU econ only mode based on OA damper modulating and clg htg = zero
-        df["econ_only_cooling_mode"] = (
-            (df[self.heating_sig_col] == 0)
-            & (df[self.cooling_sig_col] == 0)
-            & (df[self.supply_vfd_speed_col] > 0)
-            & (df[self.economizer_sig_col] > self.ahu_min_oa_dpr)
-        )
-
-        # AHU econ+mech clg mode based on OA damper modulating for cooling and clg pid/vlv modulating
-        df["econ_plus_mech_cooling_mode"] = (
-            (df[self.heating_sig_col] == 0)
-            & (df[self.cooling_sig_col] > 0)
-            & (df[self.supply_vfd_speed_col] > 0)
-            & (df[self.economizer_sig_col] > self.ahu_min_oa_dpr)
-        )
-
-        # AHU mech mode based on OA damper @ min OA and clg pid/vlv modulating
-        df["mech_cooling_only_mode"] = (
-            (df[self.heating_sig_col] == 0)
-            & (df[self.cooling_sig_col] > 0)
-            & (df[self.supply_vfd_speed_col] > 0)
-            & (df[self.economizer_sig_col] == self.ahu_min_oa_dpr)
-        )
-
-        # Fill non-finite values with zero or drop them
-        df = df.fillna(0)
-
-        df = df.astype(int)
-        df = df.resample("60min").apply(lambda x: (x.eq(1) & x.shift().ne(1)).sum())
-
-        df["fc4_flag"] = df[df.columns].gt(self.delta_os_max).any(axis=1).astype(int)
-        return df
+        # If heating or cooling columns are provided, add them to the required columns
+        if self.heating_sig_col:
+            self.required_columns.append(self.heating_sig_col)
+        if self.cooling_sig_col:
+            self.required_columns.append(self.cooling_sig_col)
+
+    def get_required_columns(self) -> str:
+        """Returns a string representation of the required columns."""
+        return f"Required columns for FaultConditionFour: {', '.join(self.required_columns)}"
+
+    def apply(self, df: pd.DataFrame) -> pd.DataFrame:
+        try:
+            # Ensure all required columns are present
+            self.check_required_columns(df)
+
+            # If the optional columns are not present, create them with all values set to 0.0
+            if self.heating_sig_col not in df.columns:
+                df[self.heating_sig_col] = 0.0
+            if self.cooling_sig_col not in df.columns:
+                df[self.cooling_sig_col] = 0.0
+
+            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.heating_sig_col,
+                self.cooling_sig_col,
+                self.supply_vfd_speed_col,
+            ]
+
+            for col in columns_to_check:
+                self.check_analog_pct(df, [col])
+
+            print("=" * 50)
+            print("Warning: The program is in FC4 and resampling the data")
+            print("to compute AHU OS state changes per hour")
+            print("to flag any hunting issue")
+            print("and this usually takes a while to run...")
+            print("=" * 50)
+
+            sys.stdout.flush()
+
+            # AHU htg only mode based on OA damper @ min oa and only htg pid/vlv modulating
+            df["heating_mode"] = (
+                (df[self.heating_sig_col] > 0)
+                & (df[self.cooling_sig_col] == 0)
+                & (df[self.supply_vfd_speed_col] > 0)
+                & (df[self.economizer_sig_col] == self.ahu_min_oa_dpr)
+            )
+
+            # AHU econ only mode based on OA damper modulating and clg htg = zero
+            df["econ_only_cooling_mode"] = (
+                (df[self.heating_sig_col] == 0)
+                & (df[self.cooling_sig_col] == 0)
+                & (df[self.supply_vfd_speed_col] > 0)
+                & (df[self.economizer_sig_col] > self.ahu_min_oa_dpr)
+            )
+
+            # AHU econ+mech clg mode based on OA damper modulating for cooling and clg pid/vlv modulating
+            df["econ_plus_mech_cooling_mode"] = (
+                (df[self.heating_sig_col] == 0)
+                & (df[self.cooling_sig_col] > 0)
+                & (df[self.supply_vfd_speed_col] > 0)
+                & (df[self.economizer_sig_col] > self.ahu_min_oa_dpr)
+            )
+
+            # AHU mech mode based on OA damper @ min OA and clg pid/vlv modulating
+            df["mech_cooling_only_mode"] = (
+                (df[self.heating_sig_col] == 0)
+                & (df[self.cooling_sig_col] > 0)
+                & (df[self.supply_vfd_speed_col] > 0)
+                & (df[self.economizer_sig_col] == self.ahu_min_oa_dpr)
+            )
+
+            # AHU minimum OA mode without heating or cooling (ventilation mode)
+            df["min_oa_mode_only"] = (
+                (df[self.heating_sig_col] == 0)
+                & (df[self.cooling_sig_col] == 0)
+                & (df[self.supply_vfd_speed_col] > 0)
+                & (df[self.economizer_sig_col] == self.ahu_min_oa_dpr)
+            )
+
+            # Fill non-finite values with zero or drop them
+            df = df.fillna(0)
+
+            df = df.astype(int)
+            df = df.resample("60min").apply(lambda x: (x.eq(1) & x.shift().ne(1)).sum())
+
+            df["fc4_flag"] = (
+                df[df.columns].gt(self.delta_os_max).any(axis=1).astype(int)
+            )
+
+            return df
+
+        except MissingColumnError as e:
+            print(f"Error: {e.message}")
+            sys.stdout.flush()
+            raise e  # Re-raise the exception so it can be caught by pytest

open_fdd/air_handling_unit/faults/fault_condition_fourteen.py

@@ -1,8 +1,10 @@
 import pandas as pd
 import numpy as np
-from open_fdd.air_handling_unit.faults.fault_condition import FaultCondition
-from open_fdd.air_handling_unit.faults.helper_utils import HelperUtils
 import operator
+from open_fdd.air_handling_unit.faults.fault_condition import (
+    FaultCondition,
+    MissingColumnError,
+)
 import sys
 
 
@@ -13,6 +15,7 @@ class FaultConditionFourteen(FaultCondition):
     """
 
     def __init__(self, dict_):
+        super().__init__()
         self.delta_t_supply_fan = float
         self.coil_temp_enter_err_thres = float
         self.coil_temp_leav_err_thres = float
@@ -28,53 +31,77 @@ class FaultConditionFourteen(FaultCondition):
 
         self.set_attributes(dict_)
 
-    def apply(self, df: pd.DataFrame) -> pd.DataFrame:
-        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,
+        # Set required columns specific to this fault condition
+        self.required_columns = [
+            self.clg_coil_enter_temp_col,
+            self.clg_coil_leave_temp_col,
             self.cooling_sig_col,
             self.heating_sig_col,
+            self.economizer_sig_col,
             self.supply_vfd_speed_col,
         ]
-        self.check_analog_pct(df, columns_to_check)
 
-        # Create helper columns
-        df["clg_delta_temp"] = (
-            df[self.clg_coil_enter_temp_col] - df[self.clg_coil_leave_temp_col]
-        )
+    def get_required_columns(self) -> str:
+        """Returns a string representation of the required columns."""
+        return f"Required columns for FaultConditionFourteen: {', '.join(self.required_columns)}"
 
-        df["clg_delta_sqrted"] = (
-            np.sqrt(
-                self.coil_temp_enter_err_thres**2 + self.coil_temp_leav_err_thres**2
+    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.heating_sig_col,
+                self.supply_vfd_speed_col,
+            ]
+            self.check_analog_pct(df, columns_to_check)
+
+            # Create helper columns
+            df["clg_delta_temp"] = (
+                df[self.clg_coil_enter_temp_col] - df[self.clg_coil_leave_temp_col]
             )
-            + self.delta_t_supply_fan
-        )
-
-        df["combined_check"] = operator.or_(
-            (df["clg_delta_temp"] >= df["clg_delta_sqrted"])
-            # verify AHU is in OS2 only free cooling mode
-            & (df[self.economizer_sig_col] > self.ahu_min_oa_dpr)
-            & (df[self.cooling_sig_col] < 0.1),  # OR
-            (df["clg_delta_temp"] >= df["clg_delta_sqrted"])
-            # verify AHU is running in OS 1 at near full heat
-            & (df[self.heating_sig_col] > 0.0) & (df[self.supply_vfd_speed_col] > 0.0),
-        )
-
-        # Rolling sum to count consecutive trues
-        rolling_sum = (
-            df["combined_check"].rolling(window=self.rolling_window_size).sum()
-        )
-        # Set flag to 1 if rolling sum equals the window size
-        df["fc14_flag"] = (rolling_sum >= self.rolling_window_size).astype(int)
-
-        if self.troubleshoot_mode:
-            print("Troubleshoot mode enabled - not removing helper columns")
-            sys.stdout.flush()
-            del df["clg_delta_temp"]
-            del df["clg_delta_sqrted"]
-            del df["combined_check"]
 
-        return df
+            df["clg_delta_sqrted"] = (
+                np.sqrt(
+                    self.coil_temp_enter_err_thres**2 + self.coil_temp_leav_err_thres**2
+                )
+                + self.delta_t_supply_fan
+            )
+
+            df["combined_check"] = operator.or_(
+                (df["clg_delta_temp"] >= df["clg_delta_sqrted"])
+                # verify AHU is in OS2 only free cooling mode
+                & (df[self.economizer_sig_col] > self.ahu_min_oa_dpr)
+                & (df[self.cooling_sig_col] < 0.1),  # OR
+                (df["clg_delta_temp"] >= df["clg_delta_sqrted"])
+                # verify AHU is running in OS 1 at near full heat
+                & (df[self.heating_sig_col] > 0.0)
+                & (df[self.supply_vfd_speed_col] > 0.0),
+            )
+
+            # Rolling sum to count consecutive trues
+            rolling_sum = (
+                df["combined_check"].rolling(window=self.rolling_window_size).sum()
+            )
+            # Set flag to 1 if rolling sum equals the window size
+            df["fc14_flag"] = (rolling_sum >= self.rolling_window_size).astype(int)
+
+            if self.troubleshoot_mode:
+                print("Troubleshoot mode enabled - not removing helper columns")
+                sys.stdout.flush()
+                del df["clg_delta_temp"]
+                del df["clg_delta_sqrted"]
+                del df["combined_check"]
+
+            return df
+
+        except MissingColumnError as e:
+            print(f"Error: {e.message}")
+            sys.stdout.flush()
+            raise e  # Re-raise the exception so it can be caught by pytest

open_fdd/air_handling_unit/faults/fault_condition_nine.py

@@ -1,7 +1,9 @@
 import pandas as pd
 import numpy as np
-from open_fdd.air_handling_unit.faults.fault_condition import FaultCondition
-from open_fdd.air_handling_unit.faults.helper_utils import HelperUtils
+from open_fdd.air_handling_unit.faults.fault_condition import (
+    FaultCondition,
+    MissingColumnError,
+)
 import sys
 
 
@@ -12,6 +14,7 @@ class FaultConditionNine(FaultCondition):
     """
 
     def __init__(self, dict_):
+        super().__init__()
         self.delta_t_supply_fan = float
         self.outdoor_degf_err_thres = float
         self.supply_degf_err_thres = float
@@ -25,44 +28,65 @@ class FaultConditionNine(FaultCondition):
 
         self.set_attributes(dict_)
 
-    def apply(self, df: pd.DataFrame) -> pd.DataFrame:
-        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,
+        # 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,
         ]
-        self.check_analog_pct(df, columns_to_check)
 
-        # Create helper columns
-        df["oat_minus_oaterror"] = df[self.oat_col] - self.outdoor_degf_err_thres
-        df["satsp_delta_saterr"] = (
-            df[self.sat_setpoint_col]
-            - self.delta_t_supply_fan
-            + self.supply_degf_err_thres
-        )
+    def get_required_columns(self) -> str:
+        """Returns a string representation of the required columns."""
+        return f"Required columns for FaultConditionNine: {', '.join(self.required_columns)}"
 
-        df["combined_check"] = (
-            (df["oat_minus_oaterror"] > df["satsp_delta_saterr"])
-            # verify AHU is in OS2 only free cooling mode
-            & (df[self.economizer_sig_col] > self.ahu_min_oa_dpr)
-            & (df[self.cooling_sig_col] < 0.1)
-        )
+    def apply(self, df: pd.DataFrame) -> pd.DataFrame:
+        try:
+            # Ensure all required columns are present
+            self.check_required_columns(df)
 
-        # 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["fc9_flag"] = (rolling_sum >= self.rolling_window_size).astype(int)
+            if self.troubleshoot_mode:
+                self.troubleshoot_cols(df)
 
-        if self.troubleshoot_mode:
-            print("Troubleshoot mode enabled - not removing helper columns")
-            sys.stdout.flush()
-            del df["oat_minus_oaterror"]
-            del df["satsp_delta_saterr"]
-            del df["combined_check"]
+            # 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)
 
-        return df
+            # Create helper columns
+            df["oat_minus_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_minus_oaterror"] > df["satsp_delta_saterr"])
+                # verify AHU is in OS2 only free cooling mode
+                & (df[self.economizer_sig_col] > self.ahu_min_oa_dpr)
+                & (df[self.cooling_sig_col] < 0.1)
+            )
+
+            # Rolling sum to count consecutive trues
+            rolling_sum = (
+                df["combined_check"].rolling(window=self.rolling_window_size).sum()
+            )
+            # Set flag to 1 if rolling sum equals the window size
+            df["fc9_flag"] = (rolling_sum >= self.rolling_window_size).astype(int)
+
+            if self.troubleshoot_mode:
+                print("Troubleshoot mode enabled - not removing helper columns")
+                sys.stdout.flush()
+                del df["oat_minus_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  # Re-raise the exception so it can be caught by pytest

open_fdd/air_handling_unit/faults/fault_condition_one.py

@@ -1,5 +1,8 @@
 import pandas as pd
-from open_fdd.air_handling_unit.faults.fault_condition import FaultCondition
+from open_fdd.air_handling_unit.faults.fault_condition import (
+    FaultCondition,
+    MissingColumnError,
+)
 import sys
 
 
@@ -9,9 +12,7 @@ class FaultConditionOne(FaultCondition):
     """
 
     def __init__(self, dict_):
-        """
-        :param dict_:
-        """
+        super().__init__()
         self.vfd_speed_percent_err_thres = float
         self.vfd_speed_percent_max = float
         self.duct_static_inches_err_thres = float
@@ -23,38 +24,58 @@ class FaultConditionOne(FaultCondition):
 
         self.set_attributes(dict_)
 
+        # Set required columns specific to this fault condition manually
+        self.required_columns = [
+            self.duct_static_col,
+            self.supply_vfd_speed_col,
+            self.duct_static_setpoint_col,
+        ]
+
+    def get_required_columns(self) -> str:
+        """Returns a string representation of the required columns."""
+        return f"Required columns for FaultConditionOne: {', '.join(self.required_columns)}"
+
     def apply(self, df: pd.DataFrame) -> pd.DataFrame:
-        if self.troubleshoot_mode:
-            self.troubleshoot_cols(df)
-
-        # check analog outputs [data with units of %] are floats only
-        columns_to_check = [self.supply_vfd_speed_col]
-        self.check_analog_pct(df, columns_to_check)
-
-        df["static_check_"] = (
-            df[self.duct_static_col]
-            < df[self.duct_static_setpoint_col] - self.duct_static_inches_err_thres
-        )
-        df["fan_check_"] = (
-            df[self.supply_vfd_speed_col]
-            >= self.vfd_speed_percent_max - self.vfd_speed_percent_err_thres
-        )
-
-        # Combined condition check
-        df["combined_check"] = df["static_check_"] & df["fan_check_"]
-
-        # 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["fc1_flag"] = (rolling_sum == self.rolling_window_size).astype(int)
-
-        if self.troubleshoot_mode:
-            print("Troubleshoot mode enabled - not removing helper columns")
-            sys.stdout.flush()
-            del df["static_check_"]
-            del df["fan_check_"]
-            del df["combined_check"]
+        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.supply_vfd_speed_col]
+            self.check_analog_pct(df, columns_to_check)
+
+            df["static_check_"] = (
+                df[self.duct_static_col]
+                < df[self.duct_static_setpoint_col] - self.duct_static_inches_err_thres
+            )
+            df["fan_check_"] = (
+                df[self.supply_vfd_speed_col]
+                >= self.vfd_speed_percent_max - self.vfd_speed_percent_err_thres
+            )
 
-        return df
+            # Combined condition check
+            df["combined_check"] = df["static_check_"] & df["fan_check_"]
+
+            # 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["fc1_flag"] = (rolling_sum == self.rolling_window_size).astype(int)
+
+            if self.troubleshoot_mode:
+                print("Troubleshoot mode enabled - not removing helper columns")
+                sys.stdout.flush()
+                del df["static_check_"]
+                del df["fan_check_"]
+                del df["combined_check"]
+
+            return df
+
+        except MissingColumnError as e:
+            print(f"Error: {e.message}")
+            sys.stdout.flush()
+            raise e  # Re-raise the exception so it can be caught by pytest