Update app/construction.py

app/construction.py

@@ -18,6 +18,9 @@ import logging
 import uuid
 from typing import Dict, List, Any, Optional, Tuple, Union
 
+# Import the centralized data module
+from app.m_c_data import get_default_constructions
+
 # Configure logging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
@@ -25,169 +28,13 @@ logger = logging.getLogger(__name__)
 # Define constants
 CONSTRUCTION_TYPES = ["Wall", "Roof", "Floor"]
 
-# Default library constructions
-DEFAULT_CONSTRUCTIONS = {
-    "Brick Cavity Wall": {
-        "type": "Wall",
-        "layers": [
-            {"material": "Brick", "thickness": 0.1},
-            {"material": "Air Gap", "thickness": 0.05},
-            {"material": "Mineral Wool", "thickness": 0.1},
-            {"material": "Concrete Block", "thickness": 0.1},
-            {"material": "Gypsum Board", "thickness": 0.0125}
-        ],
-        "u_value": 0.35,  # W/m²·K
-        "r_value": 2.86,  # m²·K/W
-        "thermal_mass": 220.0,  # kJ/m²·K
-        "embodied_carbon": 120.0,  # kg CO2e/m²
-        "cost": 180.0  # USD/m²
-    },
-    "Insulated Concrete Wall": {
-        "type": "Wall",
-        "layers": [
-            {"material": "Concrete", "thickness": 0.15},
-            {"material": "EPS Insulation", "thickness": 0.1},
-            {"material": "Gypsum Board", "thickness": 0.0125}
-        ],
-        "u_value": 0.32,
-        "r_value": 3.13,
-        "thermal_mass": 360.0,
-        "embodied_carbon": 95.0,
-        "cost": 150.0
-    },
-    "Timber Frame Wall": {
-        "type": "Wall",
-        "layers": [
-            {"material": "Wood (Pine)", "thickness": 0.02},
-            {"material": "Glass Fiber Insulation", "thickness": 0.15},
-            {"material": "Plywood", "thickness": 0.012},
-            {"material": "Gypsum Board", "thickness": 0.0125}
-        ],
-        "u_value": 0.25,
-        "r_value": 4.0,
-        "thermal_mass": 45.0,
-        "embodied_carbon": 35.0,
-        "cost": 120.0
-    },
-    "Concrete Flat Roof": {
-        "type": "Roof",
-        "layers": [
-            {"material": "Concrete", "thickness": 0.15},
-            {"material": "Polyurethane Insulation", "thickness": 0.15},
-            {"material": "Waterproofing Membrane", "thickness": 0.005}
-        ],
-        "u_value": 0.18,
-        "r_value": 5.56,
-        "thermal_mass": 360.0,
-        "embodied_carbon": 110.0,
-        "cost": 200.0
-    },
-    "Timber Pitched Roof": {
-        "type": "Roof",
-        "layers": [
-            {"material": "Roof Tiles", "thickness": 0.02},
-            {"material": "Waterproofing Membrane", "thickness": 0.002},
-            {"material": "Wood (Pine)", "thickness": 0.025},
-            {"material": "Glass Fiber Insulation", "thickness": 0.2},
-            {"material": "Gypsum Board", "thickness": 0.0125}
-        ],
-        "u_value": 0.16,
-        "r_value": 6.25,
-        "thermal_mass": 40.0,
-        "embodied_carbon": 45.0,
-        "cost": 160.0
-    },
-    "Concrete Floor Slab": {
-        "type": "Floor",
-        "layers": [
-            {"material": "Ceramic Tile", "thickness": 0.01},
-            {"material": "Concrete", "thickness": 0.1},
-            {"material": "EPS Insulation", "thickness": 0.1},
-            {"material": "Damp Proof Membrane", "thickness": 0.002},
-            {"material": "Gravel", "thickness": 0.15}
-        ],
-        "u_value": 0.25,
-        "r_value": 4.0,
-        "thermal_mass": 240.0,
-        "embodied_carbon": 85.0,
-        "cost": 140.0
-    },
-    "Timber Floor": {
-        "type": "Floor",
-        "layers": [
-            {"material": "Wood (Pine)", "thickness": 0.02},
-            {"material": "Air Gap", "thickness": 0.05},
-            {"material": "Glass Fiber Insulation", "thickness": 0.15},
-            {"material": "Plywood", "thickness": 0.018}
-        ],
-        "u_value": 0.22,
-        "r_value": 4.55,
-        "thermal_mass": 30.0,
-        "embodied_carbon": 25.0,
-        "cost": 110.0
-    }
-}
-
-# Additional materials needed for constructions but not in material library
-ADDITIONAL_MATERIALS = {
-    "Air Gap": {
-        "category": "Sub-Structural Materials",
-        "thermal_conductivity": 0.026,
-        "density": 1.2,
-        "specific_heat": 1000.0,
-        "thickness_range": [0.01, 0.1],
-        "default_thickness": 0.05,
-        "embodied_carbon": 0.0,
-        "cost": 0.0
-    },
-    "Waterproofing Membrane": {
-        "category": "Finishing Materials",
-        "thermal_conductivity": 0.17,
-        "density": 1100.0,
-        "specific_heat": 1000.0,
-        "thickness_range": [0.001, 0.01],
-        "default_thickness": 0.002,
-        "embodied_carbon": 4.2,
-        "cost": 15.0
-    },
-    "Damp Proof Membrane": {
-        "category": "Sub-Structural Materials",
-        "thermal_conductivity": 0.17,
-        "density": 1100.0,
-        "specific_heat": 1000.0,
-        "thickness_range": [0.001, 0.005],
-        "default_thickness": 0.002,
-        "embodied_carbon": 4.0,
-        "cost": 12.0
-    },
-    "Roof Tiles": {
-        "category": "Finishing Materials",
-        "thermal_conductivity": 1.0,
-        "density": 1900.0,
-        "specific_heat": 800.0,
-        "thickness_range": [0.01, 0.03],
-        "default_thickness": 0.02,
-        "embodied_carbon": 110.0,
-        "cost": 75.0
-    },
-    "Gravel": {
-        "category": "Sub-Structural Materials",
-        "thermal_conductivity": 0.7,
-        "density": 1800.0,
-        "specific_heat": 840.0,
-        "thickness_range": [0.05, 0.3],
-        "default_thickness": 0.15,
-        "embodied_carbon": 1.5,
-        "cost": 30.0
-    }
-}
-
 def display_construction_page():
     """
     Display the construction page.
     This is the main function called by main.py when the Construction page is selected.
     """
     st.title("Construction Library")
