Update app/internal_loads.py

app/internal_loads.py

@@ -80,13 +80,11 @@ def display_internal_loads_page():
     with col1:
         if st.button("Back to Building Components", key="back_to_components"):
             st.session_state.current_page = "Building Components"
-            st.session_state.module_rerun_flags["internal_loads"] = True
             st.rerun()
     
     with col2:
         if st.button("Continue to HVAC Loads", key="continue_to_hvac_loads"):
             st.session_state.current_page = "HVAC Loads"
-            st.session_state.module_rerun_flags["internal_loads"] = True
             st.rerun()
 
 def initialize_internal_loads():
@@ -105,11 +103,9 @@ def initialize_internal_loads():
         }
 
 def display_people_tab():
-    """Display the people tab content with a two-column layout and fixed button logic."""
-    # Get people from session state
+    """Display the people tab content with a two-column layout similar to components.py."""
     people_groups = st.session_state.project_data["internal_loads"]["people"]
     
-    # Split the display into two columns
     col1, col2 = st.columns([3, 2])
     
     with col1:
@@ -122,29 +118,21 @@ 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}
         
-        # Check if an action is pending
-        current_action = st.session_state.people_action
-        action_id = current_action.get("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,
@@ -153,7 +141,6 @@ def display_people_tab():
                 help="Number of people in this group."
             )
             
-            # Activity level
             activity_level = st.selectbox(
                 "Activity Level",
                 list(PEOPLE_ACTIVITY_LEVELS.keys()),
@@ -161,7 +148,6 @@ 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)
             
@@ -185,7 +171,6 @@ 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",
@@ -194,14 +179,12 @@ 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"
@@ -210,69 +193,64 @@ def display_people_tab():
             with col2:
                 refresh = st.form_submit_button("Refresh")
         
-        # Handle form submission
-        if submit and current_action["action"] != "submit":
-            new_action_id = str(uuid.uuid4())
-            st.session_state.people_action = {"action": "submit", "id": new_action_id}
-            
-            # Validate inputs
-            if not name.strip():
-                st.error("Group name is required.")
-                st.session_state.people_action = {"action": None, "id": None}
-                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.")
-                st.session_state.people_action = {"action": None, "id": None}
-                return
-            
-            # 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!")
+            # 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()
             
-            # Clear editor and action states
-            st.session_state.people_editor = {}
-            st.session_state.people_action = {"action": None, "id": None}
-            st.session_state.module_rerun_flags["internal_loads"] = True
-        
-        elif refresh and current_action["action"] != "refresh":
-            new_action_id = str(uuid.uuid4())
-            st.session_state.people_action = {"action": "refresh", "id": new_action_id}
-            st.session_state.people_editor = {}
-            st.session_state.people_action = {"action": None, "id": None}
-            st.session_state.module_rerun_flags["internal_loads"] = True
+            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()
 
 def display_lighting_tab():
-    """Display the lighting tab content with a two-column layout and fixed button logic."""
-    # Get lighting from session state
+    """Display the lighting tab content with a two-column layout similar to components.py."""
     lighting_systems = st.session_state.project_data["internal_loads"]["lighting"]
     
-    # Split the display into two columns
     col1, col2 = st.columns([3, 2])
     
     with col1:
@@ -285,33 +263,24 @@ 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}
         
-        # Check if an action is pending
-        current_action = st.session_state.lighting_action
-        action_id = current_action.get("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,
@@ -321,7 +290,6 @@ 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,
@@ -331,7 +299,6 @@ 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)
             
@@ -355,7 +322,6 @@ 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",
@@ -364,14 +330,12 @@ 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"
@@ -380,66 +344,59 @@ def display_lighting_tab():
             with col2:
                 refresh = st.form_submit_button("Refresh")
         
-        # Handle form submission
-        if submit and current_action["action"] != "submit":
-            new_action_id = str(uuid.uuid4())
-            st.session_state.lighting_action = {"action": "submit", "id": new_action_id}
-            
-            # Validate inputs
-            if not name.strip():
-                st.error("System name is required.")
-                st.session_state.lighting_action = {"action": None, "id": None}
-                return
-            if abs(radiative_fraction + convective_fraction - 1.0) > 0.01:
-                st.error("Radiative and convective fractions must sum to 1.0")
-                st.session_state.lighting_action = {"action": None, "id": None}
-                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.")
-                st.session_state.lighting_action = {"action": None, "id": None}
-                return
-            
-            # 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!")
+            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()
             
