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

open_fdd/air_handling_unit/faults/fault_condition_seven.py

@@ -1,7 +1,8 @@
 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
+from open_fdd.air_handling_unit.faults.fault_condition import (
+    FaultCondition,
+    MissingColumnError,
+)
 import sys
 
 
@@ -12,6 +13,7 @@ class FaultConditionSeven(FaultCondition):
     """
 
     def __init__(self, dict_):
+        super().__init__()
         self.supply_degf_err_thres = float
         self.sat_col = str
         self.sat_setpoint_col = str
@@ -22,34 +24,55 @@ class FaultConditionSeven(FaultCondition):
 
         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,
+        ]
+
+    def get_required_columns(self) -> str:
+        """Returns a string representation of the required columns."""
+        return f"Required columns for FaultConditionSeven: {', '.join(self.required_columns)}"
+
     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"]
+        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
 
-        return df
+            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  # Re-raise the exception so it can be caught by pytest

open_fdd/air_handling_unit/faults/fault_condition_six.py

@@ -1,33 +1,29 @@
 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
+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. 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
+    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
@@ -47,74 +43,102 @@ class FaultConditionSix(FaultCondition):
 
         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 = [
+        # 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,
         ]
 
-        for col in columns_to_check:
-            self.check_analog_pct(df, [col])
+    def get_required_columns(self) -> str:
+        """Returns a string representation of the required columns."""
+        return f"Required columns for FaultConditionSix: {', '.join(self.required_columns)}"
 
-        # 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]
-        )
+    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)
+            # 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["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["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)
+            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),
             )
-            # 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)
+
+            # Rolling sum to count consecutive trues
+            rolling_sum = (
+                df["combined_check"].rolling(window=self.rolling_window_size).sum()
             )
-            # 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")
+            # 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()
-            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
+            raise e  # Re-raise the exception so it can be caught by pytest

open_fdd/air_handling_unit/faults/fault_condition_ten.py

@@ -1,7 +1,9 @@
 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
+from open_fdd.air_handling_unit.faults.fault_condition import (
+    FaultCondition,
+    MissingColumnError,
+)
 import sys
 
 
@@ -12,6 +14,7 @@ class FaultConditionTen(FaultCondition):
     """
 
     def __init__(self, dict_):
+        super().__init__()
         self.outdoor_degf_err_thres = float
         self.mix_degf_err_thres = float
         self.oat_col = str
@@ -23,40 +26,62 @@ class FaultConditionTen(FaultCondition):
 
         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,
+        # Set required columns specific to this fault condition
+        self.required_columns = [
+            self.oat_col,
+            self.mat_col,
             self.cooling_sig_col,
+            self.economizer_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
+
+    def get_required_columns(self) -> str:
+        """Returns a string representation of the required columns."""
+        return f"Required columns for FaultConditionTen: {', '.join(self.required_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["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")
+                sys.stdout.flush()
+                del df["abs_mat_minus_oat"]
+                del df["mat_oat_sqrted"]
+                del df["combined_check"]
+
+            return df
+
+        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

open_fdd/air_handling_unit/faults/fault_condition_thirteen.py

@@ -1,8 +1,9 @@
 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
+from open_fdd.air_handling_unit.faults.fault_condition import (
+    FaultCondition,
+    MissingColumnError,
+)
 import sys
 
 
@@ -13,6 +14,7 @@ class FaultConditionThirteen(FaultCondition):
     """
 
     def __init__(self, dict_):
+        super().__init__()
         self.supply_degf_err_thres = float
         self.ahu_min_oa_dpr = float
         self.sat_col = str
@@ -24,43 +26,66 @@ class FaultConditionThirteen(FaultCondition):
 
         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,
+        # Set required columns specific to this fault condition
+        self.required_columns = [
+            self.sat_col,
+            self.sat_setpoint_col,
             self.cooling_sig_col,
+            self.economizer_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
-        )
+    def get_required_columns(self) -> str:
+        """Returns a string representation of the required columns."""
+        return f"Required columns for FaultConditionThirteen: {', '.join(self.required_columns)}"
 
-        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),
-        )
+    def apply(self, df: pd.DataFrame) -> pd.DataFrame:
+        try:
+            # Ensure all required columns are present
+            self.check_required_columns(df)
 
-        # 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:
+                self.troubleshoot_cols(df)
 
-        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"]
+            # 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)
 
-        return df
+            # 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
+
+        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

open_fdd/air_handling_unit/faults/fault_condition_three.py

@@ -1,6 +1,9 @@
 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.fault_condition import (
+    FaultCondition,
+    MissingColumnError,
+)
 import sys
 
 
@@ -10,6 +13,7 @@ class FaultConditionThree(FaultCondition):
     """
 
     def __init__(self, dict_):
+        super().__init__()
         self.mix_degf_err_thres = float
         self.return_degf_err_thres = float
         self.outdoor_degf_err_thres = float
@@ -22,37 +26,58 @@ class FaultConditionThree(FaultCondition):
 
         self.set_attributes(dict_)
 
+        # Set required columns specific to this fault condition
+        self.required_columns = [
+            self.mat_col,
+            self.rat_col,
+            self.oat_col,
+            self.supply_vfd_speed_col,
+        ]
+
+    def get_required_columns(self) -> str:
+        """Returns a string representation of the required columns."""
+        return f"Required columns for FaultConditionThree: {', '.join(self.required_columns)}"
+
     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"]
+        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)
+
+            # 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,
+            )
 
-        return df
+            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
+
+        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