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

open_fdd/air_handling_unit/faults/fault_condition_three.py

@@ -0,0 +1,112 @@
+import numpy as np
+import pandas as pd
+
+from open_fdd.core.base_fault import BaseFaultCondition
+from open_fdd.core.components import FaultInputColumn, InstanceAttribute
+from open_fdd.core.mixins import FaultConditionMixin
+
+INPUT_COLS = [
+    FaultInputColumn(
+        name="mat_col",
+        constant_form="MAT_COL",
+        description="Mixed air temperature",
+        unit="°F",
+        required=True,
+        type=float,
+    ),
+    FaultInputColumn(
+        name="rat_col",
+        constant_form="RAT_COL",
+        description="Return air temperature",
+        unit="°F",
+        required=True,
+        type=float,
+    ),
+    FaultInputColumn(
+        name="oat_col",
+        constant_form="OAT_COL",
+        description="Outside air temperature",
+        unit="°F",
+        required=True,
+        type=float,
+    ),
+    FaultInputColumn(
+        name="supply_vfd_speed_col",
+        constant_form="SUPPLY_VFD_SPEED_COL",
+        description="Supply fan VFD speed",
+        unit="%",
+        required=True,
+        type=float,
+    ),
+]
+
+FAULT_PARAMS = [
+    InstanceAttribute(
+        name="mix_degf_err_thres",
+        constant_form="MIX_DEGF_ERR_THRES",
+        description="Mixed air temperature error threshold",
+        unit="°F",
+        type=float,
+        range=(0.0, 10.0),
+    ),
+    InstanceAttribute(
+        name="outdoor_degf_err_thres",
+        constant_form="OUTDOOR_DEGF_ERR_THRES",
+        description="Outdoor air temperature error threshold",
+        unit="°F",
+        type=float,
+        range=(0.0, 10.0),
+    ),
+    InstanceAttribute(
+        name="return_degf_err_thres",
+        constant_form="RETURN_DEGF_ERR_THRES",
+        description="Return air temperature error threshold",
+        unit="°F",
+        type=float,
+        range=(0.0, 10.0),
+    ),
+]
+
+
+class FaultConditionThree(BaseFaultCondition, FaultConditionMixin):
+    """Class provides the definitions for Fault Condition 3.
+    Mix temperature too high; should be between outside and return air.
+    """
+
+    input_columns = INPUT_COLS
+    fault_params = FAULT_PARAMS
+    equation_string = "fc3_flag = 1 if (MAT - εMAT > max(RAT + εRAT, OAT + εOAT)) and (VFDSPD > 0) for N consecutive values else 0 \n"
+    description_string = "Fault Condition 3: Mix temperature too high; should be between outside and return air \n"
+    error_string = "One or more required columns are missing or None \n"
+
+    @FaultConditionMixin._handle_errors
+    def apply(self, df: pd.DataFrame) -> pd.DataFrame:
+        self._apply_common_checks(df)
+
+        # Get column values using accessor methods
+        supply_vfd_speed_col = self.get_input_column("supply_vfd_speed_col")
+        mat_col = self.get_input_column("mat_col")
+        rat_col = self.get_input_column("rat_col")
+        oat_col = self.get_input_column("oat_col")
+
+        # Get parameter values using accessor methods
+        mix_degf_err_thres = self.get_param("mix_degf_err_thres")
+        return_degf_err_thres = self.get_param("return_degf_err_thres")
+        outdoor_degf_err_thres = self.get_param("outdoor_degf_err_thres")
+
+        self._apply_analog_checks(
+            df, [supply_vfd_speed_col], check_greater_than_one=True
+        )
+
+        # Specific checks
+        mat_check = df[mat_col] - mix_degf_err_thres
+        temp_max_check = np.maximum(
+            df[rat_col] + return_degf_err_thres,
+            df[oat_col] + outdoor_degf_err_thres,
+        )
+        combined_check = (mat_check > temp_max_check) & (
+            df[supply_vfd_speed_col] > 0.01
+        )
+
+        self._set_fault_flag(df, combined_check, "fc3_flag")
+        return df

open_fdd/air_handling_unit/faults/fault_condition_twelve.py