-            # Clear editor and action states
-            st.session_state.lighting_editor = {}
-            st.session_state.lighting_action = {"action": None, "id": None}
-            st.session_state.module_rerun_flags["internal_loads"] = True
-        
-        elif refresh and current_action["action"] != "refresh":
-            new_action_id = str(uuid.uuid4())
-            st.session_state.lighting_action = {"action": "refresh", "id": new_action_id}
-            st.session_state.lighting_editor = {}
-            st.session_state.lighting_action = {"action": None, "id": None}
-            st.session_state.module_rerun_flags["internal_loads"] = True
+            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()
 
 def display_equipment_tab():
-    """Display the equipment tab content with a two-column layout and fixed button logic."""
-    # Get equipment from session state
+    """Display the equipment tab content with a two-column layout similar to components.py."""
     equipment_systems = st.session_state.project_data["internal_loads"]["equipment"]
     
-    # Split the display into two columns
     col1, col2 = st.columns([3, 2])
     
     with col1:
@@ -452,33 +409,24 @@ 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}
         
-        # Check if an action is pending
-        current_action = st.session_state.equipment_action
-        action_id = current_action.get("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,
@@ -488,7 +436,6 @@ 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)
             
@@ -512,7 +459,6 @@ 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)
             
@@ -536,7 +482,6 @@ 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",
@@ -545,14 +490,12 @@ 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"
@@ -561,68 +504,61 @@ def display_equipment_tab():
             with col2:
                 refresh = st.form_submit_button("Refresh")
         
-        # Handle form submission
-        if submit and current_action["action"] != "submit":
-            new_action_id = str(uuid.uuid4())
-            st.session_state.equipment_action = {"action": "submit", "id": new_action_id}
-            
-            # Validate inputs
-            if not name.strip():
-                st.error("Equipment name is required.")
-                st.session_state.equipment_action = {"action": None, "id": None}
-                return
-            if abs(radiative_fraction + convective_fraction - 1.0) > 0.01:
-                st.error("Radiative and convective fractions must sum to 1.0")
-                st.session_state.equipment_action = {"action": None, "id": None}
-                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.")
-                st.session_state.equipment_action = {"action": None, "id": None}
-                return
-            
-            # 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!")
+            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()
             
-            # Clear editor and action states
-            st.session_state.equipment_editor = {}
-            st.session_state.equipment_action = {"action": None, "id": None}
-            st.session_state.module_rerun_flags["internal_loads"] = True
-        
-        elif refresh and current_action["action"] != "refresh":
-            new_action_id = str(uuid.uuid4())
-            st.session_state.equipment_action = {"action": "refresh", "id": new_action_id}
-            st.session_state.equipment_editor = {}
-            st.session_state.equipment_action = {"action": None, "id": None}
-            st.session_state.module_rerun_flags["internal_loads"] = True
+            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()
 
 def display_ventilation_infiltration_tab():
-    """Display the ventilation/infiltration tab content with a two-column layout and fixed button logic."""
-    # Get ventilation/infiltration from session state
+    """Display the ventilation/infiltration tab content with a two-column layout similar to components.py."""
     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:
@@ -635,33 +571,24 @@ 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}
         
-        # Check if an action is pending
-        current_action = st.session_state.vent_inf_action
-        action_id = current_action.get("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"],
@@ -669,7 +596,6 @@ def display_ventilation_infiltration_tab():
                 help="Select whether this is ventilation or infiltration."
             )
             