+    st.write("Define multi-layer constructions for walls, roofs, and floors based on ASHRAE 2005 Handbook of Fundamentals.")
     
     # Display help information in an expandable section
     with st.expander("Help & Information"):
@@ -196,23 +43,24 @@ def display_construction_page():
     # Initialize constructions in session state if not present
     initialize_constructions()
     
-    # Create columns for library and project constructions
-    col1, col2 = st.columns(2)
+    # Check if rerun is pending
+    if 'construction_rerun_pending' not in st.session_state:
+        st.session_state.construction_rerun_pending = False
+    
+    if st.session_state.construction_rerun_pending:
+        st.session_state.construction_rerun_pending = False
+        st.rerun()
+    
+    # Split the display into two columns
+    col1, col2 = st.columns([3, 2])
     
-    # Library Constructions
     with col1:
-        st.subheader("Library Constructions")
-        display_library_constructions()
+        st.subheader("Saved Constructions")
+        display_constructions_table()
     
-    # Project Constructions
     with col2:
-        st.subheader("Project Constructions")
-        display_project_constructions()
-    
-    # Construction Editor
-    st.markdown("---")
-    st.subheader("Construction Editor")
-    display_construction_editor()
+        st.subheader("Construction Editor/Creator")
+        display_construction_editor()
     
     # Navigation buttons
     col1, col2 = st.columns(2)
@@ -237,162 +85,135 @@ def initialize_constructions():
     
     # Initialize library constructions if empty
     if not st.session_state.project_data["constructions"]["library"]:
-        st.session_state.project_data["constructions"]["library"] = DEFAULT_CONSTRUCTIONS.copy()
-    
-    # Add additional materials to library if not present
-    for material_name, material_data in ADDITIONAL_MATERIALS.items():
-        if material_name not in st.session_state.project_data["materials"]["library"]:
-            st.session_state.project_data["materials"]["library"][material_name] = material_data
+        # Get default constructions from the centralized data module
+        default_constructions = get_default_constructions()
+        st.session_state.project_data["constructions"]["library"] = default_constructions.copy()
     
     # Initialize construction editor state
     if "construction_editor" not in st.session_state:
-        st.session_state.construction_editor = {
-            "name": "",
-            "type": CONSTRUCTION_TYPES[0],
-            "layers": [],
-            "edit_mode": False,
-            "original_name": ""
-        }
+        st.session_state.construction_editor = {}
+    
+    # Initialize construction action state
+    if "construction_action" not in st.session_state:
+        st.session_state.construction_action = {"action": None, "id": None}
 
-def display_library_constructions():
-    """Display the library constructions section."""
+def display_constructions_table():
+    """Display the constructions in a table format."""
     # Filter options
-    type_filter = st.selectbox(
-        "Filter by Type",
-        ["All"] + CONSTRUCTION_TYPES,
-        key="library_construction_type_filter"
-    )
-    
-    # Get library constructions
-    library_constructions = st.session_state.project_data["constructions"]["library"]
-    
-    # Apply filter
-    if type_filter != "All":
-        filtered_constructions = {
-            name: props for name, props in library_constructions.items()
-            if props["type"] == type_filter
-        }
-    else:
-        filtered_constructions = library_constructions
+    col1, col2 = st.columns(2)
     