@@ -0,0 +1,164 @@
+import numpy as np
+import pandas as pd
+
+from open_fdd.core.base_fault import BaseFaultCondition
+from open_fdd.core.components import FaultInputColumn, InstanceAttribute
+from open_fdd.core.exceptions import InvalidParameterError
+from open_fdd.core.mixins import FaultConditionMixin
+
+INPUT_COLS = [
+    FaultInputColumn(
+        name="sat_col",
+        constant_form="SAT_COL",
+        description="Supply air temperature",
+        unit="°F",
+        required=True,
+        type=float,
+    ),
+    FaultInputColumn(
+        name="mat_col",
+        constant_form="MAT_COL",
+        description="Mixed air temperature",
+        unit="°F",
+        required=True,
+        type=float,
+    ),
+    FaultInputColumn(
+        name="oat_col",
+        constant_form="OAT_COL",
+        description="Outside air temperature",
+        unit="°F",
+        required=True,
+        type=float,
+    ),
+    FaultInputColumn(
+        name="cooling_sig_col",
+        constant_form="COOLING_SIG_COL",
+        description="Cooling signal",
+        unit="%",
+        required=True,
+        type=float,
+    ),
+    FaultInputColumn(
+        name="economizer_sig_col",
+        constant_form="ECONOMIZER_SIG_COL",
+        description="Economizer signal",
+        unit="%",
+        required=True,
+        type=float,
+    ),
+]
+
+FAULT_PARAMS = [
+    InstanceAttribute(
+        name="delta_t_supply_fan",
+        constant_form="DELTA_T_SUPPLY_FAN",
+        description="Temperature rise across supply fan",
+        unit="°F",
+        type=float,
+    ),
+    InstanceAttribute(
+        name="mix_degf_err_thres",
+        constant_form="MIX_DEGF_ERR_THRES",
+        description="Mixed air temperature error threshold",
+        unit="°F",
+        type=float,
+    ),
+    InstanceAttribute(
+        name="supply_degf_err_thres",
+        constant_form="SUPPLY_DEGF_ERR_THRES",
+        description="Supply air temperature error threshold",
+        unit="°F",
+        type=float,
+    ),
+    InstanceAttribute(
+        name="outdoor_degf_err_thres",
+        constant_form="OUTDOOR_DEGF_ERR_THRES",
+        description="Outdoor air temperature error threshold",
+        unit="°F",
+        type=float,
+    ),
+    InstanceAttribute(
+        name="ahu_min_oa_dpr",
+        constant_form="AHU_MIN_OA_DPR",
+        description="Minimum outdoor air damper position",
+        unit="fraction",
+        type=float,
+    ),
+]
+
+
+class FaultConditionTwelve(BaseFaultCondition, FaultConditionMixin):
+    """Class provides the definitions for Fault Condition 12.
+    Supply air temperature too high; should be less than mixed air temperature
+    in OS3 (economizer + mechanical cooling) and OS4 (mechanical cooling only) modes.
+
+    py -3.12 -m pytest open_fdd/tests/ahu/test_ahu_fc12.py -rP -s
+    """
+
+    input_columns = INPUT_COLS
+    fault_params = FAULT_PARAMS
+    equation_string = (
+        "fc12_flag = 1 if (SAT > MAT + εSAT) and "
+        "((CLG > 0 and ECO > 0.9) or (CLG > 0.9 and ECO = MIN_OA)) "
+        "for N consecutive values else 0 \n"
+    )
+    description_string = (
+        "Fault Condition 12: Supply air temperature too high; should be less than "
+        "mixed air temperature in OS3 (economizer + mechanical cooling) and "
+        "OS4 (mechanical cooling only) modes \n"
+    )
+    error_string = "One or more required columns are missing or None \n"
+
+    @FaultConditionMixin._handle_errors
+    def apply(self, df: pd.DataFrame) -> pd.DataFrame:
+        """Apply the fault condition to the DataFrame."""
+        # Apply common checks
+        self._apply_common_checks(df)
+
+        # Get column values using accessor methods
+        sat_col = self.get_input_column("sat_col")
+        mat_col = self.get_input_column("mat_col")
+        oat_col = self.get_input_column("oat_col")
+        cooling_sig_col = self.get_input_column("cooling_sig_col")
+        economizer_sig_col = self.get_input_column("economizer_sig_col")
+
+        # Get parameter values using accessor methods
+        delta_t_supply_fan = self.get_param("delta_t_supply_fan")
+        mix_degf_err_thres = self.get_param("mix_degf_err_thres")
+        supply_degf_err_thres = self.get_param("supply_degf_err_thres")
+        outdoor_degf_err_thres = self.get_param("outdoor_degf_err_thres")
+        ahu_min_oa_dpr = self.get_param("ahu_min_oa_dpr")
+
+        # Check analog outputs [data with units of %] are floats only
+        columns_to_check = [
+            economizer_sig_col,
+            cooling_sig_col,
+        ]
+        self._apply_analog_checks(df, columns_to_check, check_greater_than_one=True)
+
+        # Calculate the threshold for SAT vs MAT comparison
+        sat_mat_threshold = np.sqrt(supply_degf_err_thres**2 + mix_degf_err_thres**2)
+
+        # Check if SAT is too high compared to MAT (accounting for supply fan heat)
+        sat_too_high = df[sat_col] > (
+            df[mat_col] + sat_mat_threshold + delta_t_supply_fan
+        )
+
+        # Check operating modes:
+        # OS3: Economizer + mechanical cooling (ECO > 0.9 and CLG > 0)
+        os3_mode = (df[economizer_sig_col] > 0.9) & (df[cooling_sig_col] > 0)
+
+        # OS4: Mechanical cooling only (ECO = MIN_OA and CLG > 0.9)
+        os4_mode = (df[economizer_sig_col] <= ahu_min_oa_dpr) & (
+            df[cooling_sig_col] > 0.9
+        )
+
+        # Combine conditions:
+        # Fault occurs when SAT is too high in either OS3 or OS4 mode
+        combined_check = sat_too_high & (os3_mode | os4_mode)
+
+        # Set fault flag
+        self._set_fault_flag(df, combined_check, "fc12_flag")
+
+        return df

