Update app/construction.py

app/construction.py

@@ -1,10 +1,10 @@
 """
-BuildSustain - Construction Module
+BuildSustain - Construction Module (Updated)
 
 This module handles the construction assembly functionality of the BuildSustain application,
 allowing users to create and manage multi-layer constructions for walls, roofs, and floors.
 It integrates with the material library to select materials for each layer and calculates
-overall thermal properties.
+overall thermal properties. The structure is adapted from old.txt's Constructions tab.
 
 Developed by: Dr Majed Abuseif, Deakin University
 © 2025
@@ -18,8 +18,9 @@ import logging
 import uuid
 from typing import Dict, List, Any, Optional, Tuple, Union
 
-# Import the centralized data module
+# Import the centralized data module and materials library
 from app.m_c_data import get_default_constructions
+from app.materials_library import get_available_materials, Material
 
 # Configure logging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
@@ -28,522 +29,520 @@ logger = logging.getLogger(__name__)
 # Define constants
 CONSTRUCTION_TYPES = ["Wall", "Roof", "Floor"]
 
+# Surface resistances (EN ISO 6946 or ASHRAE)
+R_SI = 0.12  # Internal surface resistance (m²·K/W)
+R_SE = 0.04  # External surface resistance (m²·K/W)
+
+class ConstructionLibrary:
+    def __init__(self):
+        self.library_constructions = {}
+
+    def to_dataframe(self, project_constructions: Dict, only_project: bool = True) -> pd.DataFrame:
+        """Convert project constructions to a DataFrame."""
+        data = [
+            {
+                "Name": name,
+                "Component Type": props["type"],
+                "U-Value (W/m²·K)": props.get("u_value", 0.0),
+                "R-Value (m²·K/W)": props.get("r_value", 0.0),
+                "Thermal Mass (kJ/m²·K)": props.get("thermal_mass", 0.0),
+                "Embodied Carbon (kgCO₂e/m²)": props.get("embodied_carbon", 0.0),
+                "Cost (USD/m²)": props.get("cost", 0.0),
+                "Layers": len(props.get("layers", []))
+            }
+            for name, props in project_constructions.items()
+        ]
+        return pd.DataFrame(data)
+
+    def add_project_construction(self, construction: Dict, project_constructions: Dict) -> Tuple[bool, str]:
+        """Add a new construction to the project."""
+        try:
+            if construction["name"] in project_constructions or construction["name"] in self.library_constructions:
+                return False, f"Construction '{construction['name']}' already exists."
+            project_constructions[construction["name"]] = construction
+            return True, f"Construction '{construction['name']}' added successfully!"
+        except Exception as e:
+            return False, f"Error adding construction: {str(e)}"
+
+    def edit_project_construction(self, original_name: str, new_construction: Dict, project_constructions: Dict, components: Dict) -> Tuple[bool, str]:
+        """Edit an existing project construction."""
+        try:
+            if original_name not in project_constructions:
+                return False, f"Construction '{original_name}' not found."
+            if new_construction["name"] != original_name and (new_construction["name"] in project_constructions or new_construction["name"] in self.library_constructions):
+                return False, f"Construction '{new_construction['name']}' already exists."
+            project_constructions[new_construction["name"]] = new_construction
+            if new_construction["name"] != original_name:
+                del project_constructions[original_name]
+            return True, f"Construction '{new_construction['name']}' updated successfully!"
+        except Exception as e:
+            return False, f"Error editing construction: {str(e)}"
+
+    def delete_project_construction(self, name: str, project_constructions: Dict, components: Dict) -> Tuple[bool, str]:
+        """Delete a project construction."""
+        try:
+            if name not in project_constructions:
+                return False, f"Construction '{name}' not found."
+            if check_construction_in_use(name, components):
+                return False, f"Construction '{name}' is used in components and cannot be deleted."
+            del project_constructions[name]
+            return True, f"Construction '{name}' deleted successfully!"
+        except Exception as e:
+            return False, f"Error deleting construction: {str(e)}"
+
 def display_construction_page():
     """