-            # Area
             area = st.number_input(
                 "Area (m²)",
                 min_value=1.0,
@@ -700,7 +626,6 @@ 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",
@@ -709,14 +634,12 @@ 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"
@@ -725,59 +648,54 @@ def display_ventilation_infiltration_tab():
             with col2:
                 refresh = st.form_submit_button("Refresh")
         
-        # Handle form submission
-        if submit and current_action["action"] != "submit":
-            new_action_id = str(uuid.uuid4())
-            st.session_state.vent_inf_action = {"action": "submit", "id": new_action_id}
-            
-            # Validate inputs
-            if not name.strip():
-                st.error("System name is required.")
-                st.session_state.vent_inf_action = {"action": None, "id": None}
-                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.")
-                st.session_state.vent_inf_action = {"action": None, "id": None}
-                return
-            
-            # 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!")
+            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()
             
-            # Clear editor and action states
-            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
-        
-        elif refresh and current_action["action"] != "refresh":
-            new_action_id = str(uuid.uuid4())
-            st.session_state.vent_inf_action = {"action": "refresh", "id": new_action_id}
-            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
+            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()
 
 def display_schedules_tab():
-    """Display the schedules tab content with fixed button logic."""
     st.subheader("Schedules Editor")
-    
+
     DEFAULT_STATE = {
         "name": "",
         "description": "",
@@ -787,21 +705,15 @@ def display_schedules_tab():
         "is_edit": False,
         "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:
         st.session_state.schedule_action = {"action": None, "id": None}
-    
-    # Check if an action is pending
-    current_action = st.session_state.schedule_action
-    action_id = current_action.get("id", None)
-    
+
     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",
@@ -810,33 +722,31 @@ def display_schedules_tab():
         if editor_state.get("template") in template_options else 0,
         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") and current_action["action"] != "template_change":
-        new_action_id = str(uuid.uuid4())
-        st.session_state.schedule_action = {"action": "template_change", "id": new_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()
-    
-    # UI FORM for name/description and actions
-    with st.form("schedule_form", clear_on_submit=True):
+
+    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()
+
+    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:
@@ -845,7 +755,7 @@ def display_schedules_tab():
             st.markdown("<div style='text-align:center; font-weight:bold; font-size:18px;'>Weekday</div>", unsafe_allow_html=True)
         with col_we:
             st.markdown("<div style='text-align:center; font-weight:bold; font-size:18px;'>Weekend</div>", unsafe_allow_html=True)
-        
+
         hide_elements = """
             <style>
                 div[data-testid="stSliderTickBarMin"],
@@ -855,10 +765,10 @@ def display_schedules_tab():
             </style>
         """
         st.markdown(hide_elements, unsafe_allow_html=True)
-        
+
         weekday_values = []
         weekend_values = []
-        
+
         for hour in range(24):
             col_hour, col_wd, col_we = st.columns([0.4, 2.0, 2.0])
             with col_hour:
@@ -887,8 +797,7 @@ def display_schedules_tab():
                     format=None
                 )
                 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"
@@ -897,8 +806,7 @@ def display_schedules_tab():
             edit_submitted = st.form_submit_button("Edit Selected Schedule")
         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",
@@ -906,79 +814,75 @@ def display_schedules_tab():
             index=list(schedules.keys()).index(editor_state.get("name", list(schedules.keys())[0])) if editor_state.get("name") in schedules and schedules else 0,
             help="Select a saved schedule to edit or delete."
         )
-        
-        # Save logic
-        if submitted and current_action["action"] != "submit":
-            new_action_id = str(uuid.uuid4())
-            st.session_state.schedule_action = {"action": "submit", "id": new_action_id}
-            if not name.strip():
-                st.error("Schedule name is required.")
-                st.session_state.schedule_action = {"action": None, "id": None}
-                return
-            if name in schedules and not editor_state.get("is_edit"):
-                st.error("A schedule with this name already exists.")
-                st.session_state.schedule_action = {"action": None, "id": None}
-                return
-            schedules[name] = {
-                "description": description,
-                "weekday": weekday_values,
-                "weekend": weekend_values
-            }
-            if editor_state.get("is_edit") and editor_state.get("original_name") and editor_state.get("original_name") != name:
-                if editor_state["original_name"] in schedules:
-                    del schedules[editor_state["original_name"]]
-            st.session_state.schedule_editor = DEFAULT_STATE.copy()
-            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.success(f"Schedule '{name}' saved successfully!")
-            st.session_state.schedule_action = {"action": None, "id": None}
-            st.session_state.module_rerun_flags["internal_loads"] = True
-        
-        # Edit logic
-        elif edit_submitted and saved_schedule and current_action["action"] != "edit":
-            new_action_id = str(uuid.uuid4())
-            st.session_state.schedule_action = {"action": "edit", "id": new_action_id}
-            if saved_schedule in DEFAULT_SCHEDULE_TEMPLATES:
-                st.error("Default schedules cannot be edited.")
-                st.session_state.schedule_action = {"action": None, "id": None}
-                return
-            schedule_data = schedules[saved_schedule]
-            st.session_state.schedule_editor = {
-                "is_edit": True,
-                "original_name": saved_schedule,
-                "name": saved_schedule,
-                "description": schedule_data.get("description", ""),
-                "weekday": schedule_data.get("weekday", [0.0] * 24),
-                "weekend": schedule_data.get("weekend", [0.0] * 24),
-                "template": "None"
-            }
-            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.schedule_action = {"action": None, "id": None}
-            st.session_state.module_rerun_flags["internal_loads"] = True
-        
-        # Delete logic
-        elif delete_submitted and saved_schedule and current_action["action"] != "delete":
-            new_action_id = str(uuid.uuid4())
-            st.session_state.schedule_action = {"action": "delete", "id": new_action_id}
-            if saved_schedule in DEFAULT_SCHEDULE_TEMPLATES:
-                st.error("Default schedules cannot be deleted.")
-                st.session_state.schedule_action = {"action": None, "id": None}
-                return
-            if is_schedule_in_use(saved_schedule):
-                st.error(f"Schedule '{saved_schedule}' is in use and cannot be deleted.")
-                st.session_state.schedule_action = {"action": None, "id": None}
-                return
-            del schedules[saved_schedule]
-            st.session_state.schedule_editor = DEFAULT_STATE.copy()
-            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.success(f"Schedule '{saved_schedule}' deleted!")
-            st.session_state.schedule_action = {"action": None, "id": None}
-            st.session_state.module_rerun_flags["internal_loads"] = True
+
+        if submitted:
+            action_id = str(uuid.uuid4())
+            if st.session_state.schedule_action.get("id") != action_id:
+                st.session_state.schedule_action = {"action": "save", "id": action_id}
+                if not name.strip():
+                    st.error("Schedule name is required.")
+                elif name in schedules and not editor_state.get("is_edit"):
+                    st.error("A schedule with this name already exists.")
+                else:
+                    schedules[name] = {
+                        "description": description,
+                        "weekday": weekday_values,
+                        "weekend": weekend_values
+                    }
+                    if editor_state.get("is_edit") and editor_state.get("original_name") and editor_state.get("original_name") != name:
+                        if editor_state["original_name"] in schedules:
+                            del schedules[editor_state["original_name"]]
+                    st.session_state.schedule_editor = DEFAULT_STATE.copy()
+                    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.success(f"Schedule '{name}' saved successfully.")
+                    st.session_state.schedule_action = {"action": None, "id": None}
+                    st.session_state.module_rerun_flags["internal_loads"] = True
+                    st.rerun()
+
+        if edit_submitted and saved_schedule:
+            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 saved_schedule in DEFAULT_SCHEDULE_TEMPLATES:
+                    st.error("Default schedules cannot be edited.")
+                else:
+                    schedule_data = schedules[saved_schedule]
+                    st.session_state.schedule_editor = {
+                        "is_edit": True,
+                        "original_name": saved_schedule,
+                        "name": saved_schedule,
+                        "description": schedule_data.get("description", ""),
+                        "weekday": schedule_data.get("weekday", [0.0] * 24),
+                        "weekend": schedule_data.get("weekend", [0.0] * 24),
+                        "template": "None"
+                    }
+                    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.schedule_action = {"action": None, "id": None}
+                    st.session_state.module_rerun_flags["internal_loads"] = True
+                    st.rerun()
+
+        if delete_submitted and saved_schedule:
+            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}
+                if saved_schedule in DEFAULT_SCHEDULE_TEMPLATES:
+                    st.error("Default schedules cannot be deleted.")
+                elif is_schedule_in_use(saved_schedule):
+                    st.error(f"Schedule '{saved_schedule}' is in use and cannot be deleted.")
+                else:
+                    del schedules[saved_schedule]
+                    st.session_state.schedule_editor = DEFAULT_STATE.copy()
+                    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.success(f"Schedule '{saved_schedule}' deleted!")
+                    st.session_state.schedule_action = {"action": None, "id": None}
+                    st.session_state.module_rerun_flags["internal_loads"] = True
+                    st.rerun()
 
 def is_schedule_in_use(schedule_name: str) -> bool:
     """
@@ -1006,8 +910,7 @@ def is_schedule_in_use(schedule_name: str) -> bool:
     return False
 
 def display_people_table(people_groups: List[Dict[str, Any]]):
-    """Display people groups in a table format with fixed edit/delete button logic."""
-    # Create column headers
+    """Display people groups in a table format with edit/delete buttons."""
     cols = st.columns([2, 1, 1, 1, 1, 1, 1])
     cols[0].write("**Name**")
     cols[1].write("**Number**")
@@ -1017,11 +920,6 @@ def display_people_table(people_groups: List[Dict[str, Any]]):
     cols[5].write("**Edit**")
     cols[6].write("**Delete**")
     
-    # Check if an action is pending
-    current_action = st.session_state.people_action
-    action_id = current_action.get("id", None)
-    
-    # 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"])
@@ -1030,40 +928,39 @@ 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) and current_action["action"] != "edit":
-                new_action_id = str(uuid.uuid4())
-                st.session_state.people_action = {"action": "edit", "id": new_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.people_action = {"action": None, "id": None}
-                st.session_state.module_rerun_flags["internal_loads"] = True
+            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()
         
-        # Delete button
         delete_key = f"delete_people_{group['id']}_{idx}"
         with cols[6].container():
-            if st.button("Delete", key=delete_key) and current_action["action"] != "delete":
-                new_action_id = str(uuid.uuid4())
-                st.session_state.people_action = {"action": "delete", "id": new_action_id}
-                st.session_state.project_data["internal_loads"]["people"].pop(idx)
-                st.success(f"People group '{group['name']}' deleted!")
-                st.session_state.people_action = {"action": None, "id": None}
-                st.session_state.module_rerun_flags["internal_loads"] = True
+            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()
 
 def display_lighting_table(lighting_systems: List[Dict[str, Any]]):
-    """Display lighting systems in a table format with fixed edit/delete button logic."""
-    # Create column headers
+    """Display lighting systems in a table format with edit/delete buttons."""
     cols = st.columns([2, 1, 1, 1, 1, 1, 1])
     cols[0].write("**Name**")
     cols[1].write("**Area (m²)**")
@@ -1073,11 +970,6 @@ def display_lighting_table(lighting_systems: List[Dict[str, Any]]):
     cols[5].write("**Edit**")
     cols[6].write("**Delete**")
     
-    # Check if an action is pending
-    current_action = st.session_state.lighting_action
-    action_id = current_action.get("id", None)
-    
-    # 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"])
@@ -1086,40 +978,39 @@ 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) and current_action["action"] != "edit":
-                new_action_id = str(uuid.uuid4())
-                st.session_state.lighting_action = {"action": "edit", "id": new_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.lighting_action = {"action": None, "id": None}
-                st.session_state.module_rerun_flags["internal_loads"] = True
+            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()
         
-        # Delete button
         delete_key = f"delete_lighting_{system['id']}_{idx}"
         with cols[6].container():
-            if st.button("Delete", key=delete_key) and current_action["action"] != "delete":
-                new_action_id = str(uuid.uuid4())
-                st.session_state.lighting_action = {"action": "delete", "id": new_action_id}
-                st.session_state.project_data["internal_loads"]["lighting"].pop(idx)
-                st.success(f"Lighting system '{system['name']}' deleted!")
-                st.session_state.lighting_action = {"action": None, "id": None}
-                st.session_state.module_rerun_flags["internal_loads"] = True
+            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()
 
 def display_equipment_table(equipment_systems: List[Dict[str, Any]]):
-    """Display equipment systems in a table format with fixed edit/delete button logic."""
-    # Create column headers
+    """Display equipment systems in a table format with edit/delete buttons."""
     cols = st.columns([2, 1, 1, 1, 1, 1, 1])
     cols[0].write("**Name**")
     cols[1].write("**Area (m²)**")
@@ -1129,11 +1020,6 @@ def display_equipment_table(equipment_systems: List[Dict[str, Any]]):
     cols[5].write("**Edit**")
     cols[6].write("**Delete**")
     
-    # Check if an action is pending
-    current_action = st.session_state.equipment_action
-    action_id = current_action.get("id", None)
-    
-    # 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"])
@@ -1142,41 +1028,40 @@ 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) and current_action["action"] != "edit":
-                new_action_id = str(uuid.uuid4())
-                st.session_state.equipment_action = {"action": "edit", "id": new_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.equipment_action = {"action": None, "id": None}
-                st.session_state.module_rerun_flags["internal_loads"] = True
+            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()
         
-        # Delete button
         delete_key = f"delete_equipment_{system['id']}_{idx}"
         with cols[6].container():
-            if st.button("Delete", key=delete_key) and current_action["action"] != "delete":
-                new_action_id = str(uuid.uuid4())
-                st.session_state.equipment_action = {"action": "delete", "id": new_action_id}
-                st.session_state.project_data["internal_loads"]["equipment"].pop(idx)
-                st.success(f"Equipment '{system['name']}' deleted!")
-                st.session_state.equipment_action = {"action": None, "id": None}
-                st.session_state.module_rerun_flags["internal_loads"] = True
+            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()
 
 def display_ventilation_infiltration_table(vent_inf_systems: List[Dict[str, Any]]):
-    """Display ventilation/infiltration systems in a table format with fixed edit/delete button logic."""
-    # Create column headers
+    """Display ventilation/infiltration systems in a table format with edit/delete buttons."""
     cols = st.columns([2, 1, 1, 1, 1, 1, 1])
     cols[0].write("**Name**")
     cols[1].write("**Type**")
@@ -1186,11 +1071,6 @@ def display_ventilation_infiltration_table(vent_inf_systems: List[Dict[str, Any]
     cols[5].write("**Edit**")
     cols[6].write("**Delete**")
     
-    # Check if an action is pending
-    current_action = st.session_state.vent_inf_action
-    action_id = current_action.get("id", None)
-    
-    # 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"])
@@ -1200,43 +1080,42 @@ 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) and current_action["action"] != "edit":
-                new_action_id = str(uuid.uuid4())
-                st.session_state.vent_inf_action = {"action": "edit", "id": new_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.vent_inf_action = {"action": None, "id": None}
-                st.session_state.module_rerun_flags["internal_loads"] = True
+            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()
         
-        # Delete button
         delete_key = f"delete_vent_inf_{system['id']}_{idx}"
         with cols[6].container():
-            if st.button("Delete", key=delete_key) and current_action["action"] != "delete":
-                new_action_id = str(uuid.uuid4())
-                st.session_state.vent_inf_action = {"action": "delete", "id": new_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.vent_inf_action = {"action": None, "id": None}
-                st.session_state.module_rerun_flags["internal_loads"] = True
+            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()
 
 def display_schedules_table(schedules: Dict[str, Any]):
-    """Display schedules in a table format with fixed edit/delete button logic."""
+    """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]))
@@ -1252,15 +1131,8 @@ 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)
         