open_fdd/air_handling_unit/faults/fault_condition_two.py

@@ -0,0 +1,112 @@
+import numpy as np
+import pandas as pd
+
+from open_fdd.core.base_fault import BaseFaultCondition
+from open_fdd.core.components import FaultInputColumn, InstanceAttribute
+from open_fdd.core.mixins import FaultConditionMixin
+
+INPUT_COLS = [
+    FaultInputColumn(
+        name="mat_col",
+        constant_form="MAT_COL",
+        description="Mixed air temperature",
+        unit="°F",
+        required=True,
+        type=float,
+    ),
+    FaultInputColumn(
+        name="rat_col",
+        constant_form="RAT_COL",
+        description="Return air temperature",
+        unit="°F",
+        required=True,
+        type=float,
+    ),
+    FaultInputColumn(
+        name="oat_col",
+        constant_form="OAT_COL",
+        description="Outside air temperature",
+        unit="°F",
+        required=True,
+        type=float,
+    ),
+    FaultInputColumn(
+        name="supply_vfd_speed_col",
+        constant_form="SUPPLY_VFD_SPEED_COL",
+        description="Supply fan VFD speed",
+        unit="%",
+        required=True,
+        type=float,
+    ),
+]
+
+FAULT_PARAMS = [
+    InstanceAttribute(
+        name="mix_degf_err_thres",
+        constant_form="MIX_DEGF_ERR_THRES",
+        description="Mixed air temperature error threshold",
+        unit="°F",
+        type=float,
+        range=(0.0, 10.0),
+    ),
+    InstanceAttribute(
+        name="outdoor_degf_err_thres",
+        constant_form="OUTDOOR_DEGF_ERR_THRES",
+        description="Outdoor air temperature error threshold",
+        unit="°F",
+        type=float,
+        range=(0.0, 10.0),
+    ),
+    InstanceAttribute(
+        name="return_degf_err_thres",
+        constant_form="RETURN_DEGF_ERR_THRES",
+        description="Return air temperature error threshold",
+        unit="°F",
+        type=float,
+        range=(0.0, 10.0),
+    ),
+]
+
+
+class FaultConditionTwo(BaseFaultCondition, FaultConditionMixin):
+    """Class provides the definitions for Fault Condition 2.
+    Mix temperature too low; should be between outside and return air.
+    """
+
+    input_columns = INPUT_COLS
+    fault_params = FAULT_PARAMS
+    equation_string = "fc2_flag = 1 if (MAT - εMAT < min(RAT - εRAT, OAT - εOAT)) and (VFDSPD > 0) for N consecutive values else 0 \n"
+    description_string = "Fault Condition 2: Mix temperature too low; should be between outside and return air \n"
+    error_string = "One or more required columns are missing or None \n"
+
+    @FaultConditionMixin._handle_errors
+    def apply(self, df: pd.DataFrame) -> pd.DataFrame:
+        self._apply_common_checks(df)
+
+        # Get column values using accessor methods
+        supply_vfd_speed_col = self.get_input_column("supply_vfd_speed_col")
+        mat_col = self.get_input_column("mat_col")
+        rat_col = self.get_input_column("rat_col")
+        oat_col = self.get_input_column("oat_col")
+
+        # Get parameter values using accessor methods
+        mix_degf_err_thres = self.get_param("mix_degf_err_thres")
+        return_degf_err_thres = self.get_param("return_degf_err_thres")
+        outdoor_degf_err_thres = self.get_param("outdoor_degf_err_thres")
+
+        self._apply_analog_checks(
+            df, [supply_vfd_speed_col], check_greater_than_one=True
+        )
+
+        # Specific checks
+        mat_check = df[mat_col] - mix_degf_err_thres
+        temp_min_check = np.minimum(
+            df[rat_col] - return_degf_err_thres,
+            df[oat_col] - outdoor_degf_err_thres,
+        )
+        combined_check = (mat_check < temp_min_check) & (
+            df[supply_vfd_speed_col] > 0.01
+        )
+
+        self._set_fault_flag(df, combined_check, "fc2_flag")
+        return df