-    Display the construction page.
-    This is the main function called by main.py when the Construction page is selected.
+    Display the construction page, adapted from old.txt's Constructions tab.
     """
     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
+
+    # Display help information
     with st.expander("Help & Information"):
         display_construction_help()
-    
-    # Initialize constructions in session state if not present
-    initialize_constructions()
-    
-    # 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:
+
+    # CSS for box heights, scrolling, and visual appeal
+    st.markdown("""
+    <style>
+    .box-container {
+        border: 1px solid #e0e0e0;
+        border-radius: 8px;
+        padding: 10px;
+        background-color: #f9f9f9;
+        box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+        overflow-y: auto;
+        scrollbar-width: thin;
+    }
+    .library-box {
+        max-height: 250px;
+    }
+    .project-box {
+        max-height: 250px;
+    }
+    .editor-box {
+        min-height: 540px;
+    }
+    .stButton>button {
+        width: 100%;
+        font-size: 12px;
+        padding: 5px;
+    }
+    </style>
+    """, unsafe_allow_html=True)
+
+    # Initialize constructions in session state
+    initialize_construction()
+
+    # Check for rerun trigger
+    if st.session_state.get("construction_rerun_pending", False):
         st.session_state.construction_rerun_pending = False
         st.rerun()
-    
-    # Split the display into two columns
+
+    # Initialize session state
+    if 'construction_action' not in st.session_state:
+        st.session_state.construction_action = {"action": None, "id": None}
+    if 'construction_rerun_pending' not in st.session_state:
+        st.session_state.construction_rerun_pending = False
+    if 'construction_form_state' not in st.session_state:
+        st.session_state.construction_form_state = {}
+    if 'construction_editor' not in st.session_state:
+        st.session_state.construction_editor = {}
+
+    # Initialize construction library
+    construction_library = ConstructionLibrary()
+    construction_library.library_constructions = st.session_state.project_data["constructions"]["library"]
+
+    # Display constructions content
     col1, col2 = st.columns([3, 2])
-    
     with col1:
-        st.subheader("Saved Constructions")
-        display_constructions_table()
-    
+        display_constructions_tables(construction_library)
     with col2:
-        st.subheader("Construction Editor/Creator")
-        display_construction_editor()
-    
+        display_construction_editor(construction_library)
+
+    # Display project constructions DataFrame
+    st.subheader("Project Constructions")
+    try:
+        construction_filter = st.session_state.get("construction_filter", "All")
+        construction_df = construction_library.to_dataframe(st.session_state.project_data["constructions"]["project"])
+        if construction_filter != "All":
+            construction_df = construction_df[construction_df["Component Type"] == construction_filter]
+        if not construction_df.empty:
+            st.dataframe(construction_df, use_container_width=True)
+        else:
+            st.write("No project constructions to display.")
+    except Exception as e:
+        st.error(f"Error displaying project constructions: {str(e)}")
+        st.write("No project constructions to display.")
+
     # Navigation buttons
     col1, col2 = st.columns(2)
-    
     with col1:
         if st.button("Back to Material Library", key="back_to_materials"):
             st.session_state.current_page = "Material Library"
             st.rerun()
-    
     with col2:
         if st.button("Continue to Building Components", key="continue_to_components"):
             st.session_state.current_page = "Building Components"
             st.rerun()
 
-def initialize_constructions():
+def initialize_construction():
     """Initialize constructions in session state if not present."""
+    if "project_data" not in st.session_state:
+        st.session_state.project_data = {}
     if "constructions" not in st.session_state.project_data:
         st.session_state.project_data["constructions"] = {
-            "library": {},
+            "library": get_default_constructions(),
             "project": {}
         }
-    
-    # Initialize library constructions if empty
-    if not st.session_state.project_data["constructions"]["library"]:
-        # 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 = {}
-    
-    # Initialize construction action state
-    if "construction_action" not in st.session_state:
-        st.session_state.construction_action = {"action": None, "id": None}
+    if "components" not in st.session_state.project_data:
+        st.session_state.project_data["components"] = {}
 
-def display_constructions_table():
-    """Display the constructions in a table format."""
-    # Filter options
-    col1, col2 = st.columns(2)
-    
-    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])
+def display_constructions_tables(construction_library: ConstructionLibrary):
+    """Display library and project constructions tables."""
+    # Component type filter
+    filter_options = ["All"] + CONSTRUCTION_TYPES
+    construction_filter = st.selectbox("Filter by Component Type", filter_options, key="construction_filter")
+
+    st.subheader("Library Constructions")
+    with st.container():
+        library_constructions = list(construction_library.library_constructions.values())
+        if construction_filter != "All":
+            library_constructions = [c for c in library_constructions if c["type"] == construction_filter]
+        cols = st.columns([2, 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 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
+        cols[1].write("**Thermal Mass**")
+        cols[2].write("**U-Value (W/m²·K)**")
+        cols[3].write("**Preview**")
+        cols[4].write("**Copy**")
+        for construction in library_constructions:
+            cols = st.columns([2, 1, 1, 1, 1])
+            cols[0].write(construction["name"])
+            cols[1].write(f"{construction.get('thermal_mass', 0.0):.1f}")
+            cols[2].write(f"{construction.get('u_value', 0.0):.3f}")
+            if cols[3].button("Preview", key=f"preview_lib_cons_{construction['name']}"):
+                if st.session_state.get("rerun_trigger") != f"preview_cons_{construction['name']}":
+                    st.session_state.rerun_trigger = f"preview_cons_{construction['name']}"
+                    st.session_state.construction_editor = {
+                        "name": construction["name"],
+                        "component_type": construction["type"],
+                        "layers": [{"material_name": layer["material"], "thickness": layer["thickness"]} for layer in construction["layers"]],
+                        "is_edit": False
+                    }
+                    st.session_state.construction_form_state = {
+                        "name": construction["name"],
+                        "component_type": construction["type"],
+                        "num_layers": len(construction["layers"]),
+                        "layers": [{"material_name": layer["material"], "thickness": layer["thickness"]} for layer in construction["layers"]]
+                    }
+                    st.session_state.construction_rerun_pending = True
+            if cols[4].button("Copy", key=f"copy_lib_cons_{construction['name']}"):
+                new_name = f"{construction['name']}_Project"
+                counter = 1
+                while new_name in st.session_state.project_data["constructions"]["project"] or new_name in construction_library.library_constructions:
+                    new_name = f"{construction['name']}_Project_{counter}"
+                    counter += 1
+                new_layers = []
+                material_library = st.session_state.get("material_library", None)
+                if not material_library:
+                    from app.materials_library import MaterialLibrary
+                    material_library = MaterialLibrary()
+                    st.session_state.material_library = material_library
+                for layer in construction["layers"]:
+                    material_name = layer["material"]
+                    if material_name in st.session_state.project_data["materials"]["library"]:
+                        # Copy library material to project
+                        library_material = st.session_state.project_data["materials"]["library"][material_name]
+                        new_mat_name = f"{material_name}_Project"
+                        counter = 1
+                        while new_mat_name in st.session_state.project_data["materials"]["project"] or new_mat_name in st.session_state.project_data["materials"]["library"]:
+                            new_mat_name = f"{material_name}_Project_{counter}"
+                            counter += 1
+                        new_material = Material(
+                            name=new_mat_name,
+                            category=MaterialCategory(library_material["category"]),
+                            conductivity=library_material["thermal_conductivity"],
+                            density=library_material["density"],
+                            specific_heat=library_material["specific_heat"],
+                            default_thickness=library_material["thickness_range"]["default"],
+                            embodied_carbon=library_material["embodied_carbon"],
+                            solar_absorption=library_material.get("solar_absorption", 0.6),
+                            price=library_material["cost"]["material"],
+                            emissivity=library_material.get("emissivity", 0.9),
+                            is_library=False
+                        )
+                        success, message = material_library.add_project_material(new_material, st.session_state.project_data["materials"]["project"])
+                        if not success:
+                            st.error(f"Failed to copy material '{material_name}': {message}")
+                            break
+                        material_name = new_mat_name
+                    new_layers.append({"material": material_name, "thickness": layer["thickness"]})
+                else:
+                    properties = calculate_construction_properties(new_layers, get_available_materials())
+                    new_construction = {
+                        "name": new_name,
+                        "type": construction["type"],
+                        "layers": new_layers,
+                        "u_value": properties["u_value"],
+                        "r_value": properties["r_value"],
+                        "thermal_mass": properties["thermal_mass"],
+                        "embodied_carbon": properties["embodied_carbon"],
+                        "cost": properties["cost"],
+                        "is_library": False
+                    }
+                    success, message = construction_library.add_project_construction(new_construction, st.session_state.project_data["constructions"]["project"])
+                    if success:
+                        st.success(message)
+                        st.session_state.construction_rerun_pending = True
+                    else:
+                        st.error(message)
+
+    st.subheader("Project Constructions")
+    with st.container():
+        project_constructions = list(st.session_state.project_data["constructions"]["project"].values())
+        if construction_filter != "All":
+            project_constructions = [c for c in project_constructions if c["type"] == construction_filter]
+        if project_constructions:
+            cols = st.columns([2, 1, 1, 1, 1])
+            cols[0].write("**Name**")
+            cols[1].write("**Thermal Mass**")
+            cols[2].write("**U-Value (W/m²·K)**")
+            cols[3].write("**Edit**")
+            cols[4].write("**Delete**")
+            for construction in project_constructions:
+                cols = st.columns([2, 1, 1, 1, 1])
+                cols[0].write(construction["name"])
+                cols[1].write(f"{construction.get('thermal_mass', 0.0):.1f}")
+                cols[2].write(f"{construction.get('u_value', 0.0):.3f}")
+                if cols[3].button("Edit", key=f"edit_proj_cons_{construction['name']}"):
+                    if st.session_state.get("rerun_trigger") != f"edit_cons_{construction['name']}":
+                        st.session_state.rerun_trigger = f"edit_cons_{construction['name']}"
                         st.session_state.construction_editor = {
-                            "name": name,
-                            "type": props["type"],
-                            "layers": props.get("layers", []).copy(),
-                            "is_edit": True
+                            "name": construction["name"],
+                            "component_type": construction["type"],
+                            "layers": [{"material_name": layer["material"], "thickness": layer["thickness"]} for layer in construction["layers"]],
+                            "is_edit": True,
+                            "original_name": construction["name"]
+                        }
+                        st.session_state.construction_form_state = {
+                            "name": construction["name"],
+                            "component_type": construction["type"],
+                            "num_layers": len(construction["layers"]),
+                            "layers": [{"material_name": layer["material"], "thickness": layer["thickness"]} for layer in construction["layers"]]
                         }
-                        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")
-        
-        # Display details of selected construction
-        st.subheader("Construction Details")
-        selected_construction = st.selectbox(
-            "Select Construction to View Details",
-            list(constructions.keys()),
-            key="construction_details_selector"
-        )
-        
-        if selected_construction:
-            display_construction_details(constructions[selected_construction])
-            
-            # 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())}
+                if cols[4].button("Delete", key=f"delete_proj_cons_{construction['name']}"):
+                    success, message = construction_library.delete_project_construction(
+                        construction["name"], st.session_state.project_data["constructions"]["project"], st.session_state.project_data.get("components", {})
+                    )
+                    if success:
+                        st.success(message)
                         st.session_state.construction_rerun_pending = True
-    else:
-        st.info("No constructions found with the selected filters.")
-
-def display_construction_details(construction: Dict[str, Any]):
-    """
-    Display detailed information about a construction.
-    
-    Args:
-        construction: Construction data dictionary
-    """
-    # Display basic properties
-    col1, col2, col3 = st.columns(3)
-    
-    with col1:
-        st.write(f"**Type:** {construction['type']}")
-        st.write(f"**U-Value:** {construction.get('u_value', 0.0):.3f} W/m²·K")
-    
-    with col2:
-        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.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.get("layers", [])):
-        layers_data.append({
-            "Layer": i + 1,
-            "Material": layer.get("material", ""),
-            "Thickness (m)": layer.get("thickness", 0.0)
-        })
-    
-    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.")
+                    else:
+                        st.error(message)
+        else:
+            st.write("No project constructions added.")
 
-def display_construction_editor():
+def display_construction_editor(construction_library: ConstructionLibrary):
     """Display the construction editor form."""
-    # Get available materials
-    available_materials = get_available_materials()
-    
-    # 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=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(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
-        st.subheader("Layers (from outside to inside)")
-        
-        # 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 defined. Add layers below.")
-        
-        # Add new layer
-        st.subheader("Add New Layer")
-        
-        col1, col2 = st.columns(2)
-        
-        with col1:
-            new_material = st.selectbox(
-                "Material",
-                list(available_materials.keys()),
-                help="Select a material for the new layer."
+    is_preview = st.session_state.get("rerun_trigger", "").startswith("preview_cons_")
+    materials = get_available_materials()
+    material_objects = {name: m for name, m in materials.items() if isinstance(m, Material)}
+    if is_preview:
+        material_objects.update(st.session_state.project_data["materials"]["library"])
+    material_names = list(material_objects.keys())
+    
+    if not material_names and not is_preview:
+        st.error("No project materials available. Please create materials in the Materials tab first.")
+        if st.button("Go to Materials", key="go_to_materials"):
+            st.session_state.current_page = "Material Library"
+            st.rerun()
+        return
+
+    with st.container():
+        with st.form("construction_editor_form", clear_on_submit=False):
+            editor_state = st.session_state.get("construction_editor", {})
+            form_state = st.session_state.get("construction_form_state", {
+                "name": "",
+                "component_type": "Wall",
+                "num_layers": 1,
+                "layers": [{"material_name": material_names[0] if material_names else "", "thickness": 0.1}]
+            })
+            is_edit = editor_state.get("is_edit", False)
+            original_name = editor_state.get("original_name", "")
+            name = st.text_input(
+                "Construction Name",
+                value=form_state.get("name", editor_state.get("name", "")),
+                help="Unique construction identifier",
+                key="construction_name_input"
             )
-        
-        with col2:
-            # 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=min_thickness,
-                max_value=max_thickness,
-                value=default_thickness,
-                format="%.3f",
-                help=f"Enter the thickness of the layer (between {min_thickness} and {max_thickness} m)."
+            component_type = st.selectbox(
+                "Component Type",
+                CONSTRUCTION_TYPES,
+                index=CONSTRUCTION_TYPES.index(form_state.get("component_type", editor_state.get("component_type", "Wall"))),
+                help="Building component type",
+                key="construction_component_type_input"
             )
-        
-        # Add layer button
-        add_layer = st.form_submit_button("Add Layer")
-        
-        # Calculate button
-        calculate = st.form_submit_button("Calculate Properties")
-        
-        # Submit buttons
-        col1, col2 = st.columns(2)
-        
-        with col1:
-            submit_label = "Update Construction" if is_edit else "Create Construction"
-            submit = st.form_submit_button(submit_label)
-        
-        with col2:
-            cancel = st.form_submit_button("Cancel")
-    
-    # Handle form actions
-    if add_layer:
-        # Add new layer to the list
-        new_layer = {
-            "material": new_material,
-            "thickness": new_thickness
-        }
-        
-        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:
-            properties = calculate_construction_properties(layers, available_materials)
-            
-            # 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"]
-            }
-            
-            # 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²")
-            
-            st.session_state.construction_action = {"action": "calculate", "id": str(uuid.uuid4())}
-            st.session_state.construction_rerun_pending = True
-    
-    elif submit:
-        # Validate inputs
-        if not name:
-            st.error("Construction name is required.")
-        elif not layers:
-            st.error("At least one layer is required.")
-        else:
-            # 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": 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 is_edit:
-                # Check if name has changed
-                original_name = editor_state.get("name", "")
-                
-                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:
-                # 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
+            num_layers = st.number_input(
+                "Number of Layers",
+                min_value=1,
+                max_value=10,
+                value=form_state.get("num_layers", 1),
+                help="Material layer count",
+                key="construction_num_layers_input"
+            )
+            default_material = material_names[0] if material_names else ""
+            layers = form_state.get("layers", [{"material_name": default_material, "thickness": 0.1}])
+            if len(layers) < num_layers:
+                layers.extend([{"material_name": default_material, "thickness": 0.1} for _ in range(num_layers - len(layers))])
+            elif len(layers) > num_layers:
+                layers = layers[:num_layers]
+            form_state["layers"] = layers
+            form_state["num_layers"] = num_layers
+            for i in range(num_layers):
+                st.write(f"Layer {i + 1} (Exterior to Interior)")
+                layer = layers[i]
+                material_name = st.selectbox(
+                    f"Material {i+1}",
+                    material_names,
+                    index=material_names.index(layer.get("material_name", default_material)) if layer.get("material_name", default_material) in material_names else 0,
+                    key=f"cons_mat_{i}_{num_layers}",
+                    help="Layer material"
+                )
+                thickness = st.number_input(
+                    f"Thickness {i+1} (m)",
+                    min_value=0.001,
+                    value=layer.get("thickness", 0.1),
+                    key=f"cons_thick_{i}_{num_layers}",
+                    help="Layer thickness"
+                )
+                layers[i] = {"material_name": material_name, "thickness": thickness}
+            form_state["layers"] = layers
+            st.session_state.construction_form_state = form_state
 
-def get_available_materials() -> Dict[str, Any]:
-    """
-    Get all available materials from both library and project.
-    
-    Returns:
-        Dict of material name to material properties
-    """
-    available_materials = {}
-    
-    # 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
+            col1, col2, col3 = st.columns(3)
+            with col1:
+                if st.form_submit_button("Update Layers"):
+                    action_id = str(uuid.uuid4())
+                    if st.session_state.construction_action.get("id") != action_id:
+                        st.session_state.construction_action = {"action": "update_layers", "id": action_id}
+                        new_layers = []
+                        for i in range(num_layers):
+                            if i < len(layers) and layers[i].get("material_name") in material_names:
+                                new_layers.append(layers[i])
+                            else:
+                                new_layers.append({"material_name": default_material, "thickness": 0.1})
+                        form_state["layers"] = new_layers
+                        form_state["num_layers"] = num_layers
+                        st.session_state.construction_form_state = form_state
+                        st.session_state.construction_action = {"action": None, "id": None}
+                        st.session_state.construction_rerun_pending = True
+            with col2:
+                if st.form_submit_button("Preview U-Value"):
+                    action_id = str(uuid.uuid4())
+                    if st.session_state.construction_action.get("id") != action_id:
+                        st.session_state.construction_action = {"action": "preview_uvalue", "id": action_id}
+                        if layers:
+                            valid_layers = []
+                            for layer in layers:
+                                material_name = layer.get("material_name")
+                                thickness = layer.get("thickness", 0.1)
+                                if material_name in material_objects:
+                                    material = material_objects[material_name]
+                                    valid_layers.append({"material": material, "thickness": thickness})
+                            if valid_layers:
+                                r_total = R_SI + sum(layer["thickness"] / layer["material"].conductivity for layer in valid_layers) + R_SE
+                                u_value = 1.0 / r_total if r_total > 0 else 0.1
+                                st.write(f"Calculated U-Value: {u_value:.3f} W/m²·K")
+                            else:
+                                st.warning("No valid materials selected for U-Value calculation.")
+                        else:
+                            st.warning("No layers defined to calculate U-Value.")
+                        st.session_state.construction_action = {"action": None, "id": None}
+            with col3:
+                if st.form_submit_button("Save Construction"):
+                    action_id = str(uuid.uuid4())
+                    if st.session_state.construction_action.get("id") != action_id:
+                        st.session_state.construction_action = {"action": "save", "id": action_id}
+                        if not name or not name.strip():
+                            st.error("Construction name cannot be empty.")
+                        elif (name in st.session_state.project_data["constructions"]["project"] or name in construction_library.library_constructions) and (not is_edit or name != original_name):
+                            st.error(f"Construction '{name}' already exists.")
+                        elif not layers or any(not layer.get("material_name") for layer in layers):
+                            st.error("All layers must have a valid material.")
+                        else:
+                            try:
+                                valid_layers = []
+                                for layer in layers:
+                                    material_name = layer.get("material_name")
+                                    thickness = layer.get("thickness", 0.1)
+                                    if material_name in material_names:
+                                        valid_layers.append({"material": material_name, "thickness": thickness})
+                                    else:
+                                        st.error(f"Material '{material_name}' not found.")
+                                        break
+                                else:
+                                    properties = calculate_construction_properties(valid_layers, material_objects)
+                                    new_construction = {
+                                        "name": name,
+                                        "type": component_type,
+                                        "layers": valid_layers,
+                                        "u_value": properties["u_value"],
+                                        "r_value": properties["r_value"],
+                                        "thermal_mass": properties["thermal_mass"],
+                                        "embodied_carbon": properties["embodied_carbon"],
+                                        "cost": properties["cost"],
+                                        "is_library": False
+                                    }
+                                    if is_edit and name == original_name:
+                                        success, message = construction_library.edit_project_construction(
+                                            original_name, new_construction, st.session_state.project_data["constructions"]["project"], st.session_state.project_data.get("components", {})
+                                        )
+                                    else:
+                                        success, message = construction_library.add_project_construction(new_construction, st.session_state.project_data["constructions"]["project"])
+                                    if success:
+                                        st.success(message)
+                                        st.session_state.construction_editor = {}
+                                        st.session_state.construction_form_state = {
+                                            "name": "",
+                                            "component_type": "Wall",
+                                            "num_layers": 1,
+                                            "layers": [{"material_name": default_material, "thickness": 0.1}]
+                                        }
+                                        st.session_state.construction_action = {"action": None, "id": None}
+                                        st.session_state.rerun_trigger = None
+                                        st.session_state.construction_rerun_pending = True
+                                    else:
+                                        st.error(f"Failed to save construction: {message}")
+                            except Exception as e:
+                                st.error(f"Error saving construction: {str(e)}")
 
 def calculate_construction_properties(layers: List[Dict[str, Any]], materials: Dict[str, Any]) -> Dict[str, float]:
     """
     Calculate the thermal properties of a construction based on its layers.