-        # Check if an action is pending
-        current_action = st.session_state.schedule_action
-        action_id = current_action.get("id", None)
-        
-        # Display action buttons
         st.write("**Actions:**")
         for i, row in enumerate(table_data):
             schedule_name = row["Actions"]
@@ -1271,44 +1143,51 @@ def display_schedules_table(schedules: Dict[str, Any]):
                 st.write(f"{i+1}. {schedule_name}")
             
             with col2:
-                view_key = f"view_schedule_{schedule_name}_{i}"
-                if st.button("View", key=view_key) and current_action["action"] != "view":
-                    new_action_id = str(uuid.uuid4())
-                    st.session_state.schedule_action = {"action": "view", "id": new_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
+                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()
             
             with col3:
-                edit_key = f"edit_schedule_{schedule_name}_{i}"
-                if st.button("Edit", key=edit_key) and current_action["action"] != "edit":
-                    new_action_id = str(uuid.uuid4())
-                    st.session_state.schedule_action = {"action": "edit", "id": new_action_id}
-                    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.schedule_action = {"action": None, "id": None}
-                    st.session_state.module_rerun_flags["internal_loads"] = True
+                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()
             
             with col4:
                 if schedule_name not in DEFAULT_SCHEDULE_TEMPLATES:
                     if is_schedule_in_use(schedule_name):
                         st.write("(In Use)")
                     else:
-                        delete_key = f"delete_schedule_{schedule_name}_{i}"
-                        if st.button("Delete", key=delete_key) and current_action["action"] != "delete":
-                            new_action_id = str(uuid.uuid4())
-                            st.session_state.schedule_action = {"action": "delete", "id": new_action_id}
-                            del schedules[schedule_name]
-                            st.success(f"Schedule '{schedule_name}' deleted!")
-                            st.session_state.schedule_action = {"action": None, "id": None}
-                            st.session_state.module_rerun_flags["internal_loads"] = True
+                        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()
                 else:
                     st.write("(Default)")