Update app/internal_loads.py

app/internal_loads.py

@@ -104,8 +104,10 @@ def initialize_internal_loads():
 
 def display_people_tab():
     """Display the people tab content with a two-column layout similar to components.py."""
+    # Get people from session state
     people_groups = st.session_state.project_data["internal_loads"]["people"]
     
+    # Split the display into two columns
     col1, col2 = st.columns([3, 2])
     
     with col1:
@@ -118,21 +120,25 @@ def display_people_tab():
     with col2:
         st.subheader("People Group Editor/Creator")
         
+        # Initialize editor and action states
         if "people_editor" not in st.session_state:
             st.session_state.people_editor = {}
         if "people_action" not in st.session_state:
             st.session_state.people_action = {"action": None, "id": None}
         
+        # Display the editor form
         with st.form("people_editor_form", clear_on_submit=True):
             editor_state = st.session_state.get("people_editor", {})
             is_edit = editor_state.get("is_edit", False)
             
+            # Group name
             name = st.text_input(
                 "Group Name",
                 value=editor_state.get("name", ""),
                 help="Enter a unique name for this people group."
             )
             
+            # Number of people
             num_people = st.number_input(
                 "Number of People",
                 min_value=1,
@@ -141,6 +147,7 @@ def display_people_tab():
                 help="Number of people in this group."
             )
             
+            # Activity level
             activity_level = st.selectbox(
                 "Activity Level",
                 list(PEOPLE_ACTIVITY_LEVELS.keys()),
@@ -148,6 +155,7 @@ def display_people_tab():
                 help="Select the activity level for this group."
             )
             
+            # Clothing insulation
             st.write("**Clothing Insulation:**")
             col_summer, col_winter = st.columns(2)
             
@@ -171,6 +179,7 @@ def display_people_tab():
                     help="Clothing insulation for winter conditions."
                 )
             
+            # Schedule selection
             available_schedules = list(st.session_state.project_data["internal_loads"]["schedules"].keys())
             schedule = st.selectbox(
                 "Schedule",
@@ -179,12 +188,14 @@ def display_people_tab():
                 help="Select the occupancy schedule for this group."
             )
             
+            # Zone assignment
             zone = st.text_input(
                 "Zone",
                 value=editor_state.get("zone", "Whole Building"),
                 help="Zone or area where this people group is located."
             )
             
+            # Submit buttons
             col1, col2 = st.columns(2)
             with col1:
                 submit_label = "Update" if is_edit else "Add"
@@ -193,64 +204,64 @@ def display_people_tab():
             with col2:
                 refresh = st.form_submit_button("Refresh")
         
-            # Handle form submission
-            if submit:
-                action_id = str(uuid.uuid4())
-                if st.session_state.people_action.get("id") != action_id:
-                    st.session_state.people_action = {"action": "save", "id": action_id}
-                    
-                    # Validate inputs
-                    if not name.strip():
-                        st.error("Group name is required.")
-                        return
-                    existing_names = [group["name"] for group in people_groups if not (is_edit and group["name"] == editor_state.get("name"))]
-                    if name.strip() in existing_names:
-                        st.error("Group name must be unique.")
-                        return
-                    
-                    activity_data = PEOPLE_ACTIVITY_LEVELS[activity_level]
-                    
-                    people_data = {
-                        "id": str(uuid.uuid4()),
-                        "name": name.strip(),
-                        "num_people": num_people,
-                        "activity_level": activity_level,
-                        "activity_data": activity_data,
-                        "clo_summer": clo_summer,
-                        "clo_winter": clo_winter,
-                        "schedule": schedule,
-                        "zone": zone,
-                        "sensible_heat_per_person": (activity_data["sensible_min_w"] + activity_data["sensible_max_w"]) / 2,
-                        "latent_heat_per_person": (activity_data["latent_min_w"] + activity_data["latent_max_w"]) / 2,
-                        "total_sensible_heat": num_people * (activity_data["sensible_min_w"] + activity_data["sensible_max_w"]) / 2,
-                        "total_latent_heat": num_people * (activity_data["latent_min_w"] + activity_data["latent_max_w"]) / 2
-                    }
-                    
-                    if is_edit:
-                        index = editor_state.get("index", 0)
-                        st.session_state.project_data["internal_loads"]["people"][index] = people_data
-                        st.success(f"People group '{name}' updated!")
-                    else:
-                        st.session_state.project_data["internal_loads"]["people"].append(people_data)
-                        st.success(f"People group '{name}' added!")
-                    
-                    st.session_state.people_editor = {}
-                    st.session_state.people_action = {"action": None, "id": None}
-                    st.session_state.module_rerun_flags["internal_loads"] = True
-                    st.rerun()
+        # Handle form submission
+        if submit:
+            # Validate inputs
+            if not name.strip():
+                st.error("Group name is required.")
+                return
+            # Check for unique name
+            existing_names = [group["name"] for group in people_groups if not (is_edit and group["name"] == editor_state.get("name"))]
+            if name.strip() in existing_names:
+                st.error("Group name must be unique.")
+                return
             