-    
-    Args:
-        layers: List of layer dictionaries with material and thickness
-        materials: Dictionary of available materials
-    
-    Returns:
-        Dictionary of calculated properties
     """
-    # Initialize properties
-    r_value = 0.0  # m²·K/W
+    r_value = R_SI  # Internal surface resistance
     thermal_mass = 0.0  # kJ/m²·K
     embodied_carbon = 0.0  # kg CO₂e/m²
     cost = 0.0  # $/m²
-    
-    # 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.get("material", "")
         thickness = layer.get("thickness", 0.0)
-        
         if material_name in materials:
             material = materials[material_name]
-            
             # Thermal resistance
-            if material.get("thermal_conductivity", 0.0) > 0:
-                r_value += thickness / material.get("thermal_conductivity", 1.0)
-            
+            if material.conductivity > 0:
+                r_value += thickness / material.conductivity
             # Thermal mass
-            thermal_mass += material.get("density", 0.0) * material.get("specific_heat", 0.0) * thickness / 1000.0
-            
+            thermal_mass += material.density * material.specific_heat * thickness / 1000.0
             # Embodied carbon
-            embodied_carbon += material.get("embodied_carbon", 0.0) * material.get("density", 0.0) * thickness
-            
+            embodied_carbon += material.embodied_carbon * material.density * thickness
             # 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
-    
-    # Calculate U-value
+            cost += material.price * thickness
+
+    r_value += R_SE  # External surface resistance
     u_value = 1.0 / r_value if r_value > 0 else 0.0
-    
+
     return {
         "u_value": u_value,
         "r_value": r_value,
@@ -552,27 +551,15 @@ def calculate_construction_properties(layers: List[Dict[str, Any]], materials: D
         "cost": cost
     }
 
-def check_construction_in_use(construction_name: str) -> bool:
+def check_construction_in_use(construction_name: str, components: Dict) -> bool:
     """
     Check if a construction is in use in any building components.
-    
-    Args:
-        construction_name: Name of the construction to check
-    
-    Returns:
-        True if the construction is in use, False otherwise
     """
-    # 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 comp_type in components:
+            for component in components[comp_type]:
                 if component.get("construction") == construction_name:
                     return True
-    
     return False
 
 def display_construction_help():
@@ -606,3 +593,13 @@ def display_construction_help():
     * 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.
     """)
+
+def get_available_constructions() -> Dict[str, Any]:
+    """
+    Get all available constructions (library + project) for use in other modules.
+    """
+    constructions = {}
+    if "constructions" in st.session_state.project_data:
+        constructions.update(st.session_state.project_data["constructions"]["library"])
+        constructions.update(st.session_state.project_data["constructions"]["project"])
+    return constructions