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

open_fdd/air_handling_unit/faults/fault_condition_ten.py

@@ -24,6 +24,20 @@ class FaultConditionTen(FaultCondition):
         self.troubleshoot_mode = bool  # default False,
         self.rolling_window_size = int
 
+        self.equation_string = (
+            "fc10_flag = 1 if |OAT - MAT| > √(εOAT² + εMAT²) in "
+            "economizer + mech cooling mode for N consecutive values else 0 \n"
+        )
+        self.description_string = (
+            "Fault Condition 10: Outdoor air temperature and mixed air temperature "
+            "should be approximately equal in economizer plus mechanical cooling mode \n"
+        )
+        self.required_column_description = (
+            "Required inputs are the outside air temperature, mixed 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
@@ -34,9 +48,31 @@ class FaultConditionTen(FaultCondition):
             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"Required columns for FaultConditionTen: {', '.join(self.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:
@@ -60,7 +96,7 @@ class FaultConditionTen(FaultCondition):
 
             df["combined_check"] = (
                 (df["abs_mat_minus_oat"] > df["mat_oat_sqrted"])
-                # verify ahu is running in OS 3 clg mode in min OA
+                # 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)
             )
@@ -84,4 +120,4 @@ class FaultConditionTen(FaultCondition):
         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
+            raise e

open_fdd/air_handling_unit/faults/fault_condition_thirteen.py

@@ -24,6 +24,20 @@ class FaultConditionThirteen(FaultCondition):
         self.troubleshoot_mode = bool  # default False
         self.rolling_window_size = int
 
+        self.equation_string = (
+            "fc13_flag = 1 if SAT > (SATSP + εSAT) in "
+            "economizer + mech cooling mode for N consecutive values else 0 \n"
+        )
+        self.description_string = (
+            "Fault Condition 13: Supply air temperature too high in full cooling "
+            "in economizer plus mechanical cooling mode \n"
+        )
+        self.required_column_description = (
+            "Required inputs are the supply air temperature, supply air temperature setpoint, "
+            "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
@@ -34,9 +48,31 @@ class FaultConditionThirteen(FaultCondition):
             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"Required columns for FaultConditionThirteen: {', '.join(self.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:
@@ -88,4 +124,4 @@ class FaultConditionThirteen(FaultCondition):
         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
+            raise e

open_fdd/air_handling_unit/faults/fault_condition_three.py

@@ -24,6 +24,14 @@ class FaultConditionThree(FaultCondition):
         self.troubleshoot_mode = bool  # default to False
         self.rolling_window_size = int
 
+        self.equation_string = (
+            "fc3_flag = 1 if (MAT - εMAT > max(RAT + εRAT, OAT + εOAT)) and (VFDSPD > 0) "
+            "for N consecutive values else 0 \n"
+        )
+        self.description_string = "Fault Condition 3: Mix temperature too high; should be between outside and return air \n"
+        self.required_column_description = "Required inputs are the mix air temperature, return air temperature, outside air temperature, 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
@@ -34,9 +42,31 @@ class FaultConditionThree(FaultCondition):
             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"Required columns for FaultConditionThree: {', '.join(self.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:
@@ -80,4 +110,4 @@ class FaultConditionThree(FaultCondition):
         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
+            raise e

open_fdd/air_handling_unit/faults/fault_condition_twelve.py

@@ -1,4 +1,5 @@
 import pandas as pd
+import numpy as np
 import operator
 from open_fdd.air_handling_unit.faults.fault_condition import (
     FaultCondition,
@@ -26,6 +27,20 @@ class FaultConditionTwelve(FaultCondition):
         self.troubleshoot_mode = bool  # default False
         self.rolling_window_size = int
 
+        self.equation_string = (
+            "fc12_flag = 1 if SAT >= MAT + εMAT in "
+            "economizer + mech cooling mode for N consecutive values else 0 \n"
+        )
+        self.description_string = (
+            "Fault Condition 12: Supply air temperature too high; should be less than "
+            "mixed air temperature in economizer plus mechanical cooling mode \n"
+        )
+        self.required_column_description = (
+            "Required inputs are the supply air temperature, mixed 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
@@ -36,9 +51,31 @@ class FaultConditionTwelve(FaultCondition):
             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"Required columns for FaultConditionTwelve: {', '.join(self.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:
@@ -68,7 +105,7 @@ class FaultConditionTwelve(FaultCondition):
                 & (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
+                # 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),
             )
@@ -92,4 +129,4 @@ class FaultConditionTwelve(FaultCondition):
         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
+            raise e

open_fdd/air_handling_unit/faults/fault_condition_two.py

@@ -24,6 +24,14 @@ class FaultConditionTwo(FaultCondition):
         self.troubleshoot_mode = bool  # default to False
         self.rolling_window_size = int
 
+        self.equation_string = (
+            "fc2_flag = 1 if (MAT + εMAT < min(RAT - εRAT, OAT - εOAT)) and (VFDSPD > 0) "
+            "for N consecutive values else 0 \n"
+        )
+        self.description_string = "Fault Condition 2: Mix temperature too low; should be between outside and return air \n"
+        self.required_column_description = "Required inputs are the mix air temperature, return air temperature, outside air temperature, 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
@@ -34,9 +42,31 @@ class FaultConditionTwo(FaultCondition):
             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"Required columns for FaultConditionTwo: {', '.join(self.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:
@@ -80,4 +110,4 @@ class FaultConditionTwo(FaultCondition):
         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
+            raise e

open_fdd/air_handling_unit/faults/helper_utils.py

@@ -41,49 +41,21 @@ class HelperUtils:
         # Set the config dictionary
         self.set_config_dict(config_dict)
 
-        from open_fdd.air_handling_unit.faults.fault_condition_one import (
+        from open_fdd.air_handling_unit.faults import (
             FaultConditionOne,
-        )
-        from open_fdd.air_handling_unit.faults.fault_condition_two import (
             FaultConditionTwo,
-        )
-        from open_fdd.air_handling_unit.faults.fault_condition_three import (
             FaultConditionThree,
-        )
-        from open_fdd.air_handling_unit.faults.fault_condition_four import (
             FaultConditionFour,
-        )
-        from open_fdd.air_handling_unit.faults.fault_condition_five import (
             FaultConditionFive,
-        )
-        from open_fdd.air_handling_unit.faults.fault_condition_six import (
             FaultConditionSix,
-        )
-        from open_fdd.air_handling_unit.faults.fault_condition_seven import (
             FaultConditionSeven,
-        )
-        from open_fdd.air_handling_unit.faults.fault_condition_eight import (
             FaultConditionEight,
-        )
-        from open_fdd.air_handling_unit.faults.fault_condition_nine import (
             FaultConditionNine,
-        )
-        from open_fdd.air_handling_unit.faults.fault_condition_ten import (
             FaultConditionTen,
-        )
-        from open_fdd.air_handling_unit.faults.fault_condition_eleven import (
             FaultConditionEleven,
-        )
-        from open_fdd.air_handling_unit.faults.fault_condition_twelve import (
             FaultConditionTwelve,
-        )
-        from open_fdd.air_handling_unit.faults.fault_condition_thirteen import (
             FaultConditionThirteen,
-        )
-        from open_fdd.air_handling_unit.faults.fault_condition_fourteen import (
             FaultConditionFourteen,
-        )
-        from open_fdd.air_handling_unit.faults.fault_condition_fifteen import (
             FaultConditionFifteen,
         )