-    # Display constructions in a table
-    if filtered_constructions:
-        # Create a DataFrame for display
-        data = []
-        for name, props in filtered_constructions.items():
-            data.append({
-                "Name": name,
-                "Type": props["type"],
-                "U-Value (W/m²·K)": props["u_value"],
-                "R-Value (m²·K/W)": props["r_value"],
-                "Thermal Mass (kJ/m²·K)": props["thermal_mass"],
-                "Layers": len(props["layers"])
-            })
-        
-        df = pd.DataFrame(data)
-        st.dataframe(df, use_container_width=True, hide_index=True)
-        
-        # Add to project button
-        selected_construction = st.selectbox(
-            "Select Construction to Add to Project",
-            list(filtered_constructions.keys()),
-            key="library_construction_selector"
+    with col1:
+        source_filter = st.selectbox(
+            "Source",
+            ["All", "Library", "Project"],
+            key="construction_source_filter"
         )
+    
+    with col2:
+        type_filter = st.selectbox(
+            "Type",
+            ["All"] + CONSTRUCTION_TYPES,
+            key="construction_type_filter"
+        )
+    
+    # Get constructions based on filters
+    constructions = {}
+    
+    if source_filter in ["All", "Library"]:
+        for name, props in st.session_state.project_data["constructions"]["library"].items():
+            if type_filter == "All" or props["type"] == type_filter:
+                constructions[name] = {**props, "source": "Library"}
+    
+    if source_filter in ["All", "Project"]:
+        for name, props in st.session_state.project_data["constructions"]["project"].items():
+            if type_filter == "All" or props["type"] == type_filter:
+                constructions[name] = {**props, "source": "Project"}
+    
+    # Display constructions in a table
+    if constructions:
+        # Create column headers
+        cols = st.columns([3, 1, 1, 1, 1, 1, 1])
+        cols[0].write("**Name**")
+        cols[1].write("**Type**")
+        cols[2].write("**U-Value**")
+        cols[3].write("**Layers**")
+        cols[4].write("**Source**")
+        cols[5].write("**Edit**")
+        cols[6].write("**Delete**")
         
-        # Display selected construction details
-        if selected_construction:
-            st.subheader(f"Details: {selected_construction}")
-            display_construction_details(filtered_constructions[selected_construction])
-        
-        if st.button("Add to Project", key="add_library_construction_to_project"):
-            # Check if construction already exists in project
-            if selected_construction in st.session_state.project_data["constructions"]["project"]:
-                st.warning(f"Construction '{selected_construction}' already exists in your project.")
-            else:
-                # Add to project constructions
-                st.session_state.project_data["constructions"]["project"][selected_construction] = \
-                    st.session_state.project_data["constructions"]["library"][selected_construction].copy()
-                st.success(f"Construction '{selected_construction}' added to your project.")
-                logger.info(f"Added library construction '{selected_construction}' to project")
-    else:
-        st.info("No constructions found in the selected type.")
-
-def display_project_constructions():
-    """Display the project constructions section."""
-    # Get project constructions
-    project_constructions = st.session_state.project_data["constructions"]["project"]
-    
-    if project_constructions:
-        # Create a DataFrame for display
-        data = []
-        for name, props in project_constructions.items():
-            data.append({
-                "Name": name,
-                "Type": props["type"],
-                "U-Value (W/m²·K)": props["u_value"],
-                "R-Value (m²·K/W)": props["r_value"],
-                "Thermal Mass (kJ/m²·K)": props["thermal_mass"],
-                "Layers": len(props["layers"])
-            })
-        
-        df = pd.DataFrame(data)
-        st.dataframe(df, use_container_width=True, hide_index=True)
+        # Display each construction
+        for idx, (name, props) in enumerate(constructions.items()):
+            cols = st.columns([3, 1, 1, 1, 1, 1, 1])
+            cols[0].write(name)
+            cols[1].write(props["type"])
+            cols[2].write(f"{props.get('u_value', 0.0):.3f}")
+            cols[3].write(str(len(props.get("layers", []))))
+            cols[4].write(props["source"])
+            
+            # Edit button (only for project constructions)
+            with cols[5].container():
+                if props["source"] == "Project":
+                    edit_key = f"edit_construction_{name}_{idx}"
+                    if st.button("Edit", key=edit_key):
+                        # Load construction data into editor
+                        st.session_state.construction_editor = {
+                            "name": name,
+                            "type": props["type"],
+                            "layers": props.get("layers", []).copy(),
+                            "is_edit": True
+                        }
+                        st.session_state.construction_action = {"action": "edit", "id": str(uuid.uuid4())}
+                        st.session_state.construction_rerun_pending = True
+                else:
+                    st.write("N/A")
+            
+            # Delete button (only for project constructions)
+            with cols[6].container():
+                if props["source"] == "Project":
+                    delete_key = f"delete_construction_{name}_{idx}"
+                    if st.button("Delete", key=delete_key):
+                        # Check if construction is in use
+                        is_in_use = check_construction_in_use(name)
+                        
+                        if is_in_use:
+                            st.error(f"Cannot delete construction '{name}' because it is in use in building components.")
+                        else:
+                            # Delete construction
+                            del st.session_state.project_data["constructions"]["project"][name]
+                            st.success(f"Construction '{name}' deleted from your project.")
+                            logger.info(f"Deleted construction '{name}' from project")
+                            st.session_state.construction_action = {"action": "delete", "id": str(uuid.uuid4())}
+                            st.session_state.construction_rerun_pending = True
+                else:
+                    st.write("N/A")
         
-        # Select construction to view details
+        # Display details of selected construction
+        st.subheader("Construction Details")
         selected_construction = st.selectbox(
             "Select Construction to View Details",
-            list(project_constructions.keys()),
-            key="project_construction_selector"
+            list(constructions.keys()),
+            key="construction_details_selector"
         )
         
-        # Display selected construction details
         if selected_construction:
-            st.subheader(f"Details: {selected_construction}")
-            display_construction_details(project_constructions[selected_construction])
-        
-        # Edit and delete options
-        col1, col2 = st.columns(2)
-        
-        with col1:
-            selected_construction_edit = st.selectbox(
-                "Select Construction to Edit",
-                list(project_constructions.keys()),
-                key="project_construction_edit_selector"
-            )
-            
-            if st.button("Edit Construction", key="edit_project_construction"):
-                # Load construction data into editor
-                construction_data = project_constructions[selected_construction_edit]
-                st.session_state.construction_editor = {
-                    "name": selected_construction_edit,
-                    "type": construction_data["type"],
-                    "layers": construction_data["layers"].copy(),
-                    "edit_mode": True,
-                    "original_name": selected_construction_edit
-                }
-                st.success(f"Construction '{selected_construction_edit}' loaded for editing.")
-                st.rerun()
-        
-        with col2:
-            selected_construction_delete = st.selectbox(
-                "Select Construction to Delete",
-                list(project_constructions.keys()),
-                key="project_construction_delete_selector"
-            )
+            display_construction_details(constructions[selected_construction])
             
-            if st.button("Delete Construction", key="delete_project_construction"):
-                # Check if construction is in use
-                is_in_use = check_construction_in_use(selected_construction_delete)
-                
-                if is_in_use:
-                    st.error(f"Cannot delete construction '{selected_construction_delete}' because it is in use in building components.")
-                else:
-                    # Delete construction
-                    del st.session_state.project_data["constructions"]["project"][selected_construction_delete]
-                    st.success(f"Construction '{selected_construction_delete}' deleted from your project.")
-                    logger.info(f"Deleted construction '{selected_construction_delete}' from project")
+            # Add to project button for library constructions
+            if constructions[selected_construction]["source"] == "Library":
+                if st.button("Add to Project", key="add_to_project"):
+                    # Check if construction already exists in project
+                    if selected_construction in st.session_state.project_data["constructions"]["project"]:
+                        st.warning(f"Construction '{selected_construction}' already exists in your project.")
+                    else:
+                        # Add to project constructions
+                        construction_data = st.session_state.project_data["constructions"]["library"][selected_construction].copy()
+                        st.session_state.project_data["constructions"]["project"][selected_construction] = construction_data
+                        st.success(f"Construction '{selected_construction}' added to your project.")
+                        logger.info(f"Added library construction '{selected_construction}' to project")
+                        st.session_state.construction_action = {"action": "add", "id": str(uuid.uuid4())}
+                        st.session_state.construction_rerun_pending = True
     else:
-        st.info("No constructions in your project. Add constructions from the library or create custom constructions.")
+        st.info("No constructions found with the selected filters.")
 
 def display_construction_details(construction: Dict[str, Any]):
     """
@@ -406,242 +227,249 @@ def display_construction_details(construction: Dict[str, Any]):
     
     with col1:
         st.write(f"**Type:** {construction['type']}")
-        st.write(f"**U-Value:** {construction['u_value']} W/m²·K")
+        st.write(f"**U-Value:** {construction.get('u_value', 0.0):.3f} W/m²·K")
     
     with col2:
-        st.write(f"**R-Value:** {construction['r_value']} m²·K/W")
-        st.write(f"**Thermal Mass:** {construction['thermal_mass']} kJ/m²·K")
+        st.write(f"**R-Value:** {construction.get('r_value', 0.0):.3f} m²·K/W")
+        st.write(f"**Thermal Mass:** {construction.get('thermal_mass', 0.0):.1f} kJ/m²·K")
     
     with col3:
-        st.write(f"**Embodied Carbon:** {construction['embodied_carbon']} kg CO₂e/m²")
-        st.write(f"**Cost:** ${construction['cost']}/m²")
+        st.write(f"**Embodied Carbon:** {construction.get('embodied_carbon', 0.0):.1f} kg CO₂e/m²")
+        st.write(f"**Cost:** ${construction.get('cost', 0.0):.2f}/m²")
     
     # Display layers
     st.write("**Layers (from outside to inside):**")
     
     # Create a DataFrame for layers
     layers_data = []
-    for i, layer in enumerate(construction["layers"]):
+    for i, layer in enumerate(construction.get("layers", [])):
         layers_data.append({
             "Layer": i + 1,
-            "Material": layer["material"],
-            "Thickness (m)": layer["thickness"]
+            "Material": layer.get("material", ""),
+            "Thickness (m)": layer.get("thickness", 0.0)
         })
     
-    layers_df = pd.DataFrame(layers_data)
-    st.dataframe(layers_df, use_container_width=True, hide_index=True)
+    if layers_data:
+        layers_df = pd.DataFrame(layers_data)
+        st.dataframe(layers_df, use_container_width=True, hide_index=True)
+    else:
+        st.info("No layers defined for this construction.")
 
 def display_construction_editor():
     """Display the construction editor form."""
     # Get available materials
     available_materials = get_available_materials()
     
-    with st.form("construction_editor_form"):
+    # Get editor state
+    editor_state = st.session_state.construction_editor
+    is_edit = editor_state.get("is_edit", False)
+    
+    # Create the editor form
+    with st.form("construction_editor_form", clear_on_submit=True):
         # Construction name
         name = st.text_input(
             "Construction Name",
-            value=st.session_state.construction_editor["name"],
-            help="Enter a unique name for the construction."
+            value=editor_state.get("name", ""),
+            help="Enter a unique name for this construction."
         )
         
         # Construction type
         construction_type = st.selectbox(
             "Construction Type",
             CONSTRUCTION_TYPES,
-            index=CONSTRUCTION_TYPES.index(st.session_state.construction_editor["type"]) if st.session_state.construction_editor["type"] in CONSTRUCTION_TYPES else 0,
-            help="Select the construction type."
+            index=CONSTRUCTION_TYPES.index(editor_state.get("type", CONSTRUCTION_TYPES[0])) if editor_state.get("type") in CONSTRUCTION_TYPES else 0,
+            help="Select the type of construction (wall, roof, or floor)."
         )
         
-        # Layers section
+        # Layers
         st.subheader("Layers (from outside to inside)")
         
-        # Display current layers
-        if st.session_state.construction_editor["layers"]:
-            layers_data = []
-            for i, layer in enumerate(st.session_state.construction_editor["layers"]):
-                layers_data.append({
-                    "Layer": i + 1,
-                    "Material": layer["material"],
-                    "Thickness (m)": layer["thickness"]
-                })
-            
-            layers_df = pd.DataFrame(layers_data)
-            st.dataframe(layers_df, use_container_width=True, hide_index=True)
+        # Display existing layers
+        layers = editor_state.get("layers", [])
+        
+        if layers:
+            for i, layer in enumerate(layers):
+                col1, col2, col3 = st.columns([3, 2, 1])
+                
+                with col1:
+                    st.write(f"**Layer {i+1}:** {layer.get('material', '')}")
+                
+                with col2:
+                    st.write(f"**Thickness:** {layer.get('thickness', 0.0):.3f} m")
+                
+                with col3:
+                    if st.form_submit_button(f"Remove Layer {i+1}"):
+                        layers.pop(i)
+                        st.session_state.construction_editor["layers"] = layers
+                        st.session_state.construction_action = {"action": "update_layers", "id": str(uuid.uuid4())}
+                        st.session_state.construction_rerun_pending = True
         else:
-            st.info("No layers added yet. Use the controls below to add layers.")
+            st.info("No layers defined. Add layers below.")
         
-        # Layer controls
-        st.subheader("Add/Edit Layer")
+        # Add new layer
+        st.subheader("Add New Layer")
         
         col1, col2 = st.columns(2)
         
         with col1:
-            layer_material = st.selectbox(
+            new_material = st.selectbox(
                 "Material",
                 list(available_materials.keys()),
-                key="layer_material_selector",
-                help="Select a material for this layer."
+                help="Select a material for the new layer."
             )
-            
-            # Get material properties
-            if layer_material in available_materials:
-                material_props = available_materials[layer_material]
-                min_thickness = material_props["thickness_range"][0]
-                max_thickness = material_props["thickness_range"][1]
-                default_thickness = material_props["default_thickness"]
-            else:
-                min_thickness = 0.001
-                max_thickness = 0.5
-                default_thickness = 0.05
         
         with col2:
-            layer_thickness = st.number_input(
+            # Get thickness range for selected material
+            thickness_range = available_materials[new_material].get("thickness_range", {"min": 0.01, "max": 0.5, "default": 0.1})
+            min_thickness = thickness_range.get("min", 0.01)
+            max_thickness = thickness_range.get("max", 0.5)
+            default_thickness = thickness_range.get("default", 0.1)
+            
+            new_thickness = st.number_input(
                 "Thickness (m)",
-                min_value=float(min_thickness),
-                max_value=float(max_thickness),
-                value=float(default_thickness),
+                min_value=min_thickness,
+                max_value=max_thickness,
+                value=default_thickness,
                 format="%.3f",
-                help=f"Enter the thickness for this layer (range: {min_thickness}-{max_thickness} m)."
-            )
-        
-        # Layer action buttons
-        col1, col2, col3 = st.columns(3)
-        
-        with col1:
-            add_layer = st.form_submit_button("Add Layer")
-        
-        with col2:
-            layer_index_to_remove = st.number_input(
-                "Layer # to Remove",
-                min_value=1,
-                max_value=max(1, len(st.session_state.construction_editor["layers"])),
-                value=len(st.session_state.construction_editor["layers"]) if st.session_state.construction_editor["layers"] else 1,
-                step=1,
-                help="Enter the layer number to remove."
+                help=f"Enter the thickness of the layer (between {min_thickness} and {max_thickness} m)."
             )
         
-        with col3:
-            remove_layer = st.form_submit_button("Remove Layer")
+        # Add layer button
+        add_layer = st.form_submit_button("Add Layer")
         
-        # Calculate button and results
-        st.subheader("Thermal Properties")
+        # Calculate button
         calculate = st.form_submit_button("Calculate Properties")
         
-        # Form submission buttons
-        col1, col2, col3 = st.columns(3)
+        # Submit buttons
+        col1, col2 = st.columns(2)
         
         with col1:
-            save_button = st.form_submit_button("Save Construction")
+            submit_label = "Update Construction" if is_edit else "Create Construction"
+            submit = st.form_submit_button(submit_label)
         
         with col2:
-            clear_button = st.form_submit_button("Clear Form")
-        
-        with col3:
-            cancel_button = st.form_submit_button("Cancel Edit")
+            cancel = st.form_submit_button("Cancel")
     
-    # Handle form actions outside the form
+    # Handle form actions
     if add_layer:
-        # Add new layer
+        # Add new layer to the list
         new_layer = {
-            "material": layer_material,
-            "thickness": layer_thickness
+            "material": new_material,
+            "thickness": new_thickness
         }
-        st.session_state.construction_editor["layers"].append(new_layer)
-        st.success(f"Layer added: {layer_material} ({layer_thickness} m)")
-        st.rerun()
-    
-    if remove_layer and st.session_state.construction_editor["layers"]:
-        # Remove layer
-        if 1 <= layer_index_to_remove <= len(st.session_state.construction_editor["layers"]):
-            removed_layer = st.session_state.construction_editor["layers"].pop(layer_index_to_remove - 1)
-            st.success(f"Layer {layer_index_to_remove} removed: {removed_layer['material']} ({removed_layer['thickness']} m)")
-            st.rerun()
+        
+        layers = editor_state.get("layers", [])
+        layers.append(new_layer)
+        
+        # Update editor state
+        st.session_state.construction_editor = {
+            **editor_state,
+            "layers": layers
+        }
+        
+        st.success(f"Layer '{new_material}' added to construction.")
+        st.session_state.construction_action = {"action": "add_layer", "id": str(uuid.uuid4())}
+        st.session_state.construction_rerun_pending = True
+    
+    elif calculate:
+        # Calculate construction properties
+        if not layers:
+            st.error("Cannot calculate properties for a construction with no layers.")
         else:
-            st.error("Invalid layer index.")
-    
-    if calculate:
-        # Calculate thermal properties
-        if st.session_state.construction_editor["layers"]:
-            u_value, r_value, thermal_mass, embodied_carbon, cost = calculate_construction_properties(
-                st.session_state.construction_editor["layers"],
-                available_materials
-            )
-            
-            col1, col2, col3 = st.columns(3)
+            properties = calculate_construction_properties(layers, available_materials)
             
-            with col1:
-                st.metric("U-Value", f"{u_value:.3f} W/m²·K")
-                st.metric("R-Value", f"{r_value:.3f} m²·K/W")
+            # Update editor state with calculated properties
+            st.session_state.construction_editor = {
+                **editor_state,
+                "u_value": properties["u_value"],
+                "r_value": properties["r_value"],
+                "thermal_mass": properties["thermal_mass"],
+                "embodied_carbon": properties["embodied_carbon"],
+                "cost": properties["cost"]
+            }
             
-            with col2:
-                st.metric("Thermal Mass", f"{thermal_mass:.1f} kJ/m²·K")
-                st.metric("Total Thickness", f"{sum(layer['thickness'] for layer in st.session_state.construction_editor['layers']):.3f} m")
+            # Display calculated properties
+            st.success("Properties calculated successfully.")
+            st.write(f"**U-Value:** {properties['u_value']:.3f} W/m²·K")
+            st.write(f"**R-Value:** {properties['r_value']:.3f} m²·K/W")
+            st.write(f"**Thermal Mass:** {properties['thermal_mass']:.1f} kJ/m²·K")
+            st.write(f"**Embodied Carbon:** {properties['embodied_carbon']:.1f} kg CO₂e/m²")
+            st.write(f"**Cost:** ${properties['cost']:.2f}/m²")
             
-            with col3:
-                st.metric("Embodied Carbon", f"{embodied_carbon:.1f} kg CO₂e/m²")
-                st.metric("Cost", f"${cost:.2f}/m²")
-        else:
-            st.warning("Add layers to calculate thermal properties.")
+            st.session_state.construction_action = {"action": "calculate", "id": str(uuid.uuid4())}
+            st.session_state.construction_rerun_pending = True
     
-    if save_button:
+    elif submit:
         # Validate inputs
-        validation_errors = validate_construction(
-            name, construction_type, st.session_state.construction_editor["layers"],
-            st.session_state.construction_editor["edit_mode"], st.session_state.construction_editor["original_name"]
-        )
-        
-        if validation_errors:
-            # Display validation errors
-            for error in validation_errors:
-                st.error(error)
+        if not name:
+            st.error("Construction name is required.")
+        elif not layers:
+            st.error("At least one layer is required.")
         else:
-            # Calculate properties
-            u_value, r_value, thermal_mass, embodied_carbon, cost = calculate_construction_properties(
-                st.session_state.construction_editor["layers"],
-                available_materials
-            )
+            # Calculate properties if not already calculated
+            if "u_value" not in editor_state:
+                properties = calculate_construction_properties(layers, available_materials)
+            else:
+                properties = {
+                    "u_value": editor_state.get("u_value", 0.0),
+                    "r_value": editor_state.get("r_value", 0.0),
+                    "thermal_mass": editor_state.get("thermal_mass", 0.0),
+                    "embodied_carbon": editor_state.get("embodied_carbon", 0.0),
+                    "cost": editor_state.get("cost", 0.0)
+                }
             
             # Create construction data
             construction_data = {
                 "type": construction_type,
-                "layers": st.session_state.construction_editor["layers"].copy(),
-                "u_value": u_value,
-                "r_value": r_value,
-                "thermal_mass": thermal_mass,
-                "embodied_carbon": embodied_carbon,
-                "cost": cost
+                "layers": layers,
+                "u_value": properties["u_value"],
+                "r_value": properties["r_value"],
+                "thermal_mass": properties["thermal_mass"],
+                "embodied_carbon": properties["embodied_carbon"],
+                "cost": properties["cost"]
             }
             
             # Handle edit mode
-            if st.session_state.construction_editor["edit_mode"]:
-                original_name = st.session_state.construction_editor["original_name"]
-                
-                # If name changed, delete old entry and create new one
-                if original_name != name:
-                    del st.session_state.project_data["constructions"]["project"][original_name]
+            if is_edit:
+                # Check if name has changed
+                original_name = editor_state.get("name", "")
                 
-                # Update construction
-                st.session_state.project_data["constructions"]["project"][name] = construction_data
-                st.success(f"Construction '{name}' updated successfully.")
-                logger.info(f"Updated construction '{name}' in project")
+                if name != original_name and name in st.session_state.project_data["constructions"]["project"]:
+                    st.error(f"Construction name '{name}' already exists in your project. Please choose a different name.")
+                else:
+                    # If name changed, delete old entry and add new one
+                    if name != original_name:
+                        del st.session_state.project_data["constructions"]["project"][original_name]
+                    
+                    # Update construction
+                    st.session_state.project_data["constructions"]["project"][name] = construction_data
+                    st.success(f"Construction '{name}' updated successfully.")
+                    logger.info(f"Updated construction '{name}' in project")
+                    
+                    # Clear editor state
+                    st.session_state.construction_editor = {}
+                    st.session_state.construction_action = {"action": "update", "id": str(uuid.uuid4())}
+                    st.session_state.construction_rerun_pending = True
             else:
-                # Add new construction
-                st.session_state.project_data["constructions"]["project"][name] = construction_data
-                st.success(f"Construction '{name}' added to your project.")
-                logger.info(f"Added new construction '{name}' to project")
-            
-            # Reset editor
-            reset_construction_editor()
-            st.rerun()
-    
-    if clear_button:
-        reset_construction_editor()
-        st.rerun()
-    
-    if cancel_button and st.session_state.construction_editor["edit_mode"]:
-        reset_construction_editor()
-        st.success("Edit cancelled.")
-        st.rerun()
+                # Check if name already exists
+                if name in st.session_state.project_data["constructions"]["project"]:
+                    st.error(f"Construction name '{name}' already exists in your project. Please choose a different name.")
+                else:
+                    # Add new construction
+                    st.session_state.project_data["constructions"]["project"][name] = construction_data
+                    st.success(f"Construction '{name}' created successfully.")
+                    logger.info(f"Created new construction '{name}' in project")
+                    
+                    # Clear editor state
+                    st.session_state.construction_editor = {}
+                    st.session_state.construction_action = {"action": "create", "id": str(uuid.uuid4())}
+                    st.session_state.construction_rerun_pending = True
+    
+    elif cancel:
+        # Clear editor state
+        st.session_state.construction_editor = {}
+        st.session_state.construction_action = {"action": "cancel", "id": str(uuid.uuid4())}
+        st.session_state.construction_rerun_pending = True
 
 def get_available_materials() -> Dict[str, Any]:
     """
@@ -652,115 +480,76 @@ def get_available_materials() -> Dict[str, Any]:
     """
     available_materials = {}
     
-    # Add library materials
-    if "materials" in st.session_state.project_data and "library" in st.session_state.project_data["materials"]:
-        available_materials.update(st.session_state.project_data["materials"]["library"])
-    
-    # Add project materials
-    if "materials" in st.session_state.project_data and "project" in st.session_state.project_data["materials"]:
-        available_materials.update(st.session_state.project_data["materials"]["project"])
+    # Add materials from session state
+    if "materials" in st.session_state.project_data:
+        # Add library materials
+        if "library" in st.session_state.project_data["materials"]:
+            for name, material in st.session_state.project_data["materials"]["library"].items():
+                if material.get("type") == "opaque":
+                    available_materials[name] = material
+        
+        # Add project materials
+        if "project" in st.session_state.project_data["materials"]:
+            for name, material in st.session_state.project_data["materials"]["project"].items():
+                if material.get("type") == "opaque":
+                    available_materials[name] = material
     
     return available_materials
 
-def calculate_construction_properties(
-    layers: List[Dict[str, Any]],
-    available_materials: Dict[str, Any]
-) -> Tuple[float, float, float, float, float]:
+def calculate_construction_properties(layers: List[Dict[str, Any]], materials: Dict[str, Any]) -> Dict[str, float]:
     """
-    Calculate thermal properties of a construction.
+    Calculate the thermal properties of a construction based on its layers.
     
     Args:
         layers: List of layer dictionaries with material and thickness
-        available_materials: Dictionary of available materials
-        
+        materials: Dictionary of available materials
+    
     Returns:
-        Tuple of (u_value, r_value, thermal_mass, embodied_carbon, cost)
+        Dictionary of calculated properties
     """
-    # Initialize values
-    r_value_total = 0.0  # m²·K/W
-    thermal_mass_total = 0.0  # kJ/m²·K
-    embodied_carbon_total = 0.0  # kg CO₂e/m²
-    cost_total = 0.0  # USD/m²
+    # Initialize properties
+    r_value = 0.0  # m²·K/W
+    thermal_mass = 0.0  # kJ/m²·K
+    embodied_carbon = 0.0  # kg CO₂e/m²
+    cost = 0.0  # $/m²
     
-    # Add standard surface resistances
-    r_value_total += 0.13  # Interior surface resistance
-    r_value_total += 0.04  # Exterior surface resistance
+    # Add surface resistances (inside and outside)
+    r_value += 0.17  # m²·K/W (typical combined surface resistance)
     
     # Calculate properties for each layer
     for layer in layers:
-        material_name = layer["material"]
-        thickness = layer["thickness"]
+        material_name = layer.get("material", "")
+        thickness = layer.get("thickness", 0.0)
         
-        if material_name in available_materials:
-            material = available_materials[material_name]
+        if material_name in materials:
+            material = materials[material_name]
             
-            # Calculate R-value for this layer
-            r_value_layer = thickness / material["thermal_conductivity"]
-            r_value_total += r_value_layer
+            # Thermal resistance
+            if material.get("thermal_conductivity", 0.0) > 0:
+                r_value += thickness / material.get("thermal_conductivity", 1.0)
             
-            # Calculate thermal mass for this layer
-            thermal_mass_layer = material["density"] * material["specific_heat"] * thickness / 1000  # Convert J to kJ
-            thermal_mass_total += thermal_mass_layer
+            # Thermal mass
+            thermal_mass += material.get("density", 0.0) * material.get("specific_heat", 0.0) * thickness / 1000.0
             
-            # Calculate embodied carbon for this layer
-            embodied_carbon_layer = material["embodied_carbon"] * thickness
-            embodied_carbon_total += embodied_carbon_layer
+            # Embodied carbon
+            embodied_carbon += material.get("embodied_carbon", 0.0) * material.get("density", 0.0) * thickness
             
-            # Calculate cost for this layer
-            cost_layer = material["cost"] * thickness
-            cost_total += cost_layer
-    
-    # Calculate U-value from R-value
-    u_value = 1.0 / r_value_total if r_value_total > 0 else float('inf')
-    
-    return u_value, r_value_total, thermal_mass_total, embodied_carbon_total, cost_total
-
-def validate_construction(
-    name: str, construction_type: str, layers: List[Dict[str, Any]],
-    edit_mode: bool, original_name: str
-) -> List[str]:
-    """
-    Validate construction inputs.
-    
-    Args:
-        name: Construction name
-        construction_type: Construction type
-        layers: List of layer dictionaries
-        edit_mode: Whether in edit mode
-        original_name: Original name if in edit mode
-        
-    Returns:
-        List of validation error messages, empty if all inputs are valid
-    """
-    errors = []
-    
-    # Validate name
-    if not name or name.strip() == "":
-        errors.append("Construction name is required.")
-    
-    # Check for name uniqueness if not in edit mode or if name changed
-    if not edit_mode or (edit_mode and name != original_name):
-        if name in st.session_state.project_data["constructions"]["project"]:
-            errors.append(f"Construction name '{name}' already exists in your project.")
-    
-    # Validate construction type
-    if construction_type not in CONSTRUCTION_TYPES:
-        errors.append("Please select a valid construction type.")
+            # Cost
+            material_cost = material.get("cost", {})
+            if isinstance(material_cost, dict):
+                cost += material_cost.get("material", 0.0) * thickness + material_cost.get("labor", 0.0)
+            else:
+                cost += material_cost * thickness
     
-    # Validate layers
-    if not layers:
-        errors.append("At least one layer is required.")
+    # Calculate U-value
+    u_value = 1.0 / r_value if r_value > 0 else 0.0
     
-    return errors
-
-def reset_construction_editor():
-    """Reset the construction editor to default values."""
-    st.session_state.construction_editor = {
-        "name": "",
-        "type": CONSTRUCTION_TYPES[0],
-        "layers": [],
-        "edit_mode": False,
-        "original_name": ""
+    return {
+        "u_value": u_value,
+        "r_value": r_value,
+        "thermal_mass": thermal_mass,
+        "embodied_carbon": embodied_carbon,
+        "cost": cost
     }
 
 def check_construction_in_use(construction_name: str) -> bool:
@@ -769,55 +558,51 @@ def check_construction_in_use(construction_name: str) -> bool:
     
     Args:
         construction_name: Name of the construction to check
-        
+    
     Returns:
         True if the construction is in use, False otherwise
     """
-    # This is a placeholder function that will be implemented when components are added
-    # For now, we'll assume constructions are not in use
+    # Check if components exist in session state
+    if "components" not in st.session_state.project_data:
+        return False
+    
+    # Check walls, roofs, and floors
+    for comp_type in ["walls", "roofs", "floors"]:
+        if comp_type in st.session_state.project_data["components"]:
+            for component in st.session_state.project_data["components"][comp_type]:
+                if component.get("construction") == construction_name:
+                    return True
+    
     return False
 
 def display_construction_help():
-    """Display help information for the construction page."""
+    """
+    Display help information for the construction page.
+    """
     st.markdown("""
     ### Construction Library Help
     
-    This section allows you to create and manage multi-layer constructions for your building envelope.
+    This section allows you to create and manage multi-layer constructions for walls, roofs, and floors.
     
     **Key Concepts:**
     
-    * **Construction**: A multi-layer assembly of materials used for walls, roofs, or floors.
+    * **Construction**: A multi-layer assembly of materials used for building envelope components.
     * **Layers**: Individual material layers that make up a construction, defined from outside to inside.
-    * **U-Value**: Overall heat transfer coefficient (W/m²·K). Lower values indicate better insulation.
-    * **R-Value**: Thermal resistance (m²·K/W). Higher values indicate better insulation.
-    * **Thermal Mass**: Ability to store heat (kJ/m²·K). Higher values indicate better heat storage capacity.
-    
-    **Library Constructions:**
-    
-    The library contains pre-defined constructions with standard thermal properties. You can:
-    * Browse constructions by type (Wall, Roof, Floor)
-    * View detailed information about each construction
-    * Add library constructions to your project
+    * **U-Value**: Overall heat transfer coefficient (W/m²·K), lower is better for insulation.
+    * **R-Value**: Thermal resistance (m²·K/W), higher is better for insulation.
+    * **Thermal Mass**: Heat storage capacity (kJ/m²·K), higher values provide better temperature stability.
     
-    **Project Constructions:**
-    
-    These are constructions you've added to your project from the library or created custom. You can:
-    * View detailed information about each construction
-    * Edit existing constructions
-    * Delete constructions (if not in use)
-    
-    **Construction Editor:**
+    **Workflow:**
     
-    The editor allows you to create new constructions or modify existing ones:
-    * Add layers from outside to inside
-    * Select materials from your material library
-    * Specify thickness for each layer
-    * Calculate overall thermal properties
+    1. Create new constructions or add existing ones from the library to your project.
+    2. Define layers for each construction, selecting materials and specifying thicknesses.
+    3. Calculate thermal properties to evaluate performance.
+    4. Use constructions in the Building Components section to define walls, roofs, and floors.
     
-    **Workflow:**
+    **Tips:**
     
-    1. Browse the library constructions
-    2. Add constructions to your project or create custom ones
-    3. Edit properties as needed for your specific project
-    4. Continue to the Building Components page to use these constructions
+    * Start with the outermost layer (exterior) and work inward when defining layers.
+    * Consider both thermal resistance and thermal mass for optimal performance.
+    * Use the Calculate Properties button to evaluate your construction before saving.
+    * Library constructions cannot be modified, but you can add them to your project and then edit them.
     """)