Update app/internal_loads.py

app/internal_loads.py

@@ -25,7 +25,7 @@ logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(
 logger = logging.getLogger(__name__)
 
 # Define constants
-LOAD_TYPES = ["Schedules", "People", "Lighting", "Equipment", "Ventilation & Infiltration"]
+LOAD_TYPES = ["Schedules", "People", "Lighting", "Equipment", "Ventilation", "Infiltration"]
 
 def display_internal_loads_page():
     """
@@ -33,7 +33,7 @@ def display_internal_loads_page():
     This is the main function called by main.py when the Internal Loads page is selected.
     """
     st.title("Internal Loads")
-    st.write("Define internal heat gains from people, lighting, equipment, ventilation, and infiltration based on ASHRAE 2005 Handbook.")
+    st.write("Define internal heat gains from people, lighting, equipment, ventilation, and infiltration based on ASHRAE 2021 Handbook.")
     
     # Check if building type is set
     building_type = st.session_state.project_data["building_info"].get("building_type")
@@ -59,7 +59,6 @@ def display_internal_loads_page():
     
     # Create tabs for different load types
     tabs = st.tabs(LOAD_TYPES)
-    
     for i, load_type in enumerate(LOAD_TYPES):
         with tabs[i]:
             if load_type == "Schedules":
@@ -70,8 +69,10 @@ def display_internal_loads_page():
                 display_lighting_tab()
             elif load_type == "Equipment":
                 display_equipment_tab()
-            elif load_type == "Ventilation & Infiltration":
-                display_ventilation_infiltration_tab()
+            elif load_type == "Ventilation":
+                display_ventilation_tab()
+            elif load_type == "Infiltration":
+                display_infiltration_tab()
             
     # Navigation buttons
     col1, col2 = st.columns(2)
@@ -98,7 +99,8 @@ def initialize_internal_loads():
             "people": [],
             "lighting": [],
             "equipment": [],
-            "ventilation_infiltration": []
+            "ventilation": [],
+            "infiltration": []
         }
 
 def display_people_tab():
@@ -568,55 +570,55 @@ def display_equipment_tab():
             st.session_state.equipment_action = {"action": "refresh", "id": str(uuid.uuid4())}
             st.session_state.internal_loads_rerun_pending = True
 
-def display_ventilation_infiltration_tab():
-    """Display the ventilation/infiltration tab content with a two-column layout similar to components.py."""
-    # Get ventilation/infiltration from session state
-    vent_inf_systems = st.session_state.project_data["internal_loads"]["ventilation_infiltration"]
+def display_ventilation_tab():
+    """Display the ventilation tab content with a two-column layout."""
+    # Get ventilation systems from session state
+    ventilation_systems = st.session_state.project_data["internal_loads"].setdefault("ventilation", [])
     
     # Split the display into two columns
     col1, col2 = st.columns([3, 2])
     
     with col1:
-        st.subheader("Saved Ventilation & Infiltration")
-        if vent_inf_systems:
-            display_ventilation_infiltration_table(vent_inf_systems)
+        st.subheader("Saved Ventilation Systems")
+        if ventilation_systems:
+            display_ventilation_table(ventilation_systems)
         else:
-            st.write("No ventilation or infiltration systems defined.")
+            st.write("No ventilation systems defined.")
     
     with col2:
-        st.subheader("Ventilation/Infiltration Editor/Creator")
+        st.subheader("Ventilation System Editor/Creator")
         
         # Initialize editor and action states
-        if "vent_inf_editor" not in st.session_state:
-            st.session_state.vent_inf_editor = {}
-        if "vent_inf_action" not in st.session_state:
-            st.session_state.vent_inf_action = {"action": None, "id": None}
+        if "ventilation_editor" not in st.session_state:
+            st.session_state.ventilation_editor = {}
+        if "ventilation_action" not in st.session_state:
+            st.session_state.ventilation_action = {"action": None, "id": None}
         
         # Get building type for default values
         building_type = st.session_state.project_data["building_info"].get("building_type")
         default_building_data = DEFAULT_BUILDING_INTERNALS.get(building_type, DEFAULT_BUILDING_INTERNALS["Other"])
         