-            if refresh:
-                action_id = str(uuid.uuid4())
-                if st.session_state.people_action.get("id") != action_id:
-                    st.session_state.people_action = {"action": "refresh", "id": action_id}
-                    st.session_state.people_editor = {}
-                    st.session_state.module_rerun_flags["internal_loads"] = True
-                    st.rerun()
+            # Get activity data
+            activity_data = PEOPLE_ACTIVITY_LEVELS[activity_level]
+            
+            # Create people group data
+            people_data = {
+                "id": str(uuid.uuid4()),
+                "name": name.strip(),
+                "num_people": num_people,
+                "activity_level": activity_level,
+                "activity_data": activity_data,
+                "clo_summer": clo_summer,
+                "clo_winter": clo_winter,
+                "schedule": schedule,
+                "zone": zone,
+                "sensible_heat_per_person": (activity_data["sensible_min_w"] + activity_data["sensible_max_w"]) / 2,
+                "latent_heat_per_person": (activity_data["latent_min_w"] + activity_data["latent_max_w"]) / 2,
+                "total_sensible_heat": num_people * (activity_data["sensible_min_w"] + activity_data["sensible_max_w"]) / 2,
+                "total_latent_heat": num_people * (activity_data["latent_min_w"] + activity_data["latent_max_w"]) / 2
+            }
+            
+            # Handle edit mode
+            if is_edit:
+                index = editor_state.get("index", 0)
+                st.session_state.project_data["internal_loads"]["people"][index] = people_data
+                st.success(f"People group '{name}' updated!")
+            else:
+                st.session_state.project_data["internal_loads"]["people"].append(people_data)
+                st.success(f"People group '{name}' added!")
+            
+            # Clear editor state
+            st.session_state.people_editor = {}
+            st.session_state.people_action = {"action": "save", "id": str(uuid.uuid4())}
+            st.session_state.module_rerun_flags["internal_loads"] = True
+        
+        elif refresh:
+            # Clear editor state
+            st.session_state.people_editor = {}
+            st.session_state.people_action = {"action": "refresh", "id": str(uuid.uuid4())}
+            st.session_state.module_rerun_flags["internal_loads"] = True
 
 def display_lighting_tab():
     """Display the lighting tab content with a two-column layout similar to components.py."""
+    # Get lighting from session state
     lighting_systems = st.session_state.project_data["internal_loads"]["lighting"]
     
+    # Split the display into two columns
     col1, col2 = st.columns([3, 2])
     
     with col1:
@@ -263,24 +274,29 @@ def display_lighting_tab():
     with col2:
         st.subheader("Lighting System Editor/Creator")
         
+        # Initialize editor and action states
         if "lighting_editor" not in st.session_state:
             st.session_state.lighting_editor = {}
         if "lighting_action" not in st.session_state:
             st.session_state.lighting_action = {"action": None, "id": None}
         
+        # Get building type for default values
         building_type = st.session_state.project_data["building_info"].get("building_type")
         default_lighting_density = DEFAULT_BUILDING_INTERNALS.get(building_type, DEFAULT_BUILDING_INTERNALS["Other"])["lighting_density"]
         
+        # Display the editor form
         with st.form("lighting_editor_form", clear_on_submit=True):
             editor_state = st.session_state.get("lighting_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 lighting system."
             )
             
+            # Area
             area = st.number_input(
                 "Area (m²)",
                 min_value=1.0,
@@ -290,6 +306,7 @@ def display_lighting_tab():
                 help="Floor area served by this lighting system."
             )
             
+            # Lighting power density
             lpd = st.number_input(
                 "Lighting Power Density (W/m²)",
                 min_value=0.1,
@@ -299,6 +316,7 @@ def display_lighting_tab():
                 help="Lighting power density in watts per square meter."
             )
             
+            # Heat fractions
             st.write("**Heat Distribution:**")
             col_rad, col_conv = st.columns(2)
             
@@ -322,6 +340,7 @@ def display_lighting_tab():
                     help="Fraction of heat released as convection."
                 )
             
+            # Schedule selection
             available_schedules = list(st.session_state.project_data["internal_loads"]["schedules"].keys())
             schedule = st.selectbox(
                 "Schedule",
@@ -330,12 +349,14 @@ def display_lighting_tab():
                 help="Select the lighting schedule for this system."
             )
             
+            # Zone assignment
             zone = st.text_input(
                 "Zone",
                 value=editor_state.get("zone", "Whole Building"),
                 help="Zone or area where this lighting system is located."
             )
             
+            # Submit buttons
             col1, col2 = st.columns(2)
             with col1:
                 submit_label = "Update" if is_edit else "Add"
@@ -344,59 +365,60 @@ def display_lighting_tab():
             with col2:
                 refresh = st.form_submit_button("Refresh")
         