open_fdd/air_handling_unit/faults/helper_utils.py

@@ -1,7 +1,17 @@
 import sys
-from open_fdd.air_handling_unit.faults.shared_utils import SharedUtils
+
 import pandas as pd
 
+from open_fdd.core.utils import (
+    apply_rolling_average_if_needed,
+    clean_nan_values,
+    convert_to_float,
+    float_int_check_err,
+    float_max_check_err,
+    is_float,
+    not_greater_than_one,
+)
+
 
 class HelperUtils:
 
@@ -12,25 +22,25 @@ class HelperUtils:
         self.config_dict = config_dict
 
     def clean_nan_values(self, df):
-        return SharedUtils.clean_nan_values(df)
+        return clean_nan_values(df)
 
     def float_int_check_err(self, col):
-        return SharedUtils.float_int_check_err(col)
+        return float_int_check_err(col)
 
     def float_max_check_err(self, col):
-        return SharedUtils.float_max_check_err(col)
+        return float_max_check_err(col)
 
     def isfloat(self, num):
-        return SharedUtils.isfloat(num)
+        return is_float(num)
 
     def isLessThanOnePointOne(self, num):
-        return SharedUtils.isLessThanOnePointOne(num)
+        return not_greater_than_one(num)
 
     def convert_to_float(self, df, col):
-        return SharedUtils.convert_to_float(df, col)
+        return convert_to_float(df, col)
 
     def apply_rolling_average_if_needed(self, df, freq="1min", rolling_window="5min"):