+        # System type selection (outside form)
+        system_type = st.selectbox(
+            "System Type",
+            ["AirChanges/Hour", "Wind and Stack Open Area", "Balanced Flow", "Heat Recovery"],
+            key="ventilation_system_type",
+            help="Select the type of ventilation system."
+        )
+        
         # Display the editor form
-        with st.form("vent_inf_editor_form", clear_on_submit=True):
-            editor_state = st.session_state.get("vent_inf_editor", {})
+        with st.form("ventilation_editor_form", clear_on_submit=True):
+            editor_state = st.session_state.get("ventilation_editor", {})
             is_edit = editor_state.get("is_edit", False)
             
             # System name
             name = st.text_input(
                 "System Name",
                 value=editor_state.get("name", ""),
-                help="Enter a unique name for this ventilation/infiltration system."
-            )
-            
-            # System type
-            system_type = st.selectbox(
-                "System Type",
-                ["Ventilation", "Infiltration"],
-                index=["Ventilation", "Infiltration"].index(editor_state.get("system_type", "Ventilation")) if editor_state.get("system_type") in ["Ventilation", "Infiltration"] else 0,
-                help="Select whether this is ventilation or infiltration."
+                help="Enter a unique name for this ventilation system."
             )
             
-            # Area
+            # Area (required for all types)
             area = st.number_input(
                 "Area (m²)",
                 min_value=1.0,
@@ -626,28 +628,266 @@ def display_ventilation_infiltration_tab():
                 help="Floor area served by this system."
             )
             