-            if submit:
-                action_id = str(uuid.uuid4())
-                if st.session_state.lighting_action.get("id") != action_id:
-                    st.session_state.lighting_action = {"action": "save", "id": action_id}
-                    
-                    if not name.strip():
-                        st.error("System name is required.")
-                        return
-                    if abs(radiative_fraction + convective_fraction - 1.0) > 0.01:
-                        st.error("Radiative and convective fractions must sum to 1.0")
-                        return
-                    existing_names = [system["name"] for system in lighting_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
-                    
-                    lighting_data = {
-                        "id": str(uuid.uuid4()),
-                        "name": name.strip(),
-                        "area": area,
-                        "lpd": lpd,
-                        "total_power": area * lpd,
-                        "radiative_fraction": radiative_fraction,
-                        "convective_fraction": convective_fraction,
-                        "schedule": schedule,
-                        "zone": zone
-                    }
-                    
-                    if is_edit:
-                        index = editor_state.get("index", 0)
-                        st.session_state.project_data["internal_loads"]["lighting"][index] = lighting_data
-                        st.success(f"Lighting system '{name}' updated!")
-                    else:
-                        st.session_state.project_data["internal_loads"]["lighting"].append(lighting_data)
-                        st.success(f"Lighting system '{name}' added!")
-                    
-                    st.session_state.lighting_editor = {}
-                    st.session_state.lighting_action = {"action": None, "id": None}
-                    st.session_state.module_rerun_flags["internal_loads"] = True
-                    st.rerun()
+        # Handle form submission
+        if submit:
+            # Validate inputs
+            if not name.strip():
+                st.error("System name is required.")
+                return
+            if abs(radiative_fraction + convective_fraction - 1.0) > 0.01:
+                st.error("Radiative and convective fractions must sum to 1.0")
+                return
+            # Check for unique name
+            existing_names = [system["name"] for system in lighting_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 refresh:
-                action_id = str(uuid.uuid4())
-                if st.session_state.lighting_action.get("id") != action_id:
-                    st.session_state.lighting_action = {"action": "refresh", "id": action_id}
-                    st.session_state.lighting_editor = {}
-                    st.session_state.module_rerun_flags["internal_loads"] = True
-                    st.rerun()
+            # Create lighting system data
+            lighting_data = {
+                "id": str(uuid.uuid4()),
+                "name": name.strip(),
+                "area": area,
+                "lpd": lpd,
+                "total_power": area * lpd,
+                "radiative_fraction": radiative_fraction,
+                "convective_fraction": convective_fraction,
+                "schedule": schedule,
+                "zone": zone
+            }
+            
+            # Handle edit mode
+            if is_edit:
+                index = editor_state.get("index", 0)
+                st.session_state.project_data["internal_loads"]["lighting"][index] = lighting_data
+                st.success(f"Lighting system '{name}' updated!")
+            else:
+                st.session_state.project_data["internal_loads"]["lighting"].append(lighting_data)
+                st.success(f"Lighting system '{name}' added!")
+            
+            # Clear editor state
+            st.session_state.lighting_editor = {}
+            st.session_state.lighting_action = {"action": "save", "id": str(uuid.uuid4())}
+            st.session_state.module_rerun_flags["internal_loads"] = True
+        
+        elif refresh:
+            # Clear editor state
+            st.session_state.lighting_editor = {}
+            st.session_state.lighting_action = {"action": "refresh", "id": str(uuid.uuid4())}
+            st.session_state.module_rerun_flags["internal_loads"] = True
 
 def display_equipment_tab():
     """Display the equipment tab content with a two-column layout similar to components.py."""
+    # Get equipment from session state
     equipment_systems = st.session_state.project_data["internal_loads"]["equipment"]
     
+    # Split the display into two columns
     col1, col2 = st.columns([3, 2])
     
     with col1:
@@ -409,24 +431,29 @@ def display_equipment_tab():
     with col2:
         st.subheader("Equipment Editor/Creator")
         
+        # Initialize editor and action states
         if "equipment_editor" not in st.session_state:
             st.session_state.equipment_editor = {}
         if "equipment_action" not in st.session_state:
             st.session_state.equipment_action = {"action": None, "id": None}
         
+        # Get building type for default values
         building_type = st.session_state.project_data["building_info"].get("building_type")
         default_equipment_data = DEFAULT_BUILDING_INTERNALS.get(building_type, DEFAULT_BUILDING_INTERNALS["Other"])["equipment_heat_gains"]
         
+        # Display the editor form
         with st.form("equipment_editor_form", clear_on_submit=True):
             editor_state = st.session_state.get("equipment_editor", {})
             is_edit = editor_state.get("is_edit", False)
             
+            # Equipment name
             name = st.text_input(
                 "Equipment Name",
                 value=editor_state.get("name", ""),
                 help="Enter a unique name for this equipment."
             )
             
+            # Area
             area = st.number_input(
                 "Area (m²)",
                 min_value=1.0,
@@ -436,6 +463,7 @@ def display_equipment_tab():
                 help="Floor area served by this equipment."
             )
             
+            # Heat gains
             st.write("**Heat Gains (W/m²):**")
             col_sens, col_lat = st.columns(2)
             
@@ -459,6 +487,7 @@ def display_equipment_tab():
                     help="Latent heat gain in watts per square meter."
                 )
             
+            # Heat distribution
             st.write("**Heat Distribution:**")
             col_rad, col_conv = st.columns(2)
             
@@ -482,6 +511,7 @@ def display_equipment_tab():
                     help="Fraction of sensible heat released as convection."
                 )
             
+            # Schedule selection
             available_schedules = list(st.session_state.project_data["internal_loads"]["schedules"].keys())
             schedule = st.selectbox(
                 "Schedule",
@@ -490,12 +520,14 @@ def display_equipment_tab():
                 help="Select the equipment schedule."
             )
             
+            # Zone assignment
             zone = st.text_input(
                 "Zone",
                 value=editor_state.get("zone", "Whole Building"),
                 help="Zone or area where this equipment is located."
             )
             
+            # Submit buttons
             col1, col2 = st.columns(2)
             with col1:
                 submit_label = "Update" if is_edit else "Add"
@@ -504,61 +536,62 @@ def display_equipment_tab():
             with col2:
                 refresh = st.form_submit_button("Refresh")
         
-            if submit:
-                action_id = str(uuid.uuid4())
-                if st.session_state.equipment_action.get("id") != action_id:
-                    st.session_state.equipment_action = {"action": "save", "id": action_id}
-                    
-                    if not name.strip():
-                        st.error("Equipment name is required.")
-                        return
-                    if abs(radiative_fraction + convective_fraction - 1.0) > 0.01:
-                        st.error("Radiative and convective fractions must sum to 1.0")
-                        return
-                    existing_names = [system["name"] for system in equipment_systems if not (is_edit and system["name"] == editor_state.get("name"))]
-                    if name.strip() in existing_names:
-                        st.error("Equipment name must be unique.")
-                        return
-                    
-                    equipment_data = {
-                        "id": str(uuid.uuid4()),
-                        "name": name.strip(),
-                        "area": area,
-                        "sensible_gain": sensible_gain,
-                        "latent_gain": latent_gain,
-                        "total_sensible_power": area * sensible_gain,
-                        "total_latent_power": area * latent_gain,
-                        "radiative_fraction": radiative_fraction,
-                        "convective_fraction": convective_fraction,
-                        "schedule": schedule,
-                        "zone": zone
-                    }
-                    
-                    if is_edit:
-                        index = editor_state.get("index", 0)
-                        st.session_state.project_data["internal_loads"]["equipment"][index] = equipment_data
-                        st.success(f"Equipment '{name}' updated!")
-                    else:
-                        st.session_state.project_data["internal_loads"]["equipment"].append(equipment_data)
-                        st.success(f"Equipment '{name}' added!")
-                    
-                    st.session_state.equipment_editor = {}
-                    st.session_state.equipment_action = {"action": None, "id": None}
-                    st.session_state.module_rerun_flags["internal_loads"] = True
-                    st.rerun()
+        # Handle form submission
+        if submit:
+            # Validate inputs
+            if not name.strip():
+                st.error("Equipment name is required.")
+                return
+            if abs(radiative_fraction + convective_fraction - 1.0) > 0.01:
+                st.error("Radiative and convective fractions must sum to 1.0")
+                return
+            # Check for unique name
+            existing_names = [system["name"] for system in equipment_systems if not (is_edit and system["name"] == editor_state.get("name"))]
+            if name.strip() in existing_names:
+                st.error("Equipment name must be unique.")
+                return
             
