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

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

open_fdd/air_handling_unit/faults/fault_condition_fifteen.py

@@ -1,152 +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 FaultConditionFifteen(FaultCondition):
-    """Class provides the definitions for Fault Condition 15.
-    Temperature rise across inactive heating coil.
-    Requires coil leaving temp sensor.
-    """
-
-    def __init__(self, dict_):
-        super().__init__()
-        self.delta_supply_fan = float
-        self.coil_temp_enter_err_thres = float
-        self.coil_temp_leav_err_thres = float
-        self.htg_coil_enter_temp_col = str
-        self.htg_coil_leave_temp_col = str
-        self.ahu_min_oa_dpr = float
-        self.cooling_sig_col = str
-        self.heating_sig_col = str
-        self.economizer_sig_col = str
-        self.supply_vfd_speed_col = str
-        self.troubleshoot_mode = bool  # default to False
-        self.rolling_window_size = int
-
-        self.equation_string = (
-            "fc15_flag = 1 if ΔT_coil >= √(εcoil_enter² + εcoil_leave²) + ΔT_fan "
-            "in inactive heating coil mode for N consecutive values else 0 \n"
-        )
-        self.description_string = (
-            "Fault Condition 15: Temperature rise across inactive heating coil "
-            "detected, requiring coil leaving temperature sensor \n"
-        )
-        self.required_column_description = (
-            "Required inputs are the heating coil entering temperature, heating coil leaving temperature, "
-            "cooling signal, heating signal, economizer signal, and supply fan VFD speed \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.htg_coil_enter_temp_col,
-            self.htg_coil_leave_temp_col,
-            self.cooling_sig_col,
-            self.heating_sig_col,
-            self.economizer_sig_col,
-            self.supply_vfd_speed_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.heating_sig_col,
-                self.supply_vfd_speed_col,
-            ]
-            self.check_analog_pct(df, columns_to_check)
-
-            # Create helper columns
-            df["htg_delta_temp"] = (
-                df[self.htg_coil_leave_temp_col] - df[self.htg_coil_enter_temp_col]
-            )
-
-            df["htg_delta_sqrted"] = (
-                np.sqrt(
-                    self.coil_temp_enter_err_thres**2 + self.coil_temp_leav_err_thres**2
-                )
-                + self.delta_supply_fan
-            )
-
-            df["combined_check"] = (
-                (
-                    (df["htg_delta_temp"] >= df["htg_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)
-                )
-                | (
-                    (df["htg_delta_temp"] >= df["htg_delta_sqrted"])
-                    # OS4 AHU state clg @ min OA
-                    & (df[self.cooling_sig_col] > 0.01)
-                    & (df[self.economizer_sig_col] == self.ahu_min_oa_dpr)
-                )
-                | (
-                    (df["htg_delta_temp"] >= df["htg_delta_sqrted"])
-                    # 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["fc15_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["htg_delta_temp"]
-                del df["htg_delta_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_five.py

@@ -1,123 +0,0 @@
-import pandas as pd
-import pandas.api.types as pdtypes
-from open_fdd.air_handling_unit.faults.fault_condition import (
-    FaultCondition,
-    MissingColumnError,
-)
-import sys
-
-
-class FaultConditionFive(FaultCondition):
-    """Class provides the definitions for Fault Condition 5.
-    SAT too low; should be higher than MAT in HTG MODE
-    --Broken heating valve or other mechanical issue
-    related to heat valve not working as designed
-    """
-
-    def __init__(self, dict_):
-        super().__init__()
-        self.mix_degf_err_thres = float
-        self.supply_degf_err_thres = float
-        self.delta_t_supply_fan = float
-        self.mat_col = str
-        self.sat_col = str
-        self.heating_sig_col = str
-        self.supply_vfd_speed_col = str
-        self.troubleshoot_mode = bool  # default to False
-        self.rolling_window_size = int
-
-        self.equation_string = (
-            "fc5_flag = 1 if (SAT + εSAT <= MAT - εMAT + ΔT_supply_fan) and "
-            "(heating signal > 0) and (VFDSPD > 0) for N consecutive values else 0 \n"
-        )
-        self.description_string = (
-            "Fault Condition 5: SAT too low; should be higher than MAT in HTG MODE, "
-            "potential broken heating valve or mechanical issue \n"
-        )
-        self.required_column_description = (
-            "Required inputs are the mixed air temperature, supply air temperature, "
-            "heating signal, and supply fan VFD speed \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.heating_sig_col,
-            self.supply_vfd_speed_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.supply_vfd_speed_col, self.heating_sig_col]
-
-            for col in columns_to_check:
-                self.check_analog_pct(df, [col])
-
-            df["sat_check"] = df[self.sat_col] + self.supply_degf_err_thres
-            df["mat_check"] = (
-                df[self.mat_col] - self.mix_degf_err_thres + self.delta_t_supply_fan
-            )
-
-            df["combined_check"] = (
-                (df["sat_check"] <= df["mat_check"])
-                & (df[self.heating_sig_col] > 0.01)
-                & (df[self.supply_vfd_speed_col] > 0.01)
-            )
-
-            # 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["fc5_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["mat_check"]
-                del df["sat_check"]
-                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_four.py

@@ -1,168 +0,0 @@
-import pandas as pd
-from open_fdd.air_handling_unit.faults.fault_condition import (
-    FaultCondition,
-    MissingColumnError,
-)
-import sys
-
-
-class FaultConditionFour(FaultCondition):
-    """Class provides the definitions for Fault Condition 4.
-
-    This fault flags excessive operating states on the AHU
-    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
-        self.heating_sig_col = str
-        self.cooling_sig_col = str
-        self.supply_vfd_speed_col = str
-        self.troubleshoot_mode = bool  # default to False
-
-        self.equation_string = (
-            "fc4_flag = 1 if excessive mode changes (> δOS_max) occur "
-            "within an hour across heating, econ, econ+mech, mech clg, and min OA modes \n"
-        )
-        self.description_string = "Fault Condition 4: Excessive AHU operating state changes detected (hunting behavior) \n"
-        self.required_column_description = (
-            "Required inputs are the economizer signal, supply fan VFD speed, "
-            "and optionally heating and cooling signals \n"
-        )
-        self.error_string = f"One or more required columns are missing or None \n"
-
-        self.set_attributes(dict_)
-
-        # Set required columns, making heating and cooling optional
-        self.required_columns = [
-            self.economizer_sig_col,
-            self.supply_vfd_speed_col,
-        ]
-
-        # 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)
-
-        # 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 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