open-fdd 0.1.0__py3-none-any.whl

open_fdd/air_handling_unit/faults/fault_condition_one.py

@@ -0,0 +1,60 @@
+import pandas as pd
+from open_fdd.air_handling_unit.faults.fault_condition import FaultCondition
+import sys
+
+
+class FaultConditionOne(FaultCondition):
+    """Class provides the definitions for Fault Condition 1.
+    AHU low duct static pressure fan fault.
+    """
+
+    def __init__(self, dict_):
+        """
+        :param dict_:
+        """
+        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.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.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"]
+
+        return df

open_fdd/air_handling_unit/faults/fault_condition_seven.py

@@ -0,0 +1,55 @@
+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 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_):
+        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.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.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

open_fdd/air_handling_unit/faults/fault_condition_six.py

@@ -0,0 +1,120 @@
+import pandas as pd
+import pandas.api.types as pdtypes
+from open_fdd.air_handling_unit.faults.fault_condition import FaultCondition
+from open_fdd.air_handling_unit.faults.helper_utils import HelperUtils
+import operator
+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. Troubleshoot by TAB tech
+            verifying flow sensor and temp sensor precisions from
+            3rd party sensing tools.
+
+            this fault is confusing if you want to play around
+            in py code sandbox try this:
+    https://gist.github.com/bbartling/e0fb8427b1e0d148a06e3f09121ed5dc#file-fc6-py
+    """
+
+    def __init__(self, dict_):
+        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.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.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

open_fdd/air_handling_unit/faults/fault_condition_ten.py

@@ -0,0 +1,62 @@
+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 sys
+
+
+class FaultConditionTen(FaultCondition):
+    """Class provides the definitions for Fault Condition 10.
+    Outdoor air temperature and mix air temperature should
+    be approx equal in economizer plus mech cooling mode.
+    """
+
+    def __init__(self, dict_):
+        self.outdoor_degf_err_thres = float
+        self.mix_degf_err_thres = float
+        self.oat_col = str
+        self.mat_col = str
+        self.cooling_sig_col = str
+        self.economizer_sig_col = str
+        self.troubleshoot_mode = bool  # default False,
+        self.rolling_window_size = int
+
+        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,
+            self.cooling_sig_col,
+        ]
+        self.check_analog_pct(df, columns_to_check)
+
+        df["abs_mat_minus_oat"] = abs(df[self.mat_col] - df[self.oat_col])
+        df["mat_oat_sqrted"] = np.sqrt(
+            self.mix_degf_err_thres**2 + self.outdoor_degf_err_thres**2
+        )
+
+        df["combined_check"] = (
+            (df["abs_mat_minus_oat"] > df["mat_oat_sqrted"])
+            # verify ahu is running in OS 3 clg mode in min 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["fc10_flag"] = (rolling_sum >= self.rolling_window_size).astype(int)
+
+        if self.troubleshoot_mode:
+            print("Troubleshoot mode enabled - not removing helper columns")
+            del df["abs_mat_minus_oat"]
+            del df["mat_oat_sqrted"]
+            del df["combined_check"]
+
+        return df

open_fdd/air_handling_unit/faults/fault_condition_thirteen.py

@@ -0,0 +1,66 @@
+import pandas as pd
+import numpy as np
+import operator
+from open_fdd.air_handling_unit.faults.fault_condition import FaultCondition
+from open_fdd.air_handling_unit.faults.helper_utils import HelperUtils
+import sys
+
+
+class FaultConditionThirteen(FaultCondition):
+    """Class provides the definitions for Fault Condition 13.
+    Supply air temperature too high in full cooling
+    in economizer plus mech cooling mode
+    """
+
+    def __init__(self, dict_):
+        self.supply_degf_err_thres = float
+        self.ahu_min_oa_dpr = float
+        self.sat_col = str
+        self.sat_setpoint_col = str
+        self.cooling_sig_col = str
+        self.economizer_sig_col = str
+        self.troubleshoot_mode = bool  # default False
+        self.rolling_window_size = int
+
+        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,
+            self.cooling_sig_col,
+        ]
+        self.check_analog_pct(df, columns_to_check)
+
+        # Create helper columns
+        df["sat_greater_than_sp_calc"] = (
+            df[self.sat_col] > df[self.sat_setpoint_col] + self.supply_degf_err_thres
+        )
+
+        df["combined_check"] = operator.or_(
+            ((df["sat_greater_than_sp_calc"]))
+            # OS4 AHU state clg @ min OA
+            & (df[self.cooling_sig_col] > 0.01)
+            & (df[self.economizer_sig_col] == self.ahu_min_oa_dpr),  # OR
+            ((df["sat_greater_than_sp_calc"]))
+            # 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["fc13_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_greater_than_sp_calc"]
+            del df["combined_check"]
+
+        return df

open_fdd/air_handling_unit/faults/fault_condition_three.py

@@ -0,0 +1,58 @@
+import pandas as pd
+import numpy as np
+from open_fdd.air_handling_unit.faults.fault_condition import FaultCondition
+import sys
+
+
+class FaultConditionThree(FaultCondition):
+    """Class provides the definitions for Fault Condition 3.
+    Mix temperature too high; should be between outside and return air.
+    """
+
+    def __init__(self, dict_):
+        self.mix_degf_err_thres = float
+        self.return_degf_err_thres = float
+        self.outdoor_degf_err_thres = float
+        self.mat_col = str
+        self.rat_col = str
+        self.oat_col = str
+        self.supply_vfd_speed_col = str
+        self.troubleshoot_mode = bool  # default to False
+        self.rolling_window_size = int
+
+        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.supply_vfd_speed_col]
+        self.check_analog_pct(df, columns_to_check)
+
+        # Fault condition-specific checks / flags
+        df["mat_check"] = df[self.mat_col] - self.mix_degf_err_thres
+        df["temp_min_check"] = np.maximum(
+            df[self.rat_col] + self.return_degf_err_thres,
+            df[self.oat_col] + self.outdoor_degf_err_thres,
+        )
+
+        df["combined_check"] = (df["mat_check"] > df["temp_min_check"]) & (
+            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["fc3_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["temp_min_check"]
+            del df["combined_check"]
+
+        return df

open_fdd/air_handling_unit/faults/fault_condition_twelve.py

@@ -0,0 +1,71 @@
+import pandas as pd
+import numpy as np
+import operator
+from open_fdd.air_handling_unit.faults.fault_condition import FaultCondition
+from open_fdd.air_handling_unit.faults.helper_utils import HelperUtils
+import sys
+
+
+class FaultConditionTwelve(FaultCondition):
+    """Class provides the definitions for Fault Condition 12.
+    Supply air temperature too high; should be less than
+    mix air temperature in economizer plus mech cooling mode.
+    """
+
+    def __init__(self, dict_):
+        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.sat_col = str
+        self.mat_col = str
+        self.cooling_sig_col = str
+        self.economizer_sig_col = str
+        self.troubleshoot_mode = bool  # default False
+        self.rolling_window_size = int
+
+        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,
+            self.cooling_sig_col,
+        ]
+        self.check_analog_pct(df, columns_to_check)
+
+        # Create helper columns
+        df["sat_minus_saterr_delta_supply_fan"] = (
+            df[self.sat_col] - self.supply_degf_err_thres - self.delta_t_supply_fan
+        )
+        df["mat_plus_materr"] = df[self.mat_col] + self.mix_degf_err_thres
+
+        df["combined_check"] = operator.or_(
+            # OS4 AHU state clg @ min OA
+            (df["sat_minus_saterr_delta_supply_fan"] > df["mat_plus_materr"])
+            # verify AHU in OS4 mode
+            & (df[self.cooling_sig_col] > 0.01)
+            & (df[self.economizer_sig_col] == self.ahu_min_oa_dpr),  # OR
+            (df["sat_minus_saterr_delta_supply_fan"] > df["mat_plus_materr"])
+            # 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["fc12_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_minus_saterr_delta_supply_fan"]
+            del df["mat_plus_materr"]
+            del df["combined_check"]
+
+        return df

open_fdd/air_handling_unit/faults/fault_condition_two.py

@@ -0,0 +1,61 @@
+import pandas as pd
+import numpy as np
+from open_fdd.air_handling_unit.faults.fault_condition import FaultCondition
+import sys
+
+
+class FaultConditionTwo(FaultCondition):
+    """Class provides the definitions for Fault Condition 2.
+    Mix temperature too low; should be between outside and return air.
+    """
+
+    def __init__(self, dict_):
+        """
+        :param dict_:
+        """
+        self.mix_degf_err_thres = float
+        self.return_degf_err_thres = float
+        self.outdoor_degf_err_thres = float
+        self.mat_col = str
+        self.rat_col = str
+        self.oat_col = str
+        self.supply_vfd_speed_col = str
+        self.troubleshoot_mode = bool  # default to False
+        self.rolling_window_size = int
+
+        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.supply_vfd_speed_col]
+        self.check_analog_pct(df, columns_to_check)
+
+        # Fault condition-specific checks / flags
+        df["mat_check"] = df[self.mat_col] + self.mix_degf_err_thres
+        df["temp_min_check"] = np.minimum(
+            df[self.rat_col] - self.return_degf_err_thres,
+            df[self.oat_col] - self.outdoor_degf_err_thres,
+        )
+
+        df["combined_check"] = (df["mat_check"] < df["temp_min_check"]) & (
+            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["fc2_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["temp_min_check"]
+            del df["combined_check"]
+
+        return df