-            if system_type == "Ventilation":
-                # Ventilation rate
-                ventilation_rate = st.number_input(
-                    "Ventilation Rate (L/s·m²)",
+            # Schedule selection
+            available_schedules = list(st.session_state.project_data["internal_loads"]["schedules"].keys())
+            schedule = st.selectbox(
+                "Schedule",
+                available_schedules,
+                index=available_schedules.index(editor_state.get("schedule", available_schedules[0])) if editor_state.get("schedule") in available_schedules else 0,
+                help="Select the operation schedule for this system."
+            )
+            
+            # Type-specific inputs
+            if system_type == "AirChanges/Hour":
+                design_flow_rate = st.number_input(
+                    "Design Flow Rate (ACH)",
                     min_value=0.1,
                     max_value=50.0,
-                    value=float(editor_state.get("ventilation_rate", default_building_data["ventilation_rate"])),
+                    value=float(editor_state.get("design_flow_rate", default_building_data.get("ventilation_rate", 1.0))),
                     format="%.2f",
-                    help="Ventilation rate in liters per second per square meter."
+                    help="Air change rate in air changes per hour."
                 )
-                air_change_rate = 0.0
-            else:
-                # Air change rate for infiltration
-                air_change_rate = st.number_input(
-                    "Air Change Rate (ACH)",
+                ventilation_type = st.selectbox(
+                    "Ventilation Type",
+                    ["Natural", "Mechanical"],
+                    index=["Natural", "Mechanical"].index(editor_state.get("ventilation_type", "Natural")) if editor_state.get("ventilation_type") in ["Natural", "Mechanical"] else 0,
+                    help="Select whether the ventilation is natural or mechanical."
+                )
+                fan_pressure_rise = 0.0
+                fan_efficiency = 0.0
+                if ventilation_type == "Mechanical":
+                    fan_pressure_rise = st.number_input(
+                        "Fan Pressure Rise (Pa)",
+                        min_value=0.0,
+                        max_value=1000.0,
+                        value=float(editor_state.get("fan_pressure_rise", 200.0)),
+                        format="%.2f",
+                        help="Fan pressure rise in Pascals for power calculation."
+                    )
+                    fan_efficiency = st.number_input(
+                        "Fan Efficiency (0–1)",
+                        min_value=0.0,
+                        max_value=1.0,
+                        value=float(editor_state.get("fan_efficiency", 0.7)),
+                        format="%.2f",
+                        help="Fan efficiency as a fraction between 0 and 1."
+                    )
+                sensible_effectiveness = 0.0
+                latent_effectiveness = 0.0
+            elif system_type == "Wind and Stack Open Area":
+                opening_effectiveness = st.number_input(
+                    "Opening Effectiveness (%)",
                     min_value=0.0,
-                    max_value=10.0,
-                    value=float(editor_state.get("air_change_rate", default_building_data["air_change_rate"])),
+                    max_value=100.0,
+                    value=float(editor_state.get("opening_effectiveness", 50.0)),
                     format="%.2f",
-                    help="Air change rate in air changes per hour."
+                    help="Effectiveness of the opening for ventilation (0–100%)."
+                )
+                design_flow_rate = 0.0
+                ventilation_type = ""
+                fan_pressure_rise = 0.0
+                fan_efficiency = 0.0
+                sensible_effectiveness = 0.0
+                latent_effectiveness = 0.0
+            elif system_type == "Balanced Flow":
+                design_flow_rate = st.number_input(
+                    "Design Flow Rate (m³/s)",
+                    min_value=0.0,
+                    max_value=100.0,
+                    value=float(editor_state.get("design_flow_rate", 0.5)),
+                    format="%.2f",
+                    help="Balanced supply and exhaust flow rate in cubic meters per second."
                 )
-                ventilation_rate = 0.0
+                fan_pressure_rise = st.number_input(
+                    "Fan Pressure Rise (Pa)",
+                    min_value=0.0,
+                    max_value=1000.0,
+                    value=float(editor_state.get("fan_pressure_rise", 200.0)),
+                    format="%.2f",
+                    help="Fan pressure rise in Pascals for power calculation."
+                )
+                fan_efficiency = st.number_input(
+                    "Fan Total Efficiency (0–1)",
+                    min_value=0.0,
+                    max_value=1.0,
+                    value=float(editor_state.get("fan_efficiency", 0.7)),
+                    format="%.2f",
+                    help="Total fan efficiency as a fraction between 0 and 1."
+                )
+                zone_name = st.text_input(
+                    "Zone Name",
+                    value=editor_state.get("zone_name", ""),
+                    help="Name of the target zone for this ventilation system."
+                )
+                ventilation_type = ""
+                sensible_effectiveness = 0.0
+                latent_effectiveness = 0.0
+            elif system_type == "Heat Recovery":
+                design_flow_rate = st.number_input(
+                    "Design Flow Rate (m³/s)",
+                    min_value=0.0,
+                    max_value=100.0,
+                    value=float(editor_state.get("design_flow_rate", 0.5)),
+                    format="%.2f",
+                    help="Balanced supply and exhaust flow rate in cubic meters per second."
+                )
+                fan_pressure_rise = st.number_input(
+                    "Fan Pressure Rise (Pa)",
+                    min_value=0.0,
+                    max_value=1000.0,
+                    value=float(editor_state.get("fan_pressure_rise", 200.0)),
+                    format="%.2f",
+                    help="Fan pressure rise in Pascals for power calculation."
+                )
+                fan_efficiency = st.number_input(
+                    "Fan Total Efficiency (0–1)",
+                    min_value=0.0,
+                    max_value=1.0,
+                    value=float(editor_state.get("fan_efficiency", 0.7)),
+                    format="%.2f",
+                    help="Total fan efficiency as a fraction between 0 and 1."
+                )
+                zone_name = st.text_input(
+                    "Zone Name",
+                    value=editor_state.get("zone_name", ""),
+                    help="Name of the target zone for this ventilation system."
+                )
+                sensible_effectiveness = st.number_input(
+                    "Sensible Effectiveness (0–1)",
+                    min_value=0.0,
+                    max_value=1.0,
+                    value=float(editor_state.get("sensible_effectiveness", 0.8)),
+                    format="%.2f",
+                    help="Sensible heat recovery effectiveness as a fraction between 0 and 1."
+                )
+                latent_effectiveness = st.number_input(
+                    "Latent Effectiveness (0–1)",
+                    min_value=0.0,
+                    max_value=1.0,
+                    value=float(editor_state.get("latent_effectiveness", 0.6)),
+                    format="%.2f",
+                    help="Latent heat recovery effectiveness as a fraction between 0 and 1."
+                )
+                ventilation_type = ""
+            
+            # Submit buttons
+            col1, col2 = st.columns(2)
+            with col1:
+                submit_label = "Update" if is_edit else "Add"
+                submit = st.form_submit_button(f"{submit_label} Ventilation System")
+            
+            with col2:
+                refresh = st.form_submit_button("Refresh")
+        
+        # Handle form submission
+        if submit:
+            # Validate inputs
+            if not name.strip():
+                st.error("System name is required.")
+                return
+            # Check for unique name
+            existing_names = [system["name"] for system in ventilation_systems if not (is_edit and system["name"] == editor_state.get("name"))]
+            if name.strip() in existing_names:
+                st.error("System name must be unique.")
+                return
+            if system_type in ["Balanced Flow", "Heat Recovery"] and not zone_name.strip():
+                st.error("Zone name is required for Balanced Flow and Heat Recovery systems.")
+                return
+            
+            # Create ventilation data
+            ventilation_data = {
+                "id": str(uuid.uuid4()),
+                "name": name.strip(),
+                "system_type": system_type,
+                "area": area,
+                "schedule": schedule,
+                "design_flow_rate": design_flow_rate,
+                "ventilation_type": ventilation_type,
+                "fan_pressure_rise": fan_pressure_rise,
+                "fan_efficiency": fan_efficiency,
+                "zone_name": zone_name if system_type in ["Balanced Flow", "Heat Recovery"] else "",
+                "opening_effectiveness": opening_effectiveness if system_type == "Wind and Stack Open Area" else 0.0,
+                "sensible_effectiveness": sensible_effectiveness,
+                "latent_effectiveness": latent_effectiveness
+            }
+            
+            # Handle edit mode
+            if is_edit:
+                index = editor_state.get("index", 0)
+                st.session_state.project_data["internal_loads"]["ventilation"][index] = ventilation_data
+                st.success(f"Ventilation System '{name}' updated!")
+            else:
+                st.session_state.project_data["internal_loads"]["ventilation"].append(ventilation_data)
+                st.success(f"Ventilation System '{name}' added!")
+            
+            # Clear editor state
+            st.session_state.ventilation_editor = {}
+            st.session_state.ventilation_action = {"action": "save", "id": str(uuid.uuid4())}
+            st.session_state.internal_loads_rerun_pending = True
+        
+        elif refresh:
+            # Clear editor state
+            st.session_state.ventilation_editor = {}
+            st.session_state.ventilation_action = {"action": "refresh", "id": str(uuid.uuid4())}
+            st.session_state.internal_loads_rerun_pending = True
+
+def display_infiltration_tab():
+    """Display the infiltration tab content with a two-column layout."""
+    # Get infiltration systems from session state
+    infiltration_systems = st.session_state.project_data["internal_loads"].setdefault("infiltration", [])
+    
+    # Split the display into two columns
+    col1, col2 = st.columns([3, 2])
+    
+    with col1:
+        st.subheader("Saved Infiltration Systems")
+        if infiltration_systems:
+            display_infiltration_table(infiltration_systems)
+        else:
+            st.write("No infiltration systems defined.")
+    
+    with col2:
+        st.subheader("Infiltration System Editor/Creator")
+        
+        # Initialize editor and action states
+        if "infiltration_editor" not in st.session_state:
+            st.session_state.infiltration_editor = {}
+        if "infiltration_action" not in st.session_state:
+            st.session_state.infiltration_action = {"action": None, "id": None}
+        
+        # Get building type for default values
+        building_type = st.session_state.project_data["building_info"].get("building_type")
+        default_building_data = DEFAULT_BUILDING_INTERNALS.get(building_type, DEFAULT_BUILDING_INTERNALS["Other"])
+        
+        # System type selection (outside form)
+        system_type = st.selectbox(
+            "System Type",
+            ["AirChanges/Hour", "Effective Leakage Area", "Flow Coefficient"],
+            key="infiltration_system_type",
+            help="Select the type of infiltration system."
+        )
+        
+        # Display the editor form
+        with st.form("infiltration_editor_form", clear_on_submit=True):
+            editor_state = st.session_state.get("infiltration_editor", {})
+            is_edit = editor_state.get("is_edit", False)
+            
+            # System name
+            name = st.text_input(
+                "System Name",
+                value=editor_state.get("name", ""),
+                help="Enter a unique name for this infiltration system."
+            )
+            
+            # Area (required for all types)
+            area = st.number_input(
+                "Area (m²)",
+                min_value=1.0,
+                max_value=100000.0,
+                value=float(editor_state.get("area", st.session_state.project_data["building_info"].get("floor_area", 100.0))),
+                format="%.2f",
+                help="Floor area served by this system."
+            )
             
             # Schedule selection
             available_schedules = list(st.session_state.project_data["internal_loads"]["schedules"].keys())
@@ -658,11 +898,90 @@ def display_ventilation_infiltration_tab():
                 help="Select the operation schedule for this system."
             )
             
+            # Type-specific inputs
+            if system_type == "AirChanges/Hour":
+                design_flow_rate = st.number_input(
+                    "Design Flow Rate (ACH)",
+                    min_value=0.0,
+                    max_value=10.0,
+                    value=float(editor_state.get("design_flow_rate", default_building_data.get("air_change_rate", 0.3))),
+                    format="%.2f",
+                    help="Air change rate in air changes per hour."
+                )
+                effective_air_leakage_area = 0.0
+                stack_coefficient = 0.0
+                wind_coefficient = 0.0
+                flow_coefficient = 0.0
+                pressure_exponent = 0.0
+            elif system_type == "Effective Leakage Area":
+                effective_air_leakage_area = st.number_input(
+                    "Effective Air Leakage Area (cm²)",
+                    min_value=0.0,
+                    max_value=10000.0,
+                    value=float(editor_state.get("effective_air_leakage_area", 100.0)),
+                    format="%.2f",
+                    help="Effective air leakage area in square centimeters at 4 Pa or 10 Pa."
+                )
+                stack_coefficient = st.number_input(
+                    "Stack Coefficient",
+                    min_value=0.0,
+                    max_value=1.0,
+                    value=float(editor_state.get("stack_coefficient", 0.0001)),
+                    format="%.6f",
+                    help="Stack coefficient from standards or measurements."
+                )
+                wind_coefficient = st.number_input(
+                    "Wind Coefficient",
+                    min_value=0.0,
+                    max_value=1.0,
+                    value=float(editor_state.get("wind_coefficient", 0.0001)),
+                    format="%.6f",
+                    help="Wind coefficient from standards or measurements."
+                )
+                design_flow_rate = 0.0
+                flow_coefficient = 0.0
+                pressure_exponent = 0.0
+            elif system_type == "Flow Coefficient":
+                flow_coefficient = st.number_input(
+                    "Flow Coefficient (m³/s·Paⁿ)",
+                    min_value=0.0,
+                    max_value=1.0,
+                    value=float(editor_state.get("flow_coefficient", 0.0001)),
+                    format="%.6f",
+                    help="Airflow at reference pressure in cubic meters per second per Pascal raised to the pressure exponent."
+                )
+                pressure_exponent = st.number_input(
+                    "Pressure Exponent",
+                    min_value=0.0,
+                    max_value=1.0,
+                    value=float(editor_state.get("pressure_exponent", 0.6)),
+                    format="%.2f",
+                    help="Pressure exponent, typically 0.6."
+                )
+                stack_coefficient = st.number_input(
+                    "Stack Coefficient",
+                    min_value=0.0,
+                    max_value=1.0,
+                    value=float(editor_state.get("stack_coefficient", 0.0001)),
+                    format="%.6f",
+                    help="Stack coefficient from standards or measurements."
+                )
+                wind_coefficient = st.number_input(
+                    "Wind Coefficient",
+                    min_value=0.0,
+                    max_value=1.0,
+                    value=float(editor_state.get("wind_coefficient", 0.0001)),
+                    format="%.6f",
+                    help="Wind coefficient from standards or measurements."
+                )
+                design_flow_rate = 0.0
+                effective_air_leakage_area = 0.0
+            
             # Submit buttons
             col1, col2 = st.columns(2)
             with col1:
                 submit_label = "Update" if is_edit else "Add"
-                submit = st.form_submit_button(f"{submit_label} System")
+                submit = st.form_submit_button(f"{submit_label} Infiltration System")
             
             with col2:
                 refresh = st.form_submit_button("Refresh")
@@ -674,40 +993,44 @@ def display_ventilation_infiltration_tab():
                 st.error("System name is required.")
                 return
             # Check for unique name
-            existing_names = [system["name"] for system in vent_inf_systems if not (is_edit and system["name"] == editor_state.get("name"))]
+            existing_names = [system["name"] for system in infiltration_systems if not (is_edit and system["name"] == editor_state.get("name"))]
             if name.strip() in existing_names:
                 st.error("System name must be unique.")
                 return
             
-            # Create ventilation/infiltration data
-            vent_inf_data = {
+            # Create infiltration data
+            infiltration_data = {
                 "id": str(uuid.uuid4()),
                 "name": name.strip(),
                 "system_type": system_type,
                 "area": area,
-                "ventilation_rate": ventilation_rate,
-                "air_change_rate": air_change_rate,
-                "schedule": schedule
+                "schedule": schedule,
+                "design_flow_rate": design_flow_rate,
+                "effective_air_leakage_area": effective_air_leakage_area,
+                "stack_coefficient": stack_coefficient,
+                "wind_coefficient": wind_coefficient,
+                "flow_coefficient": flow_coefficient,
+                "pressure_exponent": pressure_exponent
             }
             
             # Handle edit mode
             if is_edit:
                 index = editor_state.get("index", 0)
-                st.session_state.project_data["internal_loads"]["ventilation_infiltration"][index] = vent_inf_data
-                st.success(f"{system_type} System '{name}' updated!")
+                st.session_state.project_data["internal_loads"]["infiltration"][index] = infiltration_data
+                st.success(f"Infiltration System '{name}' updated!")
             else:
-                st.session_state.project_data["internal_loads"]["ventilation_infiltration"].append(vent_inf_data)
-                st.success(f"{system_type} System '{name}' added!")
+                st.session_state.project_data["internal_loads"]["infiltration"].append(infiltration_data)
+                st.success(f"Infiltration System '{name}' added!")
             
             # Clear editor state
-            st.session_state.vent_inf_editor = {}
-            st.session_state.vent_inf_action = {"action": "save", "id": str(uuid.uuid4())}
+            st.session_state.infiltration_editor = {}
+            st.session_state.infiltration_action = {"action": "save", "id": str(uuid.uuid4())}
             st.session_state.internal_loads_rerun_pending = True
         
         elif refresh:
             # Clear editor state
-            st.session_state.vent_inf_editor = {}
-            st.session_state.vent_inf_action = {"action": "refresh", "id": str(uuid.uuid4())}
+            st.session_state.infiltration_editor = {}
+            st.session_state.infiltration_action = {"action": "refresh", "id": str(uuid.uuid4())}
             st.session_state.internal_loads_rerun_pending = True
 
 def display_schedules_tab():
@@ -1087,8 +1410,65 @@ def display_equipment_table(equipment_systems: List[Dict[str, Any]]):
                 st.session_state.equipment_action = {"action": "delete", "id": str(uuid.uuid4())}
                 st.session_state.internal_loads_rerun_pending = True
 
-def display_ventilation_infiltration_table(vent_inf_systems: List[Dict[str, Any]]):
-    """Display ventilation/infiltration systems in a table format with edit/delete buttons."""
+def display_ventilation_table(ventilation_systems: List[Dict[str, Any]]):
+    """Display ventilation systems in a table format with edit/delete buttons."""
+    # Create column headers
+    cols = st.columns([2, 1, 1, 1, 1, 1])
+    cols[0].write("**Name**")
+    cols[1].write("**Type**")
+    cols[2].write("**Area (m²)**")
+    cols[3].write("**Rate**")
+    cols[4].write("**Edit**")
+    cols[5].write("**Delete**")
+    
+    # Display each system
+    for idx, system in enumerate(ventilation_systems):
+        cols = st.columns([2, 1, 1, 1, 1, 1])
+        cols[0].write(system["name"])
+        cols[1].write(system.get("system_type", "Unknown"))
+        cols[2].write(f"{system.get('area', 0):.1f}")
+        if system.get("system_type") == "AirChanges/Hour":
+            rate_info = f"{system.get('design_flow_rate', 0):.2f} ACH"
+        elif system.get("system_type") in ["Balanced Flow", "Heat Recovery"]:
+            rate_info = f"{system.get('design_flow_rate', 0):.2f} m³/s"
+        else:
+            rate_info = f"{system.get('opening_effectiveness', 0):.2f} %"
+        cols[3].write(rate_info)
+        
+        # Edit button
+        edit_key = f"edit_ventilation_{system['name']}_{idx}"
+        with cols[4].container():
+            if st.button("Edit", key=edit_key):
+                st.session_state.ventilation_editor = {
+                    "index": idx,
+                    "name": system.get("name", ""),
+                    "system_type": system.get("system_type", "AirChanges/Hour"),
+                    "area": system.get("area", 100.0),
+                    "schedule": system.get("schedule", "Continuous"),
+                    "design_flow_rate": system.get("design_flow_rate", 1.0),
+                    "ventilation_type": system.get("ventilation_type", "Natural"),
+                    "fan_pressure_rise": system.get("fan_pressure_rise", 200.0),
+                    "fan_efficiency": system.get("fan_efficiency", 0.7),
+                    "zone_name": system.get("zone_name", ""),
+                    "opening_effectiveness": system.get("opening_effectiveness", 50.0),
+                    "sensible_effectiveness": system.get("sensible_effectiveness", 0.8),
+                    "latent_effectiveness": system.get("latent_effectiveness", 0.6),
+                    "is_edit": True
+                }
+                st.session_state.ventilation_action = {"action": "edit", "id": str(uuid.uuid4())}
+                st.session_state.internal_loads_rerun_pending = True
+        
+        # Delete button
+        delete_key = f"delete_ventilation_{system['name']}_{idx}"
+        with cols[5].container():
+            if st.button("Delete", key=delete_key):
+                st.session_state.project_data["internal_loads"]["ventilation"].pop(idx)
+                st.success(f"Ventilation System '{system['name']}' deleted!")
+                st.session_state.ventilation_action = {"action": "delete", "id": str(uuid.uuid4())}
+                st.session_state.internal_loads_rerun_pending = True
+
+def display_infiltration_table(infiltration_systems: List[Dict[str, Any]]):
+    """Display infiltration systems in a table format with edit/delete buttons."""
     # Create column headers
     cols = st.columns([2, 1, 1, 1, 1, 1])
     cols[0].write("**Name**")
@@ -1099,38 +1479,47 @@ def display_ventilation_infiltration_table(vent_inf_systems: List[Dict[str, Any]
     cols[5].write("**Delete**")
     
     # Display each system
-    for idx, system in enumerate(vent_inf_systems):
+    for idx, system in enumerate(infiltration_systems):
         cols = st.columns([2, 1, 1, 1, 1, 1])
         cols[0].write(system["name"])
         cols[1].write(system.get("system_type", "Unknown"))
         cols[2].write(f"{system.get('area', 0):.1f}")
-        rate_info = f"{system.get('ventilation_rate', 0):.2f} L/s·m²" if system.get("system_type") == "Ventilation" else f"{system.get('air_change_rate', 0):.2f} ACH"
+        if system.get("system_type") == "AirChanges/Hour":
+            rate_info = f"{system.get('design_flow_rate', 0):.2f} ACH"
+        elif system.get("system_type") == "Effective Leakage Area":
+            rate_info = f"{system.get('effective_air_leakage_area', 0):.2f} cm²"
+        else:
+            rate_info = f"{system.get('flow_coefficient', 0):.6f} m³/s·Paⁿ"
         cols[3].write(rate_info)
         
         # Edit button
-        edit_key = f"edit_vent_inf_{system['name']}_{idx}"
+        edit_key = f"edit_infiltration_{system['name']}_{idx}"
         with cols[4].container():
             if st.button("Edit", key=edit_key):
-                st.session_state.vent_inf_editor = {
+                st.session_state.infiltration_editor = {
                     "index": idx,
                     "name": system.get("name", ""),
-                    "system_type": system.get("system_type", "Ventilation"),
+                    "system_type": system.get("system_type", "AirChanges/Hour"),
                     "area": system.get("area", 100.0),
-                    "ventilation_rate": system.get("ventilation_rate", 10.0),
-                    "air_change_rate": system.get("air_change_rate", 1.0),
                     "schedule": system.get("schedule", "Continuous"),
+                    "design_flow_rate": system.get("design_flow_rate", 0.3),
+                    "effective_air_leakage_area": system.get("effective_air_leakage_area", 100.0),
+                    "stack_coefficient": system.get("stack_coefficient", 0.0001),
+                    "wind_coefficient": system.get("wind_coefficient", 0.0001),
+                    "flow_coefficient": system.get("flow_coefficient", 0.0001),
+                    "pressure_exponent": system.get("pressure_exponent", 0.6),
                     "is_edit": True
                 }
-                st.session_state.vent_inf_action = {"action": "edit", "id": str(uuid.uuid4())}
+                st.session_state.infiltration_action = {"action": "edit", "id": str(uuid.uuid4())}
                 st.session_state.internal_loads_rerun_pending = True
         
         # Delete button
-        delete_key = f"delete_vent_inf_{system['name']}_{idx}"
+        delete_key = f"delete_infiltration_{system['name']}_{idx}"
         with cols[5].container():
             if st.button("Delete", key=delete_key):
-                st.session_state.project_data["internal_loads"]["ventilation_infiltration"].pop(idx)
-                st.success(f"{system.get('system_type', 'System')} '{system['name']}' deleted!")
-                st.session_state.vent_inf_action = {"action": "delete", "id": str(uuid.uuid4())}
+                st.session_state.project_data["internal_loads"]["infiltration"].pop(idx)
+                st.success(f"Infiltration System '{system['name']}' deleted!")
+                st.session_state.infiltration_action = {"action": "delete", "id": str(uuid.uuid4())}
                 st.session_state.internal_loads_rerun_pending = True
 
 def display_schedules_table(schedules: Dict[str, Any]):