-        return SharedUtils.apply_rolling_average_if_needed(df, freq, rolling_window)
+        return apply_rolling_average_if_needed(df, freq, rolling_window)
 
     def validate_config(self, required_columns):
         """
@@ -45,21 +55,21 @@ class HelperUtils:
         self.set_config_dict(config_dict)
 
         from open_fdd.air_handling_unit.faults import (
-            FaultConditionOne,
-            FaultConditionTwo,
-            FaultConditionThree,
-            FaultConditionFour,
-            FaultConditionFive,
-            FaultConditionSix,
-            FaultConditionSeven,
             FaultConditionEight,
+            FaultConditionEleven,
+            FaultConditionFifteen,
+            FaultConditionFive,
+            FaultConditionFour,
+            FaultConditionFourteen,
             FaultConditionNine,
+            FaultConditionOne,
+            FaultConditionSeven,
+            FaultConditionSix,
             FaultConditionTen,
-            FaultConditionEleven,
-            FaultConditionTwelve,
             FaultConditionThirteen,
-            FaultConditionFourteen,
-            FaultConditionFifteen,
+            FaultConditionThree,
+            FaultConditionTwelve,
+            FaultConditionTwo,
         )
 
         fault_counts = {}

open_fdd/air_handling_unit/reports/__init__.py

@@ -1,9 +1,11 @@
+import sys
+
 import matplotlib.pyplot as plt
-from open_fdd.air_handling_unit.reports.fault_report import BaseFaultReport
-from open_fdd.air_handling_unit.faults import FaultConditionSixteen
-import pandas as pd
 import numpy as np
-import sys
+import pandas as pd
+
+from open_fdd.air_handling_unit.faults import FaultConditionSixteen
+from open_fdd.air_handling_unit.reports.fault_report import BaseFaultReport
 
 
 class FaultCodeOneReport(BaseFaultReport):

open_fdd/air_handling_unit/reports/fault_report.py

@@ -1,7 +1,8 @@
+import sys
+
 import matplotlib.pyplot as plt
-import pandas as pd
 import numpy as np
-import sys
+import pandas as pd
 
 
 class BaseFaultReport:

open_fdd/chiller_plant/faults/__init__.py

@@ -0,0 +1,7 @@
+from open_fdd.chiller_plant.faults.fault_condition_one import FaultConditionOne
+from open_fdd.chiller_plant.faults.fault_condition_two import FaultConditionTwo
+
+__all__ = [
+    "FaultConditionOne",
+    "FaultConditionTwo",
+]

open_fdd/chiller_plant/faults/fault_condition_one.py

@@ -0,0 +1,113 @@
+import pandas as pd
+
+from open_fdd.core.base_fault import BaseFaultCondition
+from open_fdd.core.components import FaultInputColumn, InstanceAttribute
+from open_fdd.core.mixins import FaultConditionMixin
+
+INPUT_COLS = [
+    FaultInputColumn(
+        name="diff_pressure_col",
+        constant_form="DIFF_PRESSURE_COL",
+        description="Differential pressure",
+        unit="PSI",
+        required=True,
+        type=str,
+    ),
+    FaultInputColumn(
+        name="pump_speed_col",
+        constant_form="PUMP_SPEED_COL",
+        description="Pump speed",
+        unit="%",
+        required=True,
+        type=str,
+    ),
+    FaultInputColumn(
+        name="diff_pressure_setpoint_col",
+        constant_form="DIFF_PRESSURE_SETPOINT_COL",
+        description="Differential pressure setpoint",
+        unit="PSI",
+        required=True,
+        type=str,
+    ),
+]
+
+FAULT_PARAMS = [
+    InstanceAttribute(
+        name="pump_speed_percent_err_thres",
+        constant_form="PUMP_SPEED_PERCENT_ERR_THRES",
+        description="Pump speed error threshold",
+        unit="%",
+        type=float,
+        range=(0.0, 1.0),
+    ),
+    InstanceAttribute(
+        name="pump_speed_percent_max",
+        constant_form="PUMP_SPEED_PERCENT_MAX",
+        description="Maximum pump speed percentage",
+        unit="%",
+        type=float,
+        range=(0.0, 1.0),
+    ),
+    InstanceAttribute(
+        name="diff_pressure_psi_err_thres",
+        constant_form="DIFF_PRESSURE_PSI_ERR_THRES",
+        description="Differential pressure error threshold",
+        unit="PSI",
+        type=float,
+        range=(0.0, 100.0),
+    ),
+]
+
+
+class FaultConditionOne(BaseFaultCondition, FaultConditionMixin):
+    """Class provides the definitions for Fault Condition for pumps.
+    Variable pump does not meet differential pressure setpoint.
+
+    py -3.12 -m pytest open_fdd/tests/chiller/test_chiller_fc1.py -rP -s
+    """
+
+    input_columns = INPUT_COLS
+    fault_params = FAULT_PARAMS
+    equation_string = (
+        "fc_pump_flag = 1 if (DP < DPSP - εDP) and (PUMPSPD >= PUMPSPD_max - εPUMPSPD) "
+        "for N consecutive values else 0 \n"
+    )
+    description_string = (
+        "Fault Condition: Differential pressure too low with pump at full speed \n"
+    )
+    error_string = "One or more required columns are missing or None \n"
+
+    @FaultConditionMixin._handle_errors
+    def apply(self, df: pd.DataFrame) -> pd.DataFrame:
+        self._apply_common_checks(df)
+
+        # Get column values using accessor methods
+        diff_pressure_col = self.get_input_column("diff_pressure_col")
+        pump_speed_col = self.get_input_column("pump_speed_col")
+        diff_pressure_setpoint_col = self.get_input_column("diff_pressure_setpoint_col")
+
+        # Get parameter values using accessor methods
+        pump_speed_percent_max = self.get_param("pump_speed_percent_max")
+        pump_speed_percent_err_thres = self.get_param("pump_speed_percent_err_thres")
+        diff_pressure_psi_err_thres = self.get_param("diff_pressure_psi_err_thres")
+
+        # Check analog outputs are floats only
+        columns_to_check = [pump_speed_col]
+        self._apply_analog_checks(df, columns_to_check)
+
+        # Perform checks
+        pressure_check = (
+            df[diff_pressure_col]
+            < df[diff_pressure_setpoint_col] - diff_pressure_psi_err_thres
+        )
+        pump_check = (
+            df[pump_speed_col] >= pump_speed_percent_max - pump_speed_percent_err_thres
+        )
+
+        # Combined condition check
+        combined_check = pressure_check & pump_check
+
+        # Set fault flag
+        self._set_fault_flag(df, combined_check, "fc_pump_flag")
+
+        return df