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

open_fdd/air_handling_unit/faults/fault_condition_twelve.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 FaultConditionTwelve(FaultCondition):
     """
 
     def __init__(self, dict_):
+        super().__init__()
         self.delta_t_supply_fan = float
         self.mix_degf_err_thres = float
         self.supply_degf_err_thres = float
@@ -26,46 +28,68 @@ class FaultConditionTwelve(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.mat_col,
             self.cooling_sig_col,
+            self.economizer_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
+    def get_required_columns(self) -> str:
+        """Returns a string representation of the required columns."""
+        return f"Required columns for FaultConditionTwelve: {', '.join(self.required_columns)}"
 
-        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),
-        )
+    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["fc12_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_minus_saterr_delta_supply_fan"]
-            del df["mat_plus_materr"]
-            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_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
+
+        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_two.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,9 +13,7 @@ class FaultConditionTwo(FaultCondition):
     """
 
     def __init__(self, dict_):
-        """
-        :param dict_:
-        """
+        super().__init__()
         self.mix_degf_err_thres = float
         self.return_degf_err_thres = float
         self.outdoor_degf_err_thres = float
@@ -25,37 +26,58 @@ class FaultConditionTwo(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 FaultConditionTwo: {', '.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.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"]
+        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.minimum(
+                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["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
+
+        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/helper_utils.py

@@ -4,6 +4,13 @@ import pandas as pd
 
 
 class HelperUtils:
+
+    def __init__(self):
+        self.config_dict = None
+
+    def set_config_dict(self, config_dict):
+        self.config_dict = config_dict
+
     def float_int_check_err(self, col):
         return SharedUtils.float_int_check_err(col)
 
@@ -22,8 +29,18 @@ class HelperUtils:
     def apply_rolling_average_if_needed(self, df, freq="1min", rolling_window="5min"):
         return SharedUtils.apply_rolling_average_if_needed(df, freq, rolling_window)
 
+    def validate_config(self, required_columns):
+        """
+        Check if all required columns are present and not None in the config dictionary.
+        """
+        if not self.config_dict:
+            raise ValueError("Config dictionary is not set.")
+        return all(self.config_dict.get(col) is not None for col in required_columns)
+
     def process_all_faults(self, df, config_dict):
-        # Import fault conditions
+        # Set the config dictionary
+        self.set_config_dict(config_dict)
+
         from open_fdd.air_handling_unit.faults.fault_condition_one import (
             FaultConditionOne,
         )
@@ -75,112 +92,325 @@ class HelperUtils:
         # Apply rolling average if needed
         df = self.apply_rolling_average_if_needed(df)
 
-        # Initialize Fault Condition Classes
-        fc1 = FaultConditionOne(config_dict)
-        fc2 = FaultConditionTwo(config_dict)
-        fc3 = FaultConditionThree(config_dict)
-        fc4 = FaultConditionFour(config_dict)
-        fc5 = FaultConditionFive(config_dict)
-        fc7 = FaultConditionSeven(config_dict)
-        fc8 = FaultConditionEight(config_dict)
-        fc9 = FaultConditionNine(config_dict)
-        fc10 = FaultConditionTen(config_dict)
-        fc11 = FaultConditionEleven(config_dict)
-        fc12 = FaultConditionTwelve(config_dict)
-        fc13 = FaultConditionThirteen(config_dict)
-
-        # Optionally initialize Fault Condition Six
+        # Initialize Fault Condition Classes with necessary checks
+        fc1 = None
+        if self.validate_config(
+            ["DUCT_STATIC_COL", "DUCT_STATIC_SETPOINT_COL", "SUPPLY_VFD_SPEED_COL"]
+        ):
+            print("Info: Running fc1")
+            fc1 = FaultConditionOne(config_dict)
+        else:
+            print("Info: Skipping fc1")
+
+        sys.stdout.flush()
+
+        fc2 = None
+        if self.validate_config(
+            ["SUPPLY_VFD_SPEED_COL", "MAT_COL", "OAT_COL", "SAT_COL", "RAT_COL"]
+        ):
+            print("Info: Running fc2 Go!")
+            fc2 = FaultConditionTwo(config_dict)
+        else:
+            print("Info: Skipping fc2")
+
+        sys.stdout.flush()
+
+        fc3 = None
+        if self.validate_config(
+            ["SUPPLY_VFD_SPEED_COL", "MAT_COL", "OAT_COL", "SAT_COL", "RAT_COL"]
+        ):
+            print("Info: Running fc3 Go!")
+            fc3 = FaultConditionThree(config_dict)
+        else:
+            print("Info: Skipping fc3")
+
+        sys.stdout.flush()
+
+        fc4 = None
+        if self.validate_config(
+            [
+                "SUPPLY_VFD_SPEED_COL",
+                "COOLING_SIG_COL",
+                "HEATING_SIG_COL",
+                "ECONOMIZER_SIG_COL",
+            ]
+        ):
+            print("Info: Running fc4 Go!")
+            fc4 = FaultConditionFour(config_dict)
+        else:
+            print("Info: Skipping fc4")
+
+        sys.stdout.flush()
+
+        fc5 = None
+        if self.validate_config(
+            ["SUPPLY_VFD_SPEED_COL", "HEATING_SIG_COL", "SAT_COL", "MAT_COL"]
+        ):
+            print("Info: Running fc5 Go!")
+            fc5 = FaultConditionFive(config_dict)
+        else:
+            print("Info: Skipping fc5")
+
+        sys.stdout.flush()
+
         fc6 = None
-        if config_dict.get("SUPPLY_FAN_AIR_VOLUME_COL") is not None:
+        if self.validate_config(
+            [
+                "SUPPLY_VFD_SPEED_COL",
+                "COOLING_SIG_COL",
+                "HEATING_SIG_COL",
+                "ECONOMIZER_SIG_COL",
+                "SUPPLY_FAN_AIR_VOLUME_COL",
+            ]
+        ):
+            print("Info: Running fc6 Go!")
             fc6 = FaultConditionSix(config_dict)
+        else:
+            print("Info: Skipping fc6")
+
+        sys.stdout.flush()
+
+        fc7 = None
+        if self.validate_config(
+            ["SUPPLY_VFD_SPEED_COL", "SAT_COL", "SAT_SETPOINT_COL", "HEATING_SIG_COL"]
+        ):
+            print("Info: Running fc7 Go!")
+            fc7 = FaultConditionSeven(config_dict)
+        else:
+            print("Info: Skipping fc7")
+
+        sys.stdout.flush()
+
+        fc8 = None
+        if self.validate_config(
+            [
+                "COOLING_SIG_COL",
+                "ECONOMIZER_SIG_COL",
+                "MAT_COL",
+                "SUPPLY_VFD_SPEED_COL",
+                "SAT_COL",
+            ]
+        ):
+            print("Info: Running fc8 Go!")
+            fc8 = FaultConditionEight(config_dict)
+        else:
+            print("Info: Skipping fc8")
+
+        sys.stdout.flush()
+
+        fc9 = None
+        if self.validate_config(
+            [
+                "OAT_COL",
+                "SUPPLY_VFD_SPEED_COL",
+                "SAT_COL",
+                "SAT_SETPOINT_COL",
+                "COOLING_SIG_COL",
+                "ECONOMIZER_SIG_COL",
+            ]
+        ):
+            print("Info: Running fc9 Go!")
+            fc9 = FaultConditionNine(config_dict)
+        else:
+            print("Info: Skipping fc9")
+
+        sys.stdout.flush()
+
+        fc10 = None
+        if self.validate_config(
+            [
+                "MAT_COL",
+                "OAT_COL",
+                "SUPPLY_VFD_SPEED_COL",
+                "COOLING_SIG_COL",
+                "ECONOMIZER_SIG_COL",
+            ]
+        ):
+            print("Info: Running fc10 Go!")
+            fc10 = FaultConditionTen(config_dict)
+        else:
+            print("Info: Skipping fc10")
+
+        sys.stdout.flush()
+
+        fc11 = None
+        if self.validate_config(
+            [
+                "OAT_COL",
+                "SUPPLY_VFD_SPEED_COL",
+                "COOLING_SIG_COL",
+                "ECONOMIZER_SIG_COL",
+                "SAT_SETPOINT_COL",
+            ]
+        ):
+            print("Info: Running fc11 Go!")
+            fc11 = FaultConditionEleven(config_dict)
+        else:
+            print("Info: Skipping fc11")
+
+        sys.stdout.flush()
+
+        fc12 = None
+        if self.validate_config(
+            [
+                "SUPPLY_VFD_SPEED_COL",
+                "ECONOMIZER_SIG_COL",
+                "COOLING_SIG_COL",
+                "SAT_COL",
+                "MAT_COL",
+            ]
+        ):
+            print("Info: Running fc12 Go!")
+            fc12 = FaultConditionTwelve(config_dict)
+        else:
+            print("Info: Skipping fc12")
+
+        sys.stdout.flush()
+
+        fc13 = None
+        if self.validate_config(
+            [
+                "SUPPLY_VFD_SPEED_COL",
+                "ECONOMIZER_SIG_COL",
+                "COOLING_SIG_COL",
+                "SAT_SETPOINT_COL",
+                "SAT_COL",
+            ]
+        ):
+            print("Info: Running fc13 Go!")
+            fc13 = FaultConditionThirteen(config_dict)
+        else:
+            print("Info: Skipping fc13")
+
+        sys.stdout.flush()
 
-        # Optionally initialize Fault Condition Fourteen
         fc14 = None
         if (
             config_dict.get("COOLING_SIG_COL") is not None
             and config_dict.get("CLG_COIL_LEAVE_TEMP_COL") is not None
         ):
+            print("Info: Running fc14 Go!")
             fc14 = FaultConditionFourteen(config_dict)
+        else:
+            print("Info: Skipping fc14")
+
+        sys.stdout.flush()
 
-        # Optionally initialize Fault Condition Fifteen
         fc15 = None
         if (
             config_dict.get("HTG_COIL_ENTER_TEMP_COL") is not None
             and config_dict.get("HTG_COIL_LEAVE_TEMP_COL") is not None
         ):
+            print("Info: Running fc15 Go!")
             fc15 = FaultConditionFifteen(config_dict)
+        else:
+            print("Info: Skipping fc15")
+
+        sys.stdout.flush()
 
         # Apply fault conditions and calculate fault counts
-        df_fc1 = fc1.apply(df.copy())
-        fault_counts["fc1_fault_sum"] = df_fc1["fc1_flag"].sum()
+        df_fc1 = fc1.apply(df.copy()) if fc1 is not None else None
+        if df_fc1 is not None:
+            fault_counts["fc1_fault_sum"] = df_fc1["fc1_flag"].sum()
 
-        df_fc2 = fc2.apply(df.copy())
-        fault_counts["fc2_fault_sum"] = df_fc2["fc2_flag"].sum()
+        df_fc2 = fc2.apply(df.copy()) if fc2 is not None else None
+        if df_fc2 is not None:
+            fault_counts["fc2_fault_sum"] = df_fc2["fc2_flag"].sum()
 
-        df_fc3 = fc3.apply(df.copy())
-        fault_counts["fc3_fault_sum"] = df_fc3["fc3_flag"].sum()
+        df_fc3 = fc3.apply(df.copy()) if fc3 is not None else None
+        if df_fc3 is not None:
+            fault_counts["fc3_fault_sum"] = df_fc3["fc3_flag"].sum()
 
-        df_fc4 = fc4.apply(df.copy())
-        fault_counts["fc4_fault_sum"] = df_fc4["fc4_flag"].sum()
+        df_fc4 = fc4.apply(df.copy()) if fc4 is not None else pd.DataFrame()
+        if not df_fc4.empty:
+            fault_counts["fc4_fault_sum"] = df_fc4["fc4_flag"].sum()
 
-        df_fc5 = fc5.apply(df.copy())
-        fault_counts["fc5_fault_sum"] = df_fc5["fc5_flag"].sum()
+        df_fc5 = fc5.apply(df.copy()) if fc5 is not None else None
+        if df_fc5 is not None:
+            fault_counts["fc5_fault_sum"] = df_fc5["fc5_flag"].sum()
 
-        if fc6 is not None:
-            df_fc6 = fc6.apply(df.copy())
+        df_fc6 = fc6.apply(df.copy()) if fc6 is not None else None
+        if df_fc6 is not None:
             fault_counts["fc6_fault_sum"] = df_fc6["fc6_flag"].sum()
 
-        df_fc7 = fc7.apply(df.copy())
-        fault_counts["fc7_fault_sum"] = df_fc7["fc7_flag"].sum()
+        df_fc7 = fc7.apply(df.copy()) if fc7 is not None else None
+        if df_fc7 is not None:
+            fault_counts["fc7_fault_sum"] = df_fc7["fc7_flag"].sum()
 
-        df_fc8 = fc8.apply(df.copy())
-        fault_counts["fc8_fault_sum"] = df_fc8["fc8_flag"].sum()
+        df_fc8 = fc8.apply(df.copy()) if fc8 is not None else None
+        if df_fc8 is not None:
+            fault_counts["fc8_fault_sum"] = df_fc8["fc8_flag"].sum()
 
-        df_fc9 = fc9.apply(df.copy())
-        fault_counts["fc9_fault_sum"] = df_fc9["fc9_flag"].sum()
+        df_fc9 = fc9.apply(df.copy()) if fc9 is not None else None
+        if df_fc9 is not None:
+            fault_counts["fc9_fault_sum"] = df_fc9["fc9_flag"].sum()
 
-        df_fc10 = fc10.apply(df.copy())
-        fault_counts["fc10_fault_sum"] = df_fc10["fc10_flag"].sum()
+        df_fc10 = fc10.apply(df.copy()) if fc10 is not None else None
+        if df_fc10 is not None:
+            fault_counts["fc10_fault_sum"] = df_fc10["fc10_flag"].sum()
 
-        df_fc11 = fc11.apply(df.copy())
-        fault_counts["fc11_fault_sum"] = df_fc11["fc11_flag"].sum()
+        df_fc11 = fc11.apply(df.copy()) if fc11 is not None else None
+        if df_fc11 is not None:
+            fault_counts["fc11_fault_sum"] = df_fc11["fc11_flag"].sum()
 
-        df_fc12 = fc12.apply(df.copy())
-        fault_counts["fc12_fault_sum"] = df_fc12["fc12_flag"].sum()
+        df_fc12 = fc12.apply(df.copy()) if fc12 is not None else None
+        if df_fc12 is not None:
+            fault_counts["fc12_fault_sum"] = df_fc12["fc12_flag"].sum()
 
-        df_fc13 = fc13.apply(df.copy())
-        fault_counts["fc13_fault_sum"] = df_fc13["fc13_flag"].sum()
+        df_fc13 = fc13.apply(df.copy()) if fc13 is not None else None
+        if df_fc13 is not None:
+            fault_counts["fc13_fault_sum"] = df_fc13["fc13_flag"].sum()
 
-        if fc14 is not None:
-            df_fc14 = fc14.apply(df.copy())
+        df_fc14 = fc14.apply(df.copy()) if fc14 is not None else None
+        if df_fc14 is not None:
             fault_counts["fc14_fault_sum"] = df_fc14["fc14_flag"].sum()
 
-        if fc15 is not None:
-            df_fc15 = fc15.apply(df.copy())
+        df_fc15 = fc15.apply(df.copy()) if fc15 is not None else None
+        if df_fc15 is not None:
             fault_counts["fc15_fault_sum"] = df_fc15["fc15_flag"].sum()
 
         # Combine fault condition results
-        df_combined = df_fc1.copy()
-        df_combined["fc2_flag"] = df_fc2["fc2_flag"]
-        df_combined["fc3_flag"] = df_fc3["fc3_flag"]
-        df_combined["fc4_flag"] = df_fc4["fc4_flag"]
-        df_combined["fc5_flag"] = df_fc5["fc5_flag"]
+        df_combined = df_fc1.copy() if df_fc1 is not None else df.copy()
 
-        if fc6 is not None:
+        if df_fc2 is not None:
+            df_combined["fc2_flag"] = df_fc2["fc2_flag"]
+
+        if df_fc3 is not None:
+            df_combined["fc3_flag"] = df_fc3["fc3_flag"]
+
+        # Skip combining df_fc4 since it is resampled
+
+        if df_fc5 is not None:
+            df_combined["fc5_flag"] = df_fc5["fc5_flag"]
+
+        if df_fc6 is not None:
             df_combined["fc6_flag"] = df_fc6["fc6_flag"]
 
-        df_combined["fc7_flag"] = df_fc7["fc7_flag"]
-        df_combined["fc8_flag"] = df_fc8["fc8_flag"]
-        df_combined["fc9_flag"] = df_fc9["fc9_flag"]
-        df_combined["fc10_flag"] = df_fc10["fc10_flag"]
-        df_combined["fc11_flag"] = df_fc11["fc11_flag"]
-        df_combined["fc12_flag"] = df_fc12["fc12_flag"]
-        df_combined["fc13_flag"] = df_fc13["fc13_flag"]
+        if df_fc7 is not None:
+            df_combined["fc7_flag"] = df_fc7["fc7_flag"]
+
+        if df_fc8 is not None:
+            df_combined["fc8_flag"] = df_fc8["fc8_flag"]
+
+        if df_fc9 is not None:
+            df_combined["fc9_flag"] = df_fc9["fc9_flag"]
+
+        if df_fc10 is not None:
+            df_combined["fc10_flag"] = df_fc10["fc10_flag"]
+
+        if df_fc11 is not None:
+            df_combined["fc11_flag"] = df_fc11["fc11_flag"]
+
+        if df_fc12 is not None:
+            df_combined["fc12_flag"] = df_fc12["fc12_flag"]
+
+        if df_fc13 is not None:
+            df_combined["fc13_flag"] = df_fc13["fc13_flag"]
 
-        if fc14 is not None:
+        if df_fc14 is not None:
             df_combined["fc14_flag"] = df_fc14["fc14_flag"]
 
-        if fc15 is not None:
+        if df_fc15 is not None:
             df_combined["fc15_flag"] = df_fc15["fc15_flag"]
 
         # Save fault counts to CSV