-            if refresh:
-                action_id = str(uuid.uuid4())
-                if st.session_state.equipment_action.get("id") != action_id:
-                    st.session_state.equipment_action = {"action": "refresh", "id": action_id}
-                    st.session_state.equipment_editor = {}
-                    st.session_state.module_rerun_flags["internal_loads"] = True
-                    st.rerun()
+            # Create equipment data
+            equipment_data = {
+                "id": str(uuid.uuid4()),
+                "name": name.strip(),
+                "area": area,
+                "sensible_gain": sensible_gain,
+                "latent_gain": latent_gain,
+                "total_sensible_power": area * sensible_gain,
+                "total_latent_power": area * latent_gain,
+                "radiative_fraction": radiative_fraction,
+                "convective_fraction": convective_fraction,
+                "schedule": schedule,
+                "zone": zone
+            }
+            
+            # Handle edit mode
+            if is_edit:
+                index = editor_state.get("index", 0)
+                st.session_state.project_data["internal_loads"]["equipment"][index] = equipment_data
+                st.success(f"Equipment '{name}' updated!")
+            else:
+                st.session_state.project_data["internal_loads"]["equipment"].append(equipment_data)
+                st.success(f"Equipment '{name}' added!")
+            
+            # Clear editor state
+            st.session_state.equipment_editor = {}
+            st.session_state.equipment_action = {"action": "save", "id": str(uuid.uuid4())}
+            st.session_state.module_rerun_flags["internal_loads"] = True
+        
+        elif refresh:
+            # Clear editor state
+            st.session_state.equipment_editor = {}
+            st.session_state.equipment_action = {"action": "refresh", "id": str(uuid.uuid4())}
+            st.session_state.module_rerun_flags["internal_loads"] = 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"]
     
+    # Split the display into two columns
     col1, col2 = st.columns([3, 2])
     
     with col1:
@@ -571,24 +604,29 @@ def display_ventilation_infiltration_tab():
     with col2:
         st.subheader("Ventilation/Infiltration 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}
         
+        # 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"])
         
+        # Display the editor form
         with st.form("vent_inf_editor_form", clear_on_submit=True):
             editor_state = st.session_state.get("vent_inf_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"],
@@ -596,6 +634,7 @@ def display_ventilation_infiltration_tab():
                 help="Select whether this is ventilation or infiltration."
             )
             
+            # Area
             area = st.number_input(
                 "Area (m²)",
                 min_value=1.0,
@@ -606,6 +645,7 @@ def display_ventilation_infiltration_tab():
             )
             
             if system_type == "Ventilation":
+                # Ventilation rate
                 ventilation_rate = st.number_input(
                     "Ventilation Rate (L/s·m²)",
                     min_value=0.1,
@@ -616,6 +656,7 @@ def display_ventilation_infiltration_tab():
                 )
                 air_change_rate = 0.0
             else:
+                # Air change rate for infiltration
                 air_change_rate = st.number_input(
                     "Air Change Rate (ACH)",
                     min_value=0.0,
@@ -626,6 +667,7 @@ def display_ventilation_infiltration_tab():
                 )
                 ventilation_rate = 0.0
             
+            # Schedule selection
             available_schedules = list(st.session_state.project_data["internal_loads"]["schedules"].keys())
             schedule = st.selectbox(
                 "Schedule",
@@ -634,12 +676,14 @@ def display_ventilation_infiltration_tab():
                 help="Select the operation schedule for this system."
             )
             
+            # Zone assignment
             zone = st.text_input(
                 "Zone",
                 value=editor_state.get("zone", "Whole Building"),
                 help="Zone or area where this system operates."
             )
             
+            # Submit buttons
             col1, col2 = st.columns(2)
             with col1:
                 submit_label = "Update" if is_edit else "Add"
@@ -648,52 +692,54 @@ def display_ventilation_infiltration_tab():
             with col2:
                 refresh = st.form_submit_button("Refresh")
         
-            if submit:
-                action_id = str(uuid.uuid4())
-                if st.session_state.vent_inf_action.get("id") != action_id:
-                    st.session_state.vent_inf_action = {"action": "save", "id": action_id}
-                    
-                    if not name.strip():
-                        st.error("System name is required.")
-                        return
-                    existing_names = [system["name"] for system in vent_inf_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
-                    
-                    vent_inf_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,
-                        "zone": zone
-                    }
-                    
-                    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!")
-                    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.vent_inf_editor = {}
-                    st.session_state.vent_inf_action = {"action": None, "id": None}
-                    st.session_state.module_rerun_flags["internal_loads"] = True
-                    st.rerun()
+        # 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 vent_inf_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 refresh:
-                action_id = str(uuid.uuid4())
-                if st.session_state.vent_inf_action.get("id") != action_id:
-                    st.session_state.vent_inf_action = {"action": "refresh", "id": action_id}
-                    st.session_state.vent_inf_editor = {}
-                    st.session_state.module_rerun_flags["internal_loads"] = True
-                    st.rerun()
+            # Create ventilation/infiltration data
+            vent_inf_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,
+                "zone": zone
+            }
+            
+            # 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!")
+            else:
+                st.session_state.project_data["internal_loads"]["ventilation_infiltration"].append(vent_inf_data)
+                st.success(f"{system_type} 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.module_rerun_flags["internal_loads"] = 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.module_rerun_flags["internal_loads"] = True
 
 def display_schedules_tab():
+    import streamlit as st
+    import uuid
+
     st.subheader("Schedules Editor")
 
     DEFAULT_STATE = {
@@ -706,6 +752,7 @@ def display_schedules_tab():
         "original_name": ""
     }
 
+    # Initialize schedule_editor and schedule_action if not present
     if "schedule_editor" not in st.session_state:
         st.session_state.schedule_editor = DEFAULT_STATE.copy()
     if "schedule_action" not in st.session_state:
@@ -714,6 +761,7 @@ def display_schedules_tab():
     editor_state = st.session_state.schedule_editor
     schedules = st.session_state.project_data["internal_loads"]["schedules"]
 
+    # Handle template change
     template_options = list(DEFAULT_SCHEDULE_TEMPLATES.keys())
     selected_template = st.selectbox(
         "Select Template",
@@ -723,30 +771,29 @@ def display_schedules_tab():
         help="Choose a base schedule to prefill values."
     )
 
+    # Update sliders only if template changes and not in edit mode
     if selected_template != editor_state.get("template", "None") and not editor_state.get("is_edit"):
-        action_id = str(uuid.uuid4())
-        if st.session_state.schedule_action.get("id") != action_id:
-            st.session_state.schedule_action = {"action": "template_change", "id": action_id}
-            st.session_state.schedule_editor["template"] = selected_template
-            if selected_template != "None":
-                tpl = DEFAULT_SCHEDULE_TEMPLATES[selected_template]
-                st.session_state.schedule_editor["weekday"] = tpl["weekday"]
-                st.session_state.schedule_editor["weekend"] = tpl["weekend"]
-                for hour in range(24):
-                    st.session_state[f"weekday_slider_{hour}_value"] = tpl["weekday"][hour]
-                    st.session_state[f"weekend_slider_{hour}_value"] = tpl["weekend"][hour]
-            else:
-                for hour in range(24):
-                    st.session_state[f"weekday_slider_{hour}_value"] = 0.0
-                    st.session_state[f"weekend_slider_{hour}_value"] = 0.0
-            st.session_state.schedule_action = {"action": None, "id": None}
-            st.session_state.module_rerun_flags["internal_loads"] = True
-            st.rerun()
+        st.session_state.schedule_editor["template"] = selected_template
+        if selected_template != "None":
+            tpl = DEFAULT_SCHEDULE_TEMPLATES[selected_template]
+            st.session_state.schedule_editor["weekday"] = tpl["weekday"]
+            st.session_state.schedule_editor["weekend"] = tpl["weekend"]
+            for hour in range(24):
+                st.session_state[f"weekday_slider_{hour}_value"] = tpl["weekday"][hour]
+                st.session_state[f"weekend_slider_{hour}_value"] = tpl["weekend"][hour]
+        else:
+            for hour in range(24):
+                st.session_state[f"weekday_slider_{hour}_value"] = 0.0
+                st.session_state[f"weekend_slider_{hour}_value"] = 0.0
+        st.session_state.module_rerun_flags["internal_loads"] = True
+        st.rerun()
 
+    # UI FORM for name/description and actions
     with st.form("schedule_form"):
         name = st.text_input("Schedule Name", value=editor_state.get("name", ""))
         description = st.text_area("Description", value=editor_state.get("description", ""))
 
+        # SLIDERS LAYOUT
         st.markdown("### Schedule Sliders")
         col_hour, col_wd, col_we = st.columns([0.4, 2.0, 2.0])
         with col_hour:
@@ -798,6 +845,7 @@ def display_schedules_tab():
                 )
                 weekend_values.append(val)
 
+        # Action Buttons
         col1, col2, col3 = st.columns(3)
         with col1:
             submit_label = "Update Schedule" if editor_state.get("is_edit") else "Save Schedule"
@@ -807,6 +855,7 @@ def display_schedules_tab():
         with col3:
             delete_submitted = st.form_submit_button("Delete Selected Schedule")
 
+        # Saved Schedules Selector
         st.markdown("### Saved Schedules")
         saved_schedule = st.selectbox(
             "Select Saved Schedule",
@@ -815,6 +864,7 @@ def display_schedules_tab():
             help="Select a saved schedule to edit or delete."
         )
 
+        # Save logic
         if submitted:
             action_id = str(uuid.uuid4())
             if st.session_state.schedule_action.get("id") != action_id:
@@ -841,6 +891,7 @@ def display_schedules_tab():
                     st.session_state.module_rerun_flags["internal_loads"] = True
                     st.rerun()
 
+        # Edit logic
         if edit_submitted and saved_schedule:
             action_id = str(uuid.uuid4())
             if st.session_state.schedule_action.get("id") != action_id:
@@ -865,6 +916,7 @@ def display_schedules_tab():
                     st.session_state.module_rerun_flags["internal_loads"] = True
                     st.rerun()
 
+        # Delete logic
         if delete_submitted and saved_schedule:
             action_id = str(uuid.uuid4())
             if st.session_state.schedule_action.get("id") != action_id:
@@ -911,6 +963,7 @@ def is_schedule_in_use(schedule_name: str) -> bool:
 
 def display_people_table(people_groups: List[Dict[str, Any]]):
     """Display people groups in a table format with edit/delete buttons."""
+    # Create column headers
     cols = st.columns([2, 1, 1, 1, 1, 1, 1])
     cols[0].write("**Name**")
     cols[1].write("**Number**")
@@ -920,6 +973,7 @@ def display_people_table(people_groups: List[Dict[str, Any]]):
     cols[5].write("**Edit**")
     cols[6].write("**Delete**")
     
+    # Display each group
     for idx, group in enumerate(people_groups):
         cols = st.columns([2, 1, 1, 1, 1, 1, 1])
         cols[0].write(group["name"])
@@ -928,39 +982,36 @@ def display_people_table(people_groups: List[Dict[str, Any]]):
         cols[3].write(f"{group.get('total_latent_heat', 0):.1f}")
         cols[4].write(group.get("zone", "Unknown"))
         
+        # Edit button
         edit_key = f"edit_people_{group['id']}_{idx}"
         with cols[5].container():
             if st.button("Edit", key=edit_key):
-                action_id = str(uuid.uuid4())
-                if st.session_state.people_action.get("id") != action_id:
-                    st.session_state.people_action = {"action": "edit", "id": action_id}
-                    st.session_state.people_editor = {
-                        "index": idx,
-                        "name": group.get("name", ""),
-                        "num_people": group.get("num_people", 10),
-                        "activity_level": group.get("activity_level", list(PEOPLE_ACTIVITY_LEVELS.keys())[0]),
-                        "clo_summer": group.get("clo_summer", 0.5),
-                        "clo_winter": group.get("clo_winter", 1.0),
-                        "schedule": group.get("schedule", "Continuous"),
-                        "zone": group.get("zone", "Whole Building"),
-                        "is_edit": True
-                    }
-                    st.session_state.module_rerun_flags["internal_loads"] = True
-                    st.rerun()
+                st.session_state.people_editor = {
+                    "index": idx,
+                    "name": group.get("name", ""),
+                    "num_people": group.get("num_people", 10),
+                    "activity_level": group.get("activity_level", list(PEOPLE_ACTIVITY_LEVELS.keys())[0]),
+                    "clo_summer": group.get("clo_summer", 0.5),
+                    "clo_winter": group.get("clo_winter", 1.0),
+                    "schedule": group.get("schedule", "Continuous"),
+                    "zone": group.get("zone", "Whole Building"),
+                    "is_edit": True
+                }
+                st.session_state.people_action = {"action": "edit", "id": str(uuid.uuid4())}
+                st.session_state.module_rerun_flags["internal_loads"] = True
         
+        # Delete button
         delete_key = f"delete_people_{group['id']}_{idx}"
         with cols[6].container():
             if st.button("Delete", key=delete_key):
-                action_id = str(uuid.uuid4())
-                if st.session_state.people_action.get("id") != action_id:
-                    st.session_state.people_action = {"action": "delete", "id": action_id}
-                    st.session_state.project_data["internal_loads"]["people"].pop(idx)
-                    st.success(f"People group '{group['name']}' deleted!")
-                    st.session_state.module_rerun_flags["internal_loads"] = True
-                    st.rerun()
+                st.session_state.project_data["internal_loads"]["people"].pop(idx)
+                st.success(f"People group '{group['name']}' deleted!")
+                st.session_state.people_action = {"action": "delete", "id": str(uuid.uuid4())}
+                st.session_state.module_rerun_flags["internal_loads"] = True
 
 def display_lighting_table(lighting_systems: List[Dict[str, Any]]):
     """Display lighting systems in a table format with edit/delete buttons."""
+    # Create column headers
     cols = st.columns([2, 1, 1, 1, 1, 1, 1])
     cols[0].write("**Name**")
     cols[1].write("**Area (m²)**")
@@ -970,6 +1021,7 @@ def display_lighting_table(lighting_systems: List[Dict[str, Any]]):
     cols[5].write("**Edit**")
     cols[6].write("**Delete**")
     
+    # Display each system
     for idx, system in enumerate(lighting_systems):
         cols = st.columns([2, 1, 1, 1, 1, 1, 1])
         cols[0].write(system["name"])
@@ -978,39 +1030,36 @@ def display_lighting_table(lighting_systems: List[Dict[str, Any]]):
         cols[3].write(f"{system.get('total_power', 0):.1f}")
         cols[4].write(system.get("zone", "Unknown"))
         
+        # Edit button
         edit_key = f"edit_lighting_{system['id']}_{idx}"
         with cols[5].container():
             if st.button("Edit", key=edit_key):
-                action_id = str(uuid.uuid4())
-                if st.session_state.lighting_action.get("id") != action_id:
-                    st.session_state.lighting_action = {"action": "edit", "id": action_id}
-                    st.session_state.lighting_editor = {
-                        "index": idx,
-                        "name": system.get("name", ""),
-                        "area": system.get("area", 100.0),
-                        "lpd": system.get("lpd", 12.0),
-                        "radiative_fraction": system.get("radiative_fraction", 0.4),
-                        "convective_fraction": system.get("convective_fraction", 0.6),
-                        "schedule": system.get("schedule", "Continuous"),
-                        "zone": system.get("zone", "Whole Building"),
-                        "is_edit": True
-                    }
-                    st.session_state.module_rerun_flags["internal_loads"] = True
-                    st.rerun()
+                st.session_state.lighting_editor = {
+                    "index": idx,
+                    "name": system.get("name", ""),
+                    "area": system.get("area", 100.0),
+                    "lpd": system.get("lpd", 12.0),
+                    "radiative_fraction": system.get("radiative_fraction", 0.4),
+                    "convective_fraction": system.get("convective_fraction", 0.6),
+                    "schedule": system.get("schedule", "Continuous"),
+                    "zone": system.get("zone", "Whole Building"),
+                    "is_edit": True
+                }
+                st.session_state.lighting_action = {"action": "edit", "id": str(uuid.uuid4())}
+                st.session_state.module_rerun_flags["internal_loads"] = True
         
+        # Delete button
         delete_key = f"delete_lighting_{system['id']}_{idx}"
         with cols[6].container():
             if st.button("Delete", key=delete_key):
-                action_id = str(uuid.uuid4())
-                if st.session_state.lighting_action.get("id") != action_id:
-                    st.session_state.lighting_action = {"action": "delete", "id": action_id}
-                    st.session_state.project_data["internal_loads"]["lighting"].pop(idx)
-                    st.success(f"Lighting system '{system['name']}' deleted!")
-                    st.session_state.module_rerun_flags["internal_loads"] = True
-                    st.rerun()
+                st.session_state.project_data["internal_loads"]["lighting"].pop(idx)
+                st.success(f"Lighting system '{system['name']}' deleted!")
+                st.session_state.lighting_action = {"action": "delete", "id": str(uuid.uuid4())}
+                st.session_state.module_rerun_flags["internal_loads"] = True
 
 def display_equipment_table(equipment_systems: List[Dict[str, Any]]):
     """Display equipment systems in a table format with edit/delete buttons."""
+    # Create column headers
     cols = st.columns([2, 1, 1, 1, 1, 1, 1])
     cols[0].write("**Name**")
     cols[1].write("**Area (m²)**")
@@ -1020,6 +1069,7 @@ def display_equipment_table(equipment_systems: List[Dict[str, Any]]):
     cols[5].write("**Edit**")
     cols[6].write("**Delete**")
     
+    # Display each system
     for idx, system in enumerate(equipment_systems):
         cols = st.columns([2, 1, 1, 1, 1, 1, 1])
         cols[0].write(system["name"])
@@ -1028,40 +1078,37 @@ def display_equipment_table(equipment_systems: List[Dict[str, Any]]):
         cols[3].write(f"{system.get('total_latent_power', 0):.1f}")
         cols[4].write(system.get("zone", "Unknown"))
         
+        # Edit button
         edit_key = f"edit_equipment_{system['id']}_{idx}"
         with cols[5].container():
             if st.button("Edit", key=edit_key):
-                action_id = str(uuid.uuid4())
-                if st.session_state.equipment_action.get("id") != action_id:
-                    st.session_state.equipment_action = {"action": "edit", "id": action_id}
-                    st.session_state.equipment_editor = {
-                        "index": idx,
-                        "name": system.get("name", ""),
-                        "area": system.get("area", 100.0),
-                        "sensible_gain": system.get("sensible_gain", 10.0),
-                        "latent_gain": system.get("latent_gain", 2.0),
-                        "radiative_fraction": system.get("radiative_fraction", 0.5),
-                        "convective_fraction": system.get("convective_fraction", 0.5),
-                        "schedule": system.get("schedule", "Continuous"),
-                        "zone": system.get("zone", "Whole Building"),
-                        "is_edit": True
-                    }
-                    st.session_state.module_rerun_flags["internal_loads"] = True
-                    st.rerun()
+                st.session_state.equipment_editor = {
+                    "index": idx,
+                    "name": system.get("name", ""),
+                    "area": system.get("area", 100.0),
+                    "sensible_gain": system.get("sensible_gain", 10.0),
+                    "latent_gain": system.get("latent_gain", 2.0),
+                    "radiative_fraction": system.get("radiative_fraction", 0.5),
+                    "convective_fraction": system.get("convective_fraction", 0.5),
+                    "schedule": system.get("schedule", "Continuous"),
+                    "zone": system.get("zone", "Whole Building"),
+                    "is_edit": True
+                }
+                st.session_state.equipment_action = {"action": "edit", "id": str(uuid.uuid4())}
+                st.session_state.module_rerun_flags["internal_loads"] = True
         
+        # Delete button
         delete_key = f"delete_equipment_{system['id']}_{idx}"
         with cols[6].container():
             if st.button("Delete", key=delete_key):
-                action_id = str(uuid.uuid4())
-                if st.session_state.equipment_action.get("id") != action_id:
-                    st.session_state.equipment_action = {"action": "delete", "id": action_id}
-                    st.session_state.project_data["internal_loads"]["equipment"].pop(idx)
-                    st.success(f"Equipment '{system['name']}' deleted!")
-                    st.session_state.module_rerun_flags["internal_loads"] = True
-                    st.rerun()
+                st.session_state.project_data["internal_loads"]["equipment"].pop(idx)
+                st.success(f"Equipment '{system['name']}' deleted!")
+                st.session_state.equipment_action = {"action": "delete", "id": str(uuid.uuid4())}
+                st.session_state.module_rerun_flags["internal_loads"] = 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."""
+    # Create column headers
     cols = st.columns([2, 1, 1, 1, 1, 1, 1])
     cols[0].write("**Name**")
     cols[1].write("**Type**")
@@ -1071,6 +1118,7 @@ def display_ventilation_infiltration_table(vent_inf_systems: List[Dict[str, Any]
     cols[5].write("**Edit**")
     cols[6].write("**Delete**")
     
+    # Display each system
     for idx, system in enumerate(vent_inf_systems):
         cols = st.columns([2, 1, 1, 1, 1, 1, 1])
         cols[0].write(system["name"])
@@ -1080,42 +1128,39 @@ def display_ventilation_infiltration_table(vent_inf_systems: List[Dict[str, Any]
         cols[3].write(rate_info)
         cols[4].write(system.get("zone", "Unknown"))
         
+        # Edit button
         edit_key = f"edit_vent_inf_{system['id']}_{idx}"
         with cols[5].container():
             if st.button("Edit", key=edit_key):
-                action_id = str(uuid.uuid4())
-                if st.session_state.vent_inf_action.get("id") != action_id:
-                    st.session_state.vent_inf_action = {"action": "edit", "id": action_id}
-                    st.session_state.vent_inf_editor = {
-                        "index": idx,
-                        "name": system.get("name", ""),
-                        "system_type": system.get("system_type", "Ventilation"),
-                        "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"),
-                        "zone": system.get("zone", "Whole Building"),
-                        "is_edit": True
-                    }
-                    st.session_state.module_rerun_flags["internal_loads"] = True
-                    st.rerun()
+                st.session_state.vent_inf_editor = {
+                    "index": idx,
+                    "name": system.get("name", ""),
+                    "system_type": system.get("system_type", "Ventilation"),
+                    "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"),
+                    "zone": system.get("zone", "Whole Building"),
+                    "is_edit": True
+                }
+                st.session_state.vent_inf_action = {"action": "edit", "id": str(uuid.uuid4())}
+                st.session_state.module_rerun_flags["internal_loads"] = True
         
+        # Delete button
         delete_key = f"delete_vent_inf_{system['id']}_{idx}"
         with cols[6].container():
             if st.button("Delete", key=delete_key):
-                action_id = str(uuid.uuid4())
-                if st.session_state.vent_inf_action.get("id") != action_id:
-                    st.session_state.vent_inf_action = {"action": "delete", "id": action_id}
-                    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.module_rerun_flags["internal_loads"] = True
-                    st.rerun()
+                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.module_rerun_flags["internal_loads"] = True
 
 def display_schedules_table(schedules: Dict[str, Any]):
     """Display schedules in a table format with edit/delete buttons."""
     if not schedules:
         return
     
+    # Create table data
     table_data = []
     for name, schedule in schedules.items():
         weekday_peak = max(schedule.get("weekday", [0]))
@@ -1131,8 +1176,11 @@ def display_schedules_table(schedules: Dict[str, Any]):
     
     if table_data:
         df = pd.DataFrame(table_data)
+        
+        # Display table
         st.dataframe(df.drop('Actions', axis=1), use_container_width=True)
         
+        # Display action buttons
         st.write("**Actions:**")
         for i, row in enumerate(table_data):
             schedule_name = row["Actions"]
@@ -1144,37 +1192,22 @@ def display_schedules_table(schedules: Dict[str, Any]):
             
             with col2:
                 if st.button("View", key=f"view_schedule_{schedule_name}_{i}"):
-                    action_id = str(uuid.uuid4())
-                    if st.session_state.schedule_action.get("id") != action_id:
-                        st.session_state.schedule_action = {"action": "view", "id": action_id}
-                        schedule_data = schedules[schedule_name]
-                        display_schedule_chart(schedule_name, schedule_data)
-                        st.session_state.schedule_action = {"action": None, "id": None}
-                        st.session_state.module_rerun_flags["internal_loads"] = True
-                        st.rerun()
+                    schedule_data = schedules[schedule_name]
+                    display_schedule_chart(schedule_name, schedule_data)
             
             with col3:
                 if st.button("Edit", key=f"edit_schedule_{schedule_name}_{i}"):
-                    action_id = str(uuid.uuid4())
-                    if st.session_state.schedule_action.get("id") != action_id:
-                        st.session_state.schedule_action = {"action": "edit", "id": action_id}
-                        if schedule_name in DEFAULT_SCHEDULE_TEMPLATES:
-                            st.error("Default schedules cannot be edited.")
-                        else:
-                            schedule_data = schedules[schedule_name]
-                            st.session_state.schedule_editor = {
-                                "is_edit": True,
-                                "original_name": schedule_name,
-                                "name": schedule_name,
-                                "description": schedule_data.get("description", ""),
-                                "weekday": schedule_data.get("weekday", [0.0] * 24),
-                                "weekend": schedule_data.get("weekend", [0.0] * 24)
-                            }
-                            for hour in range(24):
-                                st.session_state[f"weekday_slider_{hour}_value"] = schedule_data.get("weekday", [0.0] * 24)[hour]
-                                st.session_state[f"weekend_slider_{hour}_value"] = schedule_data.get("weekend", [0.0] * 24)[hour]
-                            st.session_state.module_rerun_flags["internal_loads"] = True
-                            st.rerun()
+                    schedule_data = schedules[schedule_name]
+                    st.session_state.schedule_editor = {
+                        "is_edit": True,
+                        "original_name": schedule_name,
+                        "name": schedule_name,
+                        "description": schedule_data.get("description", ""),
+                        "weekday": schedule_data.get("weekday", [0.0] * 24),
+                        "weekend": schedule_data.get("weekend", [0.0] * 24)
+                    }
+                    st.session_state.module_rerun_flags["internal_loads"] = True
+                    st.rerun()
             
             with col4:
                 if schedule_name not in DEFAULT_SCHEDULE_TEMPLATES:
@@ -1182,12 +1215,9 @@ def display_schedules_table(schedules: Dict[str, Any]):
                         st.write("(In Use)")
                     else:
                         if st.button("Delete", key=f"delete_schedule_{schedule_name}_{i}"):
-                            action_id = str(uuid.uuid4())
-                            if st.session_state.schedule_action.get("id") != action_id:
-                                st.session_state.schedule_action = {"action": "delete", "id": action_id}
-                                del schedules[schedule_name]
-                                st.success(f"Schedule '{schedule_name}' deleted!")
-                                st.session_state.module_rerun_flags["internal_loads"] = True
-                                st.rerun()
+                            del schedules[schedule_name]
+                            st.success(f"Schedule '{schedule_name}' deleted!")
+                            st.session_state.module_rerun_flags["internal_loads"] = True
+                            st.rerun()
                 else:
                     st.write("(Default)")