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

open_fdd/air_handling_unit/faults/fault_condition_fourteen.py

@@ -1,143 +0,0 @@
-import pandas as pd
-import numpy as np
-import operator
-from open_fdd.air_handling_unit.faults.fault_condition import (
-    FaultCondition,
-    MissingColumnError,
-)
-import sys
-
-
-class FaultConditionFourteen(FaultCondition):
-    """Class provides the definitions for Fault Condition 14.
-    Temperature drop across inactive cooling coil.
-    Requires coil leaving temp sensor.
-    """
-
-    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
-        self.clg_coil_enter_temp_col = str
-        self.clg_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 = (
-            "fc14_flag = 1 if ΔT_coil >= √(εcoil_enter² + εcoil_leave²) + ΔT_fan "
-            "in inactive cooling coil mode for N consecutive values else 0 \n"
-        )
-        self.description_string = (
-            "Fault Condition 14: Temperature drop across inactive cooling coil "
-            "detected, requiring coil leaving temperature sensor \n"
-        )
-        self.required_column_description = (
-            "Required inputs are the cooling coil entering temperature, cooling 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.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,
-        ]
-
-        # 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["clg_delta_temp"] = (
-                df[self.clg_coil_enter_temp_col] - df[self.clg_coil_leave_temp_col]
-            )
-
-            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

open_fdd/air_handling_unit/faults/fault_condition_nine.py

@@ -1,128 +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 FaultConditionNine(FaultCondition):
-    """Class provides the definitions for Fault Condition 9.
-    Outside air temperature too high in free cooling without
-    additional mechanical cooling in economizer mode.
-    """
-
-    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.ahu_min_oa_dpr = 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 should be False
-        self.rolling_window_size = int
-
-        self.equation_string = (
-            "fc9_flag = 1 if OAT > (SATSP - ΔT_fan + εSAT) "
-            "in free cooling mode for N consecutive values else 0 \n"
-        )
-        self.description_string = (
-            "Fault Condition 9: Outside air temperature too high in free cooling mode "
-            "without additional mechanical cooling in economizer mode \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)
-
-            # 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

open_fdd/air_handling_unit/faults/fault_condition_one.py

@@ -1,112 +0,0 @@
-import pandas as pd
-from open_fdd.air_handling_unit.faults.fault_condition import (
-    FaultCondition,
-    MissingColumnError,
-)
-import sys
-
-
-class FaultConditionOne(FaultCondition):
-    """Class provides the definitions for Fault Condition 1.
-    AHU low duct static pressure fan fault.
-    """
-
-    def __init__(self, dict_):
-        super().__init__()
-        self.vfd_speed_percent_err_thres = float
-        self.vfd_speed_percent_max = float
-        self.duct_static_inches_err_thres = float
-        self.duct_static_col = str
-        self.supply_vfd_speed_col = str
-        self.duct_static_setpoint_col = str
-        self.troubleshoot_mode = bool  # default should be False
-        self.rolling_window_size = int
-
-        self.equation_string = "fc1_flag = 1 if (DSP < DPSP - εDSP) and (VFDSPD >= VFDSPD_max - εVFDSPD) for N consecutive values else 0 \n"
-        self.description_string = (
-            "Fault Condition 1: Duct static too low at fan at full speed \n"
-        )
-        self.required_column_description = "Required inputs are the duct static pressure, setpoint, 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 manually
-        self.required_columns = [
-            self.duct_static_col,
-            self.supply_vfd_speed_col,
-            self.duct_static_setpoint_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:
-        """called from IPython to print out"""
-        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.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()
-
-            # Optionally remove temporary columns
-            df.drop(
-                columns=["static_check_", "fan_check_", "combined_check"], inplace=True
-            )
-
-            return df
-
-        except MissingColumnError as e:
-            print(f"Error: {e.message}")
-            sys.stdout.flush()
-            raise e

open_fdd/air_handling_unit/faults/fault_condition_seven.py

@@ -1,114 +0,0 @@
-import pandas as pd
-from open_fdd.air_handling_unit.faults.fault_condition import (
-    FaultCondition,
-    MissingColumnError,
-)
-import sys
-
-
-class FaultConditionSeven(FaultCondition):
-    """Class provides the definitions for Fault Condition 7.
-    Very similar to FC 13 but uses heating valve.
-    Supply air temperature too low in full heating.
-    """
-
-    def __init__(self, dict_):
-        super().__init__()
-        self.supply_degf_err_thres = float
-        self.sat_col = str
-        self.sat_setpoint_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 = (
-            "fc7_flag = 1 if SAT < (SATSP - εSAT) in full heating mode "
-            "and VFD speed > 0 for N consecutive values else 0 \n"
-        )
-        self.description_string = (
-            "Fault Condition 7: Supply air temperature too low in full heating mode "
-            "with heating valve fully open \n"
-        )
-        self.required_column_description = (
-            "Required inputs are the supply air temperature, supply air temperature setpoint, "
-            "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.sat_col,
-            self.sat_setpoint_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]
-            self.check_analog_pct(df, columns_to_check)
-
-            # Fault condition-specific checks / flags
-            df["sat_check"] = df[self.sat_setpoint_col] - self.supply_degf_err_thres
-
-            df["combined_check"] = (
-                (df[self.sat_col] < df["sat_check"])
-                & (df[self.heating_sig_col] > 0.9)
-                & (df[self.supply_vfd_speed_col] > 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["fc7_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_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_six.py

@@ -1,181 +0,0 @@
-import pandas as pd
-import operator
-from open_fdd.air_handling_unit.faults.fault_condition import (
-    FaultCondition,
-    MissingColumnError,
-)
-import sys
-
-
-class FaultConditionSix(FaultCondition):
-    """Class provides the definitions for Fault Condition 6.
-
-    This fault related to knowing the design air flow for
-    ventilation AHU_MIN_CFM_DESIGN which comes from the
-    design mech engineered records where then the fault
-    tries to calculate that based on totalized measured
-    AHU air flow and outside air fraction calc from
-    AHU temp sensors. The fault could flag issues where
-    flow stations are either not in calibration, temp
-    sensors used in the OA frac calc, or possibly the AHU
-    not bringing in design air flow when not operating in
-    economizer free cooling modes.
-    """
-
-    def __init__(self, dict_):
-        super().__init__()
-        self.airflow_err_thres = float
-        self.ahu_min_oa_cfm_design = float
-        self.outdoor_degf_err_thres = float
-        self.return_degf_err_thres = float
-        self.oat_rat_delta_min = float
-        self.ahu_min_oa_dpr = float
-        self.supply_fan_air_volume_col = str
-        self.mat_col = str
-        self.oat_col = str
-        self.rat_col = str
-        self.supply_vfd_speed_col = str
-        self.economizer_sig_col = str
-        self.heating_sig_col = str
-        self.cooling_sig_col = str
-        self.troubleshoot_mode = bool  # default should be False
-        self.rolling_window_size = int
-
-        self.equation_string = (
-            "fc6_flag = 1 if |OA_frac_calc - OA_min| > airflow_err_thres "
-            "in non-economizer modes, considering htg and mech clg OS \n"
-        )
-        self.description_string = (
-            "Fault Condition 6: Issues detected with OA fraction calculation or AHU "
-            "not maintaining design air flow in non-economizer conditions \n"
-        )
-        self.required_column_description = (
-            "Required inputs are the supply fan air volume, mixed air temperature, "
-            "outside air temperature, return air temperature, and VFD speed. "
-            "Optional inputs include economizer signal, heating 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.supply_fan_air_volume_col,
-            self.mat_col,
-            self.oat_col,
-            self.rat_col,
-            self.supply_vfd_speed_col,
-            self.economizer_sig_col,
-            self.heating_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.supply_vfd_speed_col,
-                self.economizer_sig_col,
-                self.heating_sig_col,
-                self.cooling_sig_col,
-            ]
-
-            for col in columns_to_check:
-                self.check_analog_pct(df, [col])
-
-            # Create helper columns
-            df["rat_minus_oat"] = abs(df[self.rat_col] - df[self.oat_col])
-            df["percent_oa_calc"] = (df[self.mat_col] - df[self.rat_col]) / (
-                df[self.oat_col] - df[self.rat_col]
-            )
-
-            # Weed out any negative values
-            df["percent_oa_calc"] = df["percent_oa_calc"].apply(
-                lambda x: x if x > 0 else 0
-            )
-
-            df["perc_OAmin"] = (
-                self.ahu_min_oa_cfm_design / df[self.supply_fan_air_volume_col]
-            )
-
-            df["percent_oa_calc_minus_perc_OAmin"] = abs(
-                df["percent_oa_calc"] - df["perc_OAmin"]
-            )
-
-            df["combined_check"] = operator.or_(
-                # OS 1 htg mode
-                (
-                    (df["rat_minus_oat"] >= self.oat_rat_delta_min)
-                    & (df["percent_oa_calc_minus_perc_OAmin"] > self.airflow_err_thres)
-                )
-                # Verify AHU is running in OS 1 htg mode in min OA
-                & (
-                    (df[self.heating_sig_col] > 0.0)
-                    & (df[self.supply_vfd_speed_col] > 0.0)
-                ),  # OR
-                # OS 4 mech clg mode
-                (
-                    (df["rat_minus_oat"] >= self.oat_rat_delta_min)
-                    & (df["percent_oa_calc_minus_perc_OAmin"] > self.airflow_err_thres)
-                )
-                # Verify AHU is running in OS 4 clg mode in min OA
-                & (df[self.heating_sig_col] == 0.0)
-                & (df[self.cooling_sig_col] > 0.0)
-                & (df[self.supply_vfd_speed_col] > 0.0)
-                & (df[self.economizer_sig_col] == self.ahu_min_oa_dpr),
-            )
-
-            # 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["fc6_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["rat_minus_oat"]
-                del df["percent_oa_calc"]
-                del df["perc_OAmin"]
-                del df["percent_oa_calc_minus_perc_OAmin"]
-                del df["combined_check"]
-
-            return df
-
-        except MissingColumnError as e:
-            print(f"Error: {e.message}")
-            sys.stdout.flush()
-            raise e