Upload streamlit_app.py

streamlit_app.py

@@ -0,0 +1,1395 @@
+def create_dataset_statistics(buildings_df: pd.DataFrame, weather_df: pd.DataFrame, combinations_df: pd.DataFrame):
+    """Create comprehensive dataset statistics section"""
+    st.subheader("📊 Dataset Statistics & Information")
+    
+    # Dataset description
+    st.markdown("""
+    <div style="background-color: #1e1e1e; border-radius: 10px; padding: 20px; margin: 20px 0; 
+                border-left: 4px solid #2196f3; color: white;">
+        <h4 style="color: #2196f3; margin-bottom: 15px;">🏗️ About This Dataset</h4>
+        <p style="font-size: 1.1em; line-height: 1.6; margin-bottom: 10px;">
+            This comprehensive building energy dataset contains energy models for various building types across different climate zones. 
+            The dataset is designed for energy simulation research, building performance analysis, and climate impact studies.
+        </p>
+        <p style="font-size: 1.1em; line-height: 1.6; margin-bottom: 10px;">
+            Each building model includes detailed geometric properties, construction materials, HVAC systems, and occupancy schedules. 
+            Multiple variations are generated from base models to study the impact of different parameters on energy performance.
+        </p>
+        <p style="font-size: 1.1em; line-height: 1.6;">
+            Weather data is sourced from global meteorological stations and covers multiple climate zones as defined by ASHRAE standards, 
+            enabling comprehensive climate-specific energy analysis.
+        </p>
+    </div>
+    """, unsafe_allow_html=True)
+    
+    # Detailed statistics
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        st.subheader("🏢 Building Dataset Details")
+        
+        if not buildings_df.empty:
+            # Building type breakdown
+            building_types = buildings_df['building_type'].value_counts()
+            st.markdown("**Building Types Distribution:**")
+            for btype, count in building_types.items():
+                percentage = (count / len(buildings_df)) * 100
+                st.write(f"• **{btype.title()}**: {count} models ({percentage:.1f}%)")
+            
+            st.markdown("---")
+            
+            # Variation breakdown
+            variation_types = buildings_df['variation_type'].value_counts()
+            st.markdown("**Variation Types:**")
+            for var_type, count in variation_types.items():
+                percentage = (count / len(buildings_df)) * 100
+                st.write(f"• **{var_type.title()}**: {count} models ({percentage:.1f}%)")
+            
+            st.markdown("---")
+            
+            # Climate zone coverage
+            climate_zones = buildings_df['climate_zone'].value_counts().sort_index()
+            st.markdown("**Climate Zone Coverage:**")
+            for zone, count in climate_zones.items():
+                st.write(f"• **Zone {zone}**: {count} buildings")
+        else:
+            st.warning("No building data available")
+    
+    with col2:
+        st.subheader("🌍 Weather Dataset Details")
+        
+        if not weather_df.empty:
+            # Geographic coverage
+            st.markdown("**Geographic Coverage:**")
+            st.write(f"• **Total Locations**: {len(weather_df)}")
+            st.write(f"• **Countries Covered**: {weather_df['country'].nunique()}")
+            st.write(f"• **Climate Zones**: {weather_df['climate_zone_code'].nunique()}")
+            
+            # Climate zone distribution in weather data
+            weather_climate_zones = weather_df['climate_zone_code'].value_counts().sort_index()
+            st.markdown("**Weather Locations by Climate Zone:**")
+            for zone, count in weather_climate_zones.head(10).items():
+                st.write(f"• **Zone {zone}**: {count} locations")
+            
+            st.markdown("---")
+            
+            # Top countries by location count
+            top_countries = weather_df['country'].value_counts().head(8)
+            st.markdown("**Top Countries by Weather Locations:**")
+            for country, count in top_countries.items():
+                st.write(f"• **{country}**: {count} locations")
+            
+            # Data sources if available
+            if 'data_source' in weather_df.columns:
+                st.markdown("---")
+                data_sources = weather_df['data_source'].value_counts()
+                st.markdown("**Data Sources:**")
+                for source, count in data_sources.items():
+                    st.write(f"• **{source}**: {count} files")
+        else:
+            st.warning("No weather data available")
+    
+    # Dataset quality metrics
+    st.subheader("🎯 Dataset Quality Metrics")
+    
+    quality_col1, quality_col2, quality_col3, quality_col4 = st.columns(4)
+    
+    with quality_col1:
+        completeness = 0
+        if not buildings_df.empty:
+            total_fields = len(buildings_df.columns)
+            missing_fields = buildings_df.isnull().sum().sum()
+            total_possible = len(buildings_df) * total_fields
+            completeness = ((total_possible - missing_fields) / total_possible) * 100 if total_possible > 0 else 0
+        
+        st.markdown(f"""
+        <div style="background-color: #2d2d2d; border-radius: 10px; padding: 15px; text-align: center; 
+                    border: 1px solid #404040; color: white;">
+            <div style="font-size: 1.5em; margin-bottom: 5px;">📈</div>
+            <div style="font-size: 1.8em; font-weight: bold; color: #4caf50;">{completeness:.1f}%</div>
+            <div style="font-size: 0.9em; opacity: 0.8;">Data Completeness</div>
+        </div>
+        """, unsafe_allow_html=True)
+    
+    with quality_col2:
+        file_coverage = 0
+        if not buildings_df.empty and 'filepath' in buildings_df.columns:
+            existing_files = 0
+            for _, row in buildings_df.iterrows():
+                filepath = Path("data") / row['filepath']
+                if filepath.exists():
+                    existing_files += 1
+            file_coverage = (existing_files / len(buildings_df)) * 100
+        
+        st.markdown(f"""
+        <div style="background-color: #2d2d2d; border-radius: 10px; padding: 15px; text-align: center; 
+                    border: 1px solid #404040; color: white;">
+            <div style="font-size: 1.5em; margin-bottom: 5px;">📁</div>
+            <div style="font-size: 1.8em; font-weight: bold; color: #2196f3;">{file_coverage:.1f}%</div>
+            <div style="font-size: 0.9em; opacity: 0.8;">File Availability</div>
+        </div>
+        """, unsafe_allow_html=True)
+    
+    with quality_col3:
+        diversity_score = 0
+        if not buildings_df.empty:
+            type_entropy = len(buildings_df['building_type'].unique()) / len(buildings_df) * 100
+            climate_entropy = len(buildings_df['climate_zone'].unique()) / len(buildings_df) * 100
+            diversity_score = (type_entropy + climate_entropy) / 2
+        
+        st.markdown(f"""
+        <div style="background-color: #2d2d2d; border-radius: 10px; padding: 15px; text-align: center; 
+                    border: 1px solid #404040; color: white;">
+            <div style="font-size: 1.5em; margin-bottom: 5px;">🎨</div>
+            <div style="font-size: 1.8em; font-weight: bold; color: #ff9800;">{diversity_score:.1f}%</div>
+            <div style="font-size: 0.9em; opacity: 0.8;">Dataset Diversity</div>
+        </div>
+        """, unsafe_allow_html=True)
+    
+    with quality_col4:
+        simulation_readiness = 0
+        if not combinations_df.empty:
+            simulation_readiness = 100
+        elif not buildings_df.empty and not weather_df.empty:
+            simulation_readiness = 75
+        elif not buildings_df.empty or not weather_df.empty:
+            simulation_readiness = 50
+        
+        st.markdown(f"""
+        <div style="background-color: #2d2d2d; border-radius: 10px; padding: 15px; text-align: center; 
+                    border: 1px solid #404040; color: white;">
+            <div style="font-size: 1.5em; margin-bottom: 5px;">⚡</div>
+            <div style="font-size: 1.8em; font-weight: bold; color: #9c27b0;">{simulation_readiness}%</div>
+            <div style="font-size: 0.9em; opacity: 0.8;">Simulation Ready</div>
+        </div>
+        """, unsafe_allow_html=True)
+    
+    # Usage recommendations
+    st.subheader("💡 Usage Recommendations")
+    
+    recommendation_col1, recommendation_col2 = st.columns(2)
+    
+    with recommendation_col1:
+        st.markdown("""
+        <div style="background-color: #1a237e; border-radius: 10px; padding: 20px; margin: 10px 0; 
+                    border-left: 4px solid #3f51b5; color: white;">
+            <h5 style="color: #64b5f6; margin-bottom: 15px;">🔬 Research Applications</h5>
+            <ul style="line-height: 1.8;">
+                <li>Building energy performance analysis</li>
+                <li>Climate change impact studies</li>
+                <li>HVAC system optimization</li>
+                <li>Retrofit strategy evaluation</li>
+                <li>Code compliance verification</li>
+            </ul>
+        </div>
+        """, unsafe_allow_html=True)
+    
+    with recommendation_col2:
+        st.markdown("""
+        <div style="background-color: #1b5e20; border-radius: 10px; padding: 20px; margin: 10px 0; 
+                    border-left: 4px solid #4caf50; color: white;">
+            <h5 style="color: #81c784; margin-bottom: 15px;">⚙️ Getting Started</h5>
+            <ul style="line-height: 1.8;">
+                <li>Use <strong>Building Explorer</strong> to browse models</li>
+                <li>Check <strong>Weather Data</strong> for climate coverage</li>
+                <li>Generate combinations for simulations</li>
+                <li>Export filtered datasets for analysis</li>
+                <li>Run quality checks before processing</li>
+            </ul>
+        </div>
+        """, unsafe_allow_html=True)# dashboard/streamlit_app.py
+"""
+Building Generator Dashboard - Main Streamlit Application
+Interactive web interface for exploring building energy models and weather data
+"""
+
+import streamlit as st
+import pandas as pd
+import plotly.express as px
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+import numpy as np
+from pathlib import Path
+import sys
+import json
+from typing import Dict, List, Optional
+import logging
+
+# Add the project root to Python path
+PROJECT_ROOT = Path(__file__).parent.parent
+sys.path.insert(0, str(PROJECT_ROOT))
+
+from building_gen.core.pipeline import BuildingPipeline
+
+# Configure page
+st.set_page_config(
+    page_title="Building Generator Dashboard",
+    page_icon="🏗️",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Custom CSS for dark theme styling
+st.markdown("""
+<style>
+    .main > div {
+        padding-top: 2rem;
+    }
+    
+    /* Dark theme metric cards */
+    .stMetric {
+        background-color: #1e1e1e;
+        border: 1px solid #333;
+        border-radius: 10px;
+        padding: 15px;
+        margin: 5px 0;
+        color: white;
+    }
+    
+    /* Dark theme filter container */
+    .filter-container {
+        background-color: #2d2d2d;
+        border: 1px solid #404040;
+        border-radius: 10px;
+        padding: 15px;
+        margin: 10px 0;
+        color: white;
+    }
+    
+    /* Dark theme building cards */
+    .building-card {
+        border: 2px solid #404040;
+        border-radius: 10px;
+        padding: 15px;
+        margin: 10px 0;
+        background-color: #1e1e1e;
+        color: white;
+    }
+    
+    /* Dark theme comparison highlight */
+    .comparison-highlight {
+        background-color: #1a237e;
+        border-left: 4px solid #3f51b5;
+        border-radius: 5px;
+        padding: 15px;
+        margin: 5px 0;
+        color: white;
+    }
+    
+    /* Plotly chart dark theme */
+    .js-plotly-plot {
+        background-color: transparent !important;
+    }
+    
+    /* Data editor dark theme */
+    .stDataFrame {
+        background-color: #1e1e1e;
+    }
+    
+    /* Sidebar dark theme adjustments */
+    .css-1d391kg {
+        background-color: #1e1e1e;
+    }
+    
+    /* Success/Info/Warning message styling */
+    .stSuccess {
+        background-color: #1b5e20;
+        border: 1px solid #4caf50;
+    }
+    
+    .stInfo {
+        background-color: #0d47a1;
+        border: 1px solid #2196f3;
+    }
+    
+    .stWarning {
+        background-color: #e65100;
+        border: 1px solid #ff9800;
+    }
+    
+    .stError {
+        background-color: #b71c1c;
+        border: 1px solid #f44336;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+@st.cache_data
+def load_pipeline_data(data_dir: str = "data"):
+    """Load and cache pipeline data"""
+    try:
+        pipeline = BuildingPipeline(data_dir)
+        
+        # Load building data
+        buildings_path = Path(data_dir) / "tables/buildings.csv"
+        buildings_df = pd.read_csv(buildings_path) if buildings_path.exists() else pd.DataFrame()
+        
+        # Load weather data
+        weather_path = Path(data_dir) / "weather/tables/all_weather.csv"
+        weather_df = pd.read_csv(weather_path) if weather_path.exists() else pd.DataFrame()
+        
+        # Load combinations if available
+        combinations_path = Path(data_dir) / "tables/building_weather_combinations.csv"
+        combinations_df = pd.read_csv(combinations_path) if combinations_path.exists() else pd.DataFrame()
+        
+        return pipeline, buildings_df, weather_df, combinations_df
+    except Exception as e:
+        st.error(f"Failed to load data: {e}")
+        return None, pd.DataFrame(), pd.DataFrame(), pd.DataFrame()
+
+def create_building_filters(buildings_df: pd.DataFrame) -> Dict:
+    """Create filter widgets for buildings"""
+    st.markdown('<div class="filter-container">', unsafe_allow_html=True)
+    st.subheader("🔍 Filter Buildings")
+    
+    col1, col2, col3 = st.columns(3)
+    
+    with col1:
+        building_types = st.multiselect(
+            "Building Type",
+            options=sorted(buildings_df['building_type'].unique()) if not buildings_df.empty else [],
+            default=[]
+        )
+        
+        climate_zones = st.multiselect(
+            "Climate Zone", 
+            options=sorted(buildings_df['climate_zone'].unique()) if not buildings_df.empty else [],
+            default=[]
+        )
+    
+    with col2:
+        variation_types = st.multiselect(
+            "Variation Type",
+            options=sorted(buildings_df['variation_type'].unique()) if not buildings_df.empty else [],
+            default=[]
+        )
+        
+        # Floor area range
+        if not buildings_df.empty and 'floor_area' in buildings_df.columns:
+            min_area = float(buildings_df['floor_area'].min())
+            max_area = float(buildings_df['floor_area'].max())
+            area_range = st.slider(
+                "Floor Area Range (m²)",
+                min_value=min_area,
+                max_value=max_area,
+                value=(min_area, max_area),
+                format="%.0f"
+            )
+        else:
+            area_range = (0, 10000)
+    
+    with col3:
+        # Window-to-wall ratio if available
+        if not buildings_df.empty and 'window_wall_ratio' in buildings_df.columns:
+            min_wwr = float(buildings_df['window_wall_ratio'].min())
+            max_wwr = float(buildings_df['window_wall_ratio'].max())
+            wwr_range = st.slider(
+                "Window-to-Wall Ratio",
+                min_value=min_wwr,
+                max_value=max_wwr,
+                value=(min_wwr, max_wwr),
+                format="%.2f"
+            )
+        else:
+            wwr_range = (0.0, 1.0)
+        
+        # Number of zones range
+        if not buildings_df.empty and 'num_zones' in buildings_df.columns:
+            min_zones = int(buildings_df['num_zones'].min())
+            max_zones = int(buildings_df['num_zones'].max())
+            zones_range = st.slider(
+                "Number of Zones",
+                min_value=min_zones,
+                max_value=max_zones,
+                value=(min_zones, max_zones)
+            )
+        else:
+            zones_range = (1, 100)
+    
+    st.markdown('</div>', unsafe_allow_html=True)
+    
+    return {
+        'building_types': building_types,
+        'climate_zones': climate_zones,
+        'variation_types': variation_types,
+        'area_range': area_range,
+        'wwr_range': wwr_range,
+        'zones_range': zones_range
+    }
+
+def apply_building_filters(buildings_df: pd.DataFrame, filters: Dict) -> pd.DataFrame:
+    """Apply filters to buildings dataframe"""
+    filtered_df = buildings_df.copy()
+    
+    if filters['building_types']:
+        filtered_df = filtered_df[filtered_df['building_type'].isin(filters['building_types'])]
+    
+    if filters['climate_zones']:
+        filtered_df = filtered_df[filtered_df['climate_zone'].isin(filters['climate_zones'])]
+    
+    if filters['variation_types']:
+        filtered_df = filtered_df[filtered_df['variation_type'].isin(filters['variation_types'])]
+    
+    if 'floor_area' in filtered_df.columns:
+        filtered_df = filtered_df[
+            (filtered_df['floor_area'] >= filters['area_range'][0]) &
+            (filtered_df['floor_area'] <= filters['area_range'][1])
+        ]
+    
+    if 'window_wall_ratio' in filtered_df.columns:
+        filtered_df = filtered_df[
+            (filtered_df['window_wall_ratio'] >= filters['wwr_range'][0]) &
+            (filtered_df['window_wall_ratio'] <= filters['wwr_range'][1])
+        ]
+    
+    if 'num_zones' in filtered_df.columns:
+        filtered_df = filtered_df[
+            (filtered_df['num_zones'] >= filters['zones_range'][0]) &
+            (filtered_df['num_zones'] <= filters['zones_range'][1])
+        ]
+    
+    return filtered_df
+
+def create_overview_metrics(buildings_df: pd.DataFrame, weather_df: pd.DataFrame, combinations_df: pd.DataFrame):
+    """Create overview metrics display with consistent sizing and dark theme"""
+    col1, col2, col3, col4 = st.columns(4)
+    
+    with col1:
+        st.markdown(f"""
+        <div style="background-color: #2d2d2d; border-radius: 15px; padding: 25px; margin: 10px 0; 
+                    border: 1px solid #404040; color: white; height: 200px; display: flex; 
+                    flex-direction: column; justify-content: space-between;">
+            <div style="display: flex; align-items: center; margin-bottom: 15px;">
+                <span style="font-size: 2em; margin-right: 15px;">🏢</span>
+                <span style="font-size: 1.3em; font-weight: bold;">Buildings</span>
+            </div>
+            <div style="font-size: 3.5em; font-weight: bold; text-align: center; margin: 15px 0;">{len(buildings_df)}</div>
+            <div style="font-size: 1em; text-align: center; opacity: 0.8;">
+                {len(buildings_df[buildings_df['variation_type'] != 'base']) if not buildings_df.empty else 0} variations
+            </div>
+        </div>
+        """, unsafe_allow_html=True)
+    
+    with col2:
+        st.markdown(f"""
+        <div style="background-color: #2d2d2d; border-radius: 15px; padding: 25px; margin: 10px 0; 
+                    border: 1px solid #404040; color: white; height: 200px; display: flex; 
+                    flex-direction: column; justify-content: space-between;">
+            <div style="display: flex; align-items: center; margin-bottom: 15px;">
+                <span style="font-size: 2em; margin-right: 15px;">🌍</span>
+                <span style="font-size: 1.3em; font-weight: bold;">Weather Locations</span>
+            </div>
+            <div style="font-size: 3.5em; font-weight: bold; text-align: center; margin: 15px 0;">{len(weather_df)}</div>
+            <div style="font-size: 1em; text-align: center; opacity: 0.8;">
+                {weather_df['country'].nunique() if not weather_df.empty else 0} countries
+            </div>
+        </div>
+        """, unsafe_allow_html=True)
+    
+    with col3:
+        combinations_status = "Not created" if len(combinations_df) == 0 else "Ready"
+        st.markdown(f"""
+        <div style="background-color: #2d2d2d; border-radius: 15px; padding: 25px; margin: 10px 0; 
+                    border: 1px solid #404040; color: white; height: 200px; display: flex; 
+                    flex-direction: column; justify-content: space-between;">
+            <div style="display: flex; align-items: center; margin-bottom: 15px;">
+                <span style="font-size: 2em; margin-right: 15px;">🔄</span>
+                <span style="font-size: 1.3em; font-weight: bold;">Combinations</span>
+            </div>
+            <div style="font-size: 3.5em; font-weight: bold; text-align: center; margin: 15px 0;">{len(combinations_df)}</div>
+            <div style="font-size: 1em; text-align: center; opacity: 0.8;">
+                {combinations_status}
+            </div>
+        </div>
+        """, unsafe_allow_html=True)
+    
+    with col4:
+        climate_zones = buildings_df['climate_zone'].nunique() if not buildings_df.empty else 0
+        st.markdown(f"""
+        <div style="background-color: #2d2d2d; border-radius: 15px; padding: 25px; margin: 10px 0; 
+                    border: 1px solid #404040; color: white; height: 200px; display: flex; 
+                    flex-direction: column; justify-content: space-between;">
+            <div style="display: flex; align-items: center; margin-bottom: 15px;">
+                <span style="font-size: 2em; margin-right: 15px;">🌡️</span>
+                <span style="font-size: 1.3em; font-weight: bold;">Climate Zones</span>
+            </div>
+            <div style="font-size: 3.5em; font-weight: bold; text-align: center; margin: 15px 0;">{climate_zones}</div>
+            <div style="font-size: 1em; text-align: center; opacity: 0.8;">
+                ASHRAE zones
+            </div>
+        </div>
+        """, unsafe_allow_html=True)
+
+def create_dark_theme_plotly_layout():
+    """Create consistent dark theme layout for Plotly charts"""
+    return {
+        'plot_bgcolor': 'rgba(0,0,0,0)',
+        'paper_bgcolor': 'rgba(0,0,0,0)',
+        'font': {'color': 'white'},
+        'xaxis': {
+            'gridcolor': '#404040',
+            'linecolor': '#404040',
+            'tickcolor': '#404040',
+            'color': 'white'
+        },
+        'yaxis': {
+            'gridcolor': '#404040',
+            'linecolor': '#404040',
+            'tickcolor': '#404040',
+            'color': 'white'
+        }
+    }
+
+def create_building_characteristics_chart(buildings_df: pd.DataFrame):
+    """Create building characteristics visualization with dark theme"""
+    if buildings_df.empty:
+        st.warning("No building data available")
+        return
+    
+    tab1, tab2, tab3, tab4 = st.tabs(["📊 Distribution", "🗺️ Climate Zones", "🏗️ Types", "📏 Properties"])
+    
+    with tab1:
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            # Building type distribution
+            type_counts = buildings_df['building_type'].value_counts()
+            fig_types = px.pie(
+                values=type_counts.values,
+                names=type_counts.index,
+                title="Building Types Distribution",
+                color_discrete_sequence=px.colors.qualitative.Set3
+            )
+            fig_types.update_layout(**create_dark_theme_plotly_layout(), height=400)
+            st.plotly_chart(fig_types, use_container_width=True)
+        
+        with col2:
+            # Variation type distribution
+            var_counts = buildings_df['variation_type'].value_counts()
+            fig_vars = px.bar(
+                x=var_counts.index,
+                y=var_counts.values,
+                title="Variation Types",
+                color=var_counts.index,
+                color_discrete_sequence=px.colors.qualitative.Pastel
+            )
+            fig_vars.update_layout(**create_dark_theme_plotly_layout(), height=400, showlegend=False)
+            st.plotly_chart(fig_vars, use_container_width=True)
+    
+    with tab2:
+        # Climate zone analysis
+        climate_counts = buildings_df['climate_zone'].value_counts()
+        fig_climate = px.bar(
+            x=climate_counts.index,
+            y=climate_counts.values,
+            title="Buildings by Climate Zone",
+            color=climate_counts.values,
+            color_continuous_scale='viridis'
+        )
+        fig_climate.update_layout(**create_dark_theme_plotly_layout(), height=400)
+        st.plotly_chart(fig_climate, use_container_width=True)
+        
+        # Climate zone descriptions
+        climate_descriptions = {
+            '1A': 'Very Hot - Humid', '1B': 'Very Hot - Dry',
+            '2A': 'Hot - Humid', '2B': 'Hot - Dry',
+            '3A': 'Warm - Humid', '3B': 'Warm - Dry', '3C': 'Warm - Marine',
+            '4A': 'Mixed - Humid', '4B': 'Mixed - Dry', '4C': 'Mixed - Marine',
+            '5A': 'Cool - Humid', '5B': 'Cool - Dry', '5C': 'Cool - Marine',
+            '6A': 'Cold - Humid', '6B': 'Cold - Dry',
+            '7': 'Very Cold', '8': 'Subarctic'
+        }
+        
+        st.subheader("Climate Zone Descriptions")
+        for zone in sorted(buildings_df['climate_zone'].unique()):
+            if zone in climate_descriptions:
+                st.info(f"**{zone}**: {climate_descriptions[zone]}")
+    
+    with tab3:
+        # Building type details
+        st.subheader("Building Type Analysis")
+        
+        # Check which columns exist before grouping
+        agg_dict = {'floor_area': ['count']}
+        if 'floor_area' in buildings_df.columns:
+            agg_dict['floor_area'] = ['count', 'mean', 'std']
+        if 'num_zones' in buildings_df.columns:
+            agg_dict['num_zones'] = ['mean', 'std']
+        if 'window_wall_ratio' in buildings_df.columns:
+            agg_dict['window_wall_ratio'] = ['mean', 'std']
+        
+        type_summary = buildings_df.groupby('building_type').agg(agg_dict).round(2)
+        st.dataframe(type_summary, use_container_width=True)
+    
+    with tab4:
+        # Property correlations
+        numeric_cols = []
+        for col in ['floor_area', 'num_zones', 'window_wall_ratio']:
+            if col in buildings_df.columns:
+                numeric_cols.append(col)
+        
+        if len(numeric_cols) >= 2:
+            corr_matrix = buildings_df[numeric_cols].corr()
+            
+            fig_corr = px.imshow(
+                corr_matrix,
+                color_continuous_scale='RdBu',
+                aspect='auto',
+                title='Building Property Correlations'
+            )
+            fig_corr.update_layout(**create_dark_theme_plotly_layout())
+            st.plotly_chart(fig_corr, use_container_width=True)
+            
+            # Scatter plots
+            if len(numeric_cols) >= 2:
+                col1, col2 = st.columns(2)
+                with col1:
+                    if 'floor_area' in numeric_cols and 'num_zones' in numeric_cols:
+                        fig_scatter1 = px.scatter(
+                            buildings_df,
+                            x='floor_area',
+                            y='num_zones',
+                            color='building_type',
+                            title='Floor Area vs Number of Zones',
+                            hover_data=['name']
+                        )
+                        fig_scatter1.update_layout(**create_dark_theme_plotly_layout())
+                        st.plotly_chart(fig_scatter1, use_container_width=True)
+                
+                with col2:
+                    if 'window_wall_ratio' in numeric_cols and 'floor_area' in numeric_cols:
+                        fig_scatter2 = px.scatter(
+                            buildings_df,
+                            x='window_wall_ratio',
+                            y='floor_area',
+                            color='building_type',
+                            title='Window-Wall Ratio vs Floor Area',
+                            hover_data=['name']
+                        )
+                        fig_scatter2.update_layout(**create_dark_theme_plotly_layout())
+                        st.plotly_chart(fig_scatter2, use_container_width=True)
+
+def display_buildings_table(buildings_df: pd.DataFrame):
+    """Display interactive buildings table"""
+    st.subheader("📋 Buildings Database")
+    
+    if buildings_df.empty:
+        st.warning("No buildings found matching the current filters.")
+        return
+    
+    # Prepare column config based on available columns
+    column_config = {
+        "id": st.column_config.NumberColumn("ID", width="small"),
+        "name": st.column_config.TextColumn("Building Name", width="large"),
+        "building_type": st.column_config.TextColumn("Type", width="medium"),
+        "climate_zone": st.column_config.TextColumn("Climate", width="small"),
+        "variation_type": st.column_config.TextColumn("Variation", width="medium"),
+        "filepath": st.column_config.TextColumn("File Path", width="large")
+    }
+    
+    # Add optional columns if they exist
+    if 'floor_area' in buildings_df.columns:
+        column_config["floor_area"] = st.column_config.NumberColumn("Floor Area (m²)", format="%.0f", width="medium")
+    if 'num_zones' in buildings_df.columns:
+        column_config["num_zones"] = st.column_config.NumberColumn("Zones", width="small")
+    if 'window_wall_ratio' in buildings_df.columns:
+        column_config["window_wall_ratio"] = st.column_config.NumberColumn("WWR", format="%.2f", width="small")
+    if 'created_date' in buildings_df.columns:
+        column_config["created_date"] = st.column_config.DatetimeColumn("Created", width="medium")
+    
+    # Display the table
+    selected_buildings = st.data_editor(
+        buildings_df,
+        use_container_width=True,
+        hide_index=True,
+        column_config=column_config,
+        disabled=list(buildings_df.columns)  # Make all columns read-only
+    )
+    
+    # Export functionality
+    col1, col2, col3 = st.columns([1, 1, 2])
+    with col1:
+        if st.button("📥 Export to CSV"):
+            csv = buildings_df.to_csv(index=False)
+            st.download_button(
+                label="Download CSV",
+                data=csv,
+                file_name=f"buildings_filtered_{pd.Timestamp.now().strftime('%Y%m%d_%H%M%S')}.csv",
+                mime="text/csv"
+            )
+
+def load_building_epjson(filepath: str, data_dir: str = "data") -> Optional[Dict]:
+    """Load building epJSON file"""
+    try:
+        full_path = Path(data_dir) / filepath
+        if full_path.exists():
+            with open(full_path, 'r') as f:
+                return json.load(f)
+        else:
+            st.error(f"Building file not found: {full_path}")
+            return None
+    except Exception as e:
+        st.error(f"Error loading building file: {e}")
+        return None
+
+def analyze_building_epjson(epjson_data: Dict) -> Dict:
+    """Analyze epJSON building data and extract key metrics"""
+    analysis = {
+        'zones': 0,
+        'surfaces': 0,
+        'windows': 0,
+        'hvac_systems': 0,
+        'schedules': 0,
+        'materials': 0,
+        'constructions': 0,
+        'has_meters': False,
+        'has_setpoints': False,
+        'timestep': None
+    }
+    
+    # Count building components
+    if 'Zone' in epjson_data:
+        analysis['zones'] = len(epjson_data['Zone'])
+    
+    if 'BuildingSurface:Detailed' in epjson_data:
+        analysis['surfaces'] = len(epjson_data['BuildingSurface:Detailed'])
+    
+    if 'FenestrationSurface:Detailed' in epjson_data:
+        analysis['windows'] = len(epjson_data['FenestrationSurface:Detailed'])
+    
+    if 'Schedule:Compact' in epjson_data:
+        analysis['schedules'] = len(epjson_data['Schedule:Compact'])
+    
+    if 'Material' in epjson_data:
+        analysis['materials'] = len(epjson_data['Material'])
+    
+    if 'Construction' in epjson_data:
+        analysis['constructions'] = len(epjson_data['Construction'])
+    
+    # Check for HVAC systems
+    hvac_objects = ['AirLoopHVAC', 'PlantLoop', 'ZoneHVAC:IdealLoadsAirSystem']
+    analysis['hvac_systems'] = sum(len(epjson_data.get(obj, {})) for obj in hvac_objects)
+    
+    # Check for meters and outputs
+    analysis['has_meters'] = 'Output:Meter' in epjson_data
+    analysis['has_setpoints'] = any('Setpoint' in key for key in epjson_data.keys())
+    
+    # Get timestep
+    if 'Timestep' in epjson_data:
+        timestep_obj = list(epjson_data['Timestep'].values())[0]
+        analysis['timestep'] = timestep_obj.get('number_of_timesteps_per_hour', 'Unknown')
+    
+    return analysis
+
+def create_mock_energy_profile(building_name: str):
+    """Create mock energy profile for demonstration with dark theme"""
+    st.subheader("⚡ Energy Profile (Demo)")
+    st.info("📝 Note: This is demonstration data. Connect to actual EnergyPlus simulation results for real data.")
+    
+    # Mock hourly load profile
+    hours = list(range(24))
+    base_load = 100
+    peak_factor = np.sin(np.array(hours) * np.pi / 12)
+    mock_load = base_load + 50 * peak_factor + np.random.normal(0, 10, 24)
+    mock_load = np.maximum(mock_load, 20)  # Minimum load
+    
+    # Mock monthly energy
+    months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 
+              'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
+    heating_load = [150, 120, 80, 40, 10, 0, 0, 0, 20, 60, 100, 140]
+    cooling_load = [0, 0, 10, 30, 60, 100, 120, 110, 70, 30, 5, 0]
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        # Hourly profile
+        fig_hourly = px.line(
+            x=hours, 
+            y=mock_load,
+            title="Typical Daily Load Profile",
+            labels={'x': 'Hour of Day', 'y': 'Power (kW)'}
+        )
+        fig_hourly.update_traces(line_color='#00d4ff')
+        fig_hourly.update_layout(**create_dark_theme_plotly_layout())
+        st.plotly_chart(fig_hourly, use_container_width=True)
+    
+    with col2:
+        # Monthly profile
+        fig_monthly = go.Figure()
+        fig_monthly.add_trace(go.Bar(x=months, y=heating_load, name='Heating', marker_color='#ff6b6b'))
+        fig_monthly.add_trace(go.Bar(x=months, y=cooling_load, name='Cooling', marker_color='#4ecdc4'))
+        fig_monthly.update_layout(
+            **create_dark_theme_plotly_layout(),
+            title="Monthly Energy Consumption",
+            xaxis_title="Month",
+            yaxis_title="Energy (kWh/m²)",
+            barmode='stack'
+        )
+        st.plotly_chart(fig_monthly, use_container_width=True)
+
+
+
+def main():
+    """Main Streamlit application"""
+    st.title("🏗️ Building Generator Dashboard")
+    st.markdown("Interactive exploration of building energy models and weather data")
+    
+    # Load data
+    with st.spinner("Loading building and weather data..."):
+        pipeline, buildings_df, weather_df, combinations_df = load_pipeline_data()
+    
+    if pipeline is None:
+        st.error("Failed to initialize application. Please check your data directory.")
+        st.info("Make sure you have run: `python scripts/main.py --create-table` and `python scripts/main.py --create-weather-table`")
+        return
+    
+    # Sidebar for navigation
+    st.sidebar.title("🗂️ Navigation")
+    
+    # Initialize session state for page navigation
+    if 'current_page' not in st.session_state:
+        st.session_state.current_page = "🏠 Overview"
+    
+    # Use session state to control the selectbox
+    page_options = ["🏠 Overview", "🏢 Building Explorer", "🌍 Weather Data", "⚖️ Compare Buildings", "📊 Analysis & Reports"]
+    current_index = page_options.index(st.session_state.current_page) if st.session_state.current_page in page_options else 0
+    
+    page = st.sidebar.selectbox(
+        "Choose a page:",
+        page_options,
+        index=current_index,
+        key="page_selector"
+    )
+    
+    # Update session state when selectbox changes
+    if page != st.session_state.current_page:
+        st.session_state.current_page = page
+    
+    # Use the current page from session state
+    current_page = st.session_state.current_page
+    
+    if current_page == "🏠 Overview":
+        st.header("System Overview")
+        
+        # System overview
+        create_overview_metrics(buildings_df, weather_df, combinations_df)
+    
+    elif current_page == "🏢 Building Explorer":
+        st.header("Building Explorer")
+        
+        if buildings_df.empty:
+            st.warning("No building data available. Run `python scripts/main.py --create-table` first.")
+            return
+        
+        # Filters
+        filters = create_building_filters(buildings_df)
+        
+        # Apply filters
+        filtered_buildings = apply_building_filters(buildings_df, filters)
+        
+        st.subheader(f"📊 Found {len(filtered_buildings)} buildings")
+        
+        # Visualizations
+        if not filtered_buildings.empty:
+            create_building_characteristics_chart(filtered_buildings)
+            
+            # Buildings table
+            display_buildings_table(filtered_buildings)
+            
+            # Building details expander
+            if not filtered_buildings.empty:
+                st.subheader("🔍 Building Details")
+                selected_building = st.selectbox(
+                    "Select a building to analyze:",
+                    options=filtered_buildings['name'].tolist(),
+                    index=0
+                )
+                
+                if selected_building:
+                    building_info = filtered_buildings[filtered_buildings['name'] == selected_building].iloc[0]
+                    
+                    col1, col2 = st.columns([1, 2])
+                    
+                    with col1:
+                        st.markdown('<div class="building-card">', unsafe_allow_html=True)
+                        st.subheader(f"📋 {building_info['name']}")
+                        st.write(f"**Type**: {building_info['building_type']}")
+                        st.write(f"**Climate Zone**: {building_info['climate_zone']}")
+                        st.write(f"**Variation**: {building_info['variation_type']}")
+                        
+                        # Add optional fields if they exist
+                        if 'floor_area' in building_info and pd.notna(building_info['floor_area']):
+                            st.write(f"**Floor Area**: {building_info['floor_area']:.0f} m²")
+                        if 'num_zones' in building_info and pd.notna(building_info['num_zones']):
+                            st.write(f"**Zones**: {building_info['num_zones']}")
+                        if 'window_wall_ratio' in building_info and pd.notna(building_info['window_wall_ratio']):
+                            st.write(f"**WWR**: {building_info['window_wall_ratio']:.2%}")
+                        
+                        st.markdown('</div>', unsafe_allow_html=True)
+                    
+                    with col2:
+                        # Load and analyze building file
+                        epjson_data = load_building_epjson(building_info['filepath'])
+                        
+                        if epjson_data:
+                            analysis = analyze_building_epjson(epjson_data)
+                            
+                            st.subheader("🔧 Building Analysis")
+                            
+                            # Create metrics display
+                            metric_col1, metric_col2, metric_col3 = st.columns(3)
+                            
+                            with metric_col1:
+                                st.metric("Zones", analysis['zones'])
+                                st.metric("Surfaces", analysis['surfaces'])
+                            
+                            with metric_col2:
+                                st.metric("Windows", analysis['windows'])
+                                st.metric("HVAC Systems", analysis['hvac_systems'])
+                            
+                            with metric_col3:
+                                st.metric("Schedules", analysis['schedules'])
+                                st.metric("Materials", analysis['materials'])
+                            
+                            # Status indicators
+                            st.subheader("⚡ Processing Status")
+                            status_col1, status_col2, status_col3 = st.columns(3)
+                            
+                            with status_col1:
+                                meter_status = "✅ Yes" if analysis['has_meters'] else "❌ No"
+                                st.metric("Has Meters", meter_status)
+                            
+                            with status_col2:
+                                setpoint_status = "✅ Yes" if analysis['has_setpoints'] else "❌ No"
+                                st.metric("Has Setpoints", setpoint_status)
+                            
+                            with status_col3:
+                                timestep_value = analysis['timestep'] or "Not set"
+                                st.metric("Timesteps/Hour", timestep_value)
+                    
+                    # Mock energy profile
+                    create_mock_energy_profile(selected_building)
+    
+    elif current_page == "🌍 Weather Data":
+        st.header("Weather Data Explorer")
+        
+        if weather_df.empty:
+            st.warning("No weather data available. Run `python scripts/main.py --create-weather-table` first.")
+            return
+        
+        # Weather filters
+        st.subheader("🌡️ Filter Weather Locations")
+        
+        col1, col2, col3 = st.columns(3)
+        
+        with col1:
+            countries = st.multiselect(
+                "Countries",
+                options=sorted(weather_df['country'].unique()),
+                default=[]
+            )
+            
+            climate_zones_weather = st.multiselect(
+                "Climate Zones",
+                options=sorted(weather_df['climate_zone_code'].unique()),
+                default=[]
+            )
+        
+        with col2:
+            if 'data_source' in weather_df.columns:
+                data_sources = st.multiselect(
+                    "Data Sources",
+                    options=weather_df['data_source'].unique(),
+                    default=[]
+                )
+            else:
+                data_sources = []
+            
+            lat_range = st.slider(
+                "Latitude Range",
+                min_value=float(weather_df['latitude'].min()),
+                max_value=float(weather_df['latitude'].max()),
+                value=(float(weather_df['latitude'].min()), float(weather_df['latitude'].max()))
+            )
+        
+        with col3:
+            lon_range = st.slider(
+                "Longitude Range", 
+                min_value=float(weather_df['longitude'].min()),
+                max_value=float(weather_df['longitude'].max()),
+                value=(float(weather_df['longitude'].min()), float(weather_df['longitude'].max()))
+            )
+        
+        # Apply weather filters
+        filtered_weather = weather_df.copy()
+        
+        if countries:
+            filtered_weather = filtered_weather[filtered_weather['country'].isin(countries)]
+        if climate_zones_weather:
+            filtered_weather = filtered_weather[filtered_weather['climate_zone_code'].isin(climate_zones_weather)]
+        if data_sources:
+            filtered_weather = filtered_weather[filtered_weather['data_source'].isin(data_sources)]
+        
+        filtered_weather = filtered_weather[
+            (filtered_weather['latitude'] >= lat_range[0]) &
+            (filtered_weather['latitude'] <= lat_range[1]) &
+            (filtered_weather['longitude'] >= lon_range[0]) &
+            (filtered_weather['longitude'] <= lon_range[1])
+        ]
+        
+        st.subheader(f"🌍 Found {len(filtered_weather)} weather locations")
+        
+        # Weather visualizations
+        tab1, tab2, tab3 = st.tabs(["🗺️ Map", "📊 Distribution", "📋 Table"])
+        
+        with tab1:
+            # World map of weather locations
+            fig_map = px.scatter_mapbox(
+                filtered_weather,
+                lat='latitude',
+                lon='longitude',
+                color='climate_zone_code',
+                hover_data=['place', 'country'],
+                mapbox_style='carto-darkmatter',  # Dark theme map
+                zoom=1,
+                title='Weather Locations Worldwide'
+            )
+            fig_map.update_layout(**create_dark_theme_plotly_layout(), height=600)
+            st.plotly_chart(fig_map, use_container_width=True)
+        
+        with tab2:
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                # Country distribution
+                country_counts = filtered_weather['country'].value_counts().head(15)
+                fig_countries = px.bar(
+                    x=country_counts.values,
+                    y=country_counts.index,
+                    orientation='h',
+                    title='Top 15 Countries by Weather Locations',
+                    color=country_counts.values,
+                    color_continuous_scale='viridis'
+                )
+                fig_countries.update_layout(**create_dark_theme_plotly_layout(), height=500)
+                st.plotly_chart(fig_countries, use_container_width=True)
+            
+            with col2:
+                # Climate zone distribution
+                climate_counts = filtered_weather['climate_zone_code'].value_counts()
+                fig_climate = px.pie(
+                    values=climate_counts.values,
+                    names=climate_counts.index,
+                    title='Climate Zone Distribution',
+                    color_discrete_sequence=px.colors.qualitative.Set3
+                )
+                fig_climate.update_layout(**create_dark_theme_plotly_layout(), height=500)
+                st.plotly_chart(fig_climate, use_container_width=True)
+        
+        with tab3:
+            # Weather locations table
+            st.dataframe(
+                filtered_weather,
+                use_container_width=True,
+                hide_index=True,
+                column_config={
+                    "id": st.column_config.NumberColumn("ID", width="small"),
+                    "place": st.column_config.TextColumn("Location", width="large"),
+                    "country": st.column_config.TextColumn("Country", width="small"),
+                    "climate_zone_code": st.column_config.TextColumn("Climate", width="small"),
+                    "latitude": st.column_config.NumberColumn("Latitude", format="%.2f", width="medium"),
+                    "longitude": st.column_config.NumberColumn("Longitude", format="%.2f", width="medium"),
+                    "elevation": st.column_config.NumberColumn("Elevation (m)", width="medium") if 'elevation' in filtered_weather.columns else None,
+                    "data_source": st.column_config.TextColumn("Source", width="small") if 'data_source' in filtered_weather.columns else None
+                }
+            )
+    
+    elif current_page == "⚖️ Compare Buildings":
+        st.header("Building Comparison Tool")
+        
+        if buildings_df.empty:
+            st.warning("No building data available for comparison.")
+            return
+        
+        st.subheader("Select Buildings to Compare")
+        
+        # Building selection for comparison
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            building1 = st.selectbox(
+                "Building 1:",
+                options=buildings_df['name'].tolist(),
+                key="building1"
+            )
+        
+        with col2:
+            building2 = st.selectbox(
+                "Building 2:",
+                options=buildings_df['name'].tolist(),
+                key="building2"
+            )
+        
+        if building1 and building2 and building1 != building2:
+            # Get building data
+            building1_data = buildings_df[buildings_df['name'] == building1].iloc[0]
+            building2_data = buildings_df[buildings_df['name'] == building2].iloc[0]
+            
+            # Comparison display
+            st.subheader("🔍 Building Comparison")
+            
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                st.markdown('<div class="comparison-highlight">', unsafe_allow_html=True)
+                st.subheader(f"🏢 {building1}")
+                st.write(f"**Type**: {building1_data['building_type']}")
+                st.write(f"**Climate Zone**: {building1_data['climate_zone']}")
+                st.write(f"**Variation**: {building1_data['variation_type']}")
+                
+                # Add optional fields if they exist
+                for field, label in [('floor_area', 'Floor Area'), ('num_zones', 'Zones'), ('window_wall_ratio', 'WWR')]:
+                    if field in building1_data and pd.notna(building1_data[field]):
+                        if field == 'floor_area':
+                            st.write(f"**{label}**: {building1_data[field]:.0f} m²")
+                        elif field == 'window_wall_ratio':
+                            st.write(f"**{label}**: {building1_data[field]:.2%}")
+                        else:
+                            st.write(f"**{label}**: {building1_data[field]}")
+                
+                st.markdown('</div>', unsafe_allow_html=True)
+            
+            with col2:
+                st.markdown('<div class="comparison-highlight">', unsafe_allow_html=True)
+                st.subheader(f"🏢 {building2}")
+                st.write(f"**Type**: {building2_data['building_type']}")
+                st.write(f"**Climate Zone**: {building2_data['climate_zone']}")
+                st.write(f"**Variation**: {building2_data['variation_type']}")
+                
+                # Add optional fields if they exist
+                for field, label in [('floor_area', 'Floor Area'), ('num_zones', 'Zones'), ('window_wall_ratio', 'WWR')]:
+                    if field in building2_data and pd.notna(building2_data[field]):
+                        if field == 'floor_area':
+                            st.write(f"**{label}**: {building2_data[field]:.0f} m²")
+                        elif field == 'window_wall_ratio':
+                            st.write(f"**{label}**: {building2_data[field]:.2%}")
+                        else:
+                            st.write(f"**{label}**: {building2_data[field]}")
+                
+                st.markdown('</div>', unsafe_allow_html=True)
+            
+            # Load and compare epJSON files
+            st.subheader("🔧 Technical Comparison")
+            
+            epjson1 = load_building_epjson(building1_data['filepath'])
+            epjson2 = load_building_epjson(building2_data['filepath'])
+            
+            if epjson1 and epjson2:
+                analysis1 = analyze_building_epjson(epjson1)
+                analysis2 = analyze_building_epjson(epjson2)
+                
+                # Technical comparison table
+                tech_comparison = pd.DataFrame({
+                    'Component': ['Zones', 'Surfaces', 'Windows', 'HVAC Systems', 'Schedules', 'Materials'],
+                    building1: [
+                        analysis1['zones'], analysis1['surfaces'], analysis1['windows'],
+                        analysis1['hvac_systems'], analysis1['schedules'], analysis1['materials']
+                    ],
+                    building2: [
+                        analysis2['zones'], analysis2['surfaces'], analysis2['windows'],
+                        analysis2['hvac_systems'], analysis2['schedules'], analysis2['materials']
+                    ]
+                })
+                
+                # Add difference column
+                tech_comparison['Difference'] = tech_comparison[building2] - tech_comparison[building1]
+                
+                st.dataframe(tech_comparison, use_container_width=True)
+                
+                # Processing status comparison
+                st.subheader("⚡ Processing Status Comparison")
+                
+                status_comparison = pd.DataFrame({
+                    'Status': ['Has Meters', 'Has Setpoints', 'Timesteps/Hour'],
+                    building1: [
+                        "✅" if analysis1['has_meters'] else "❌",
+                        "✅" if analysis1['has_setpoints'] else "❌",
+                        str(analysis1['timestep'] or 'Not set')
+                    ],
+                    building2: [
+                        "✅" if analysis2['has_meters'] else "❌",
+                        "✅" if analysis2['has_setpoints'] else "❌",
+                        str(analysis2['timestep'] or 'Not set')
+                    ]
+                })
+                
+                st.dataframe(status_comparison, use_container_width=True)
+        else:
+            st.info("Please select two different buildings to compare.")
+    
+    elif current_page == "📊 Analysis & Reports":
+        st.header("Analysis & Reports")
+        
+        if buildings_df.empty:
+            st.warning("No building data available for analysis.")
+            return
+        
+        # Analysis options
+        analysis_type = st.selectbox(
+            "Choose analysis type:",
+            ["📈 Statistical Summary", "🔍 Data Quality Check", "📋 Detailed Report", "🎯 Custom Analysis"]
+        )
+        
+        if analysis_type == "📈 Statistical Summary":
+            st.subheader("Statistical Summary")
+            
+            # Numeric column statistics
+            numeric_cols = []
+            for col in ['floor_area', 'num_zones', 'window_wall_ratio']:
+                if col in buildings_df.columns:
+                    numeric_cols.append(col)
+            
+            if numeric_cols:
+                st.write("**Numeric Properties Statistics:**")
+                stats_df = buildings_df[numeric_cols].describe()
+                st.dataframe(stats_df, use_container_width=True)
+            
+            # Categorical distributions
+            st.write("**Categorical Distributions:**")
+            
+            col1, col2 = st.columns(2)
+            with col1:
+                if 'building_type' in buildings_df.columns:
+                    type_dist = buildings_df['building_type'].value_counts()
+                    st.write("Building Types:")
+                    st.bar_chart(type_dist)
+            
+            with col2:
+                if 'climate_zone' in buildings_df.columns:
+                    climate_dist = buildings_df['climate_zone'].value_counts()
+                    st.write("Climate Zones:")
+                    st.bar_chart(climate_dist)
+        
+        elif analysis_type == "🔍 Data Quality Check":
+            st.subheader("Data Quality Assessment")
+            
+            # Missing data check
+            missing_data = buildings_df.isnull().sum()
+            if missing_data.sum() > 0:
+                st.write("**Missing Data:**")
+                missing_df = missing_data[missing_data > 0].to_frame('Missing Count')
+                missing_df['Percentage'] = (missing_df['Missing Count'] / len(buildings_df) * 100).round(2)
+                st.dataframe(missing_df)
+            else:
+                st.success("✅ No missing data found!")
+            
+            # Duplicate check
+            duplicates = buildings_df.duplicated().sum()
+            if duplicates > 0:
+                st.warning(f"⚠️ Found {duplicates} duplicate rows")
+            else:
+                st.success("✅ No duplicate rows found!")
+            
+            # File existence check
+            if 'filepath' in buildings_df.columns:
+                st.write("**File Existence Check:**")
+                missing_files = []
+                for idx, row in buildings_df.iterrows():
+                    filepath = Path("data") / row['filepath']
+                    if not filepath.exists():
+                        missing_files.append(row['name'])
+                
+                if missing_files:
+                    st.error(f"❌ {len(missing_files)} building files not found")
+                    with st.expander("Show missing files"):
+                        for file in missing_files[:10]:  # Show first 10
+                            st.write(f"- {file}")
+                        if len(missing_files) > 10:
+                            st.write(f"... and {len(missing_files) - 10} more")
+                else:
+                    st.success("✅ All building files exist!")
+        
+        elif analysis_type == "📋 Detailed Report":
+            st.subheader("Generate Detailed Report")
+            
+            # Report options
+            include_weather = st.checkbox("Include weather data analysis", value=True)
+            include_combinations = st.checkbox("Include combination analysis", value=True)
+            
+            if st.button("Generate Report"):
+                with st.spinner("Generating report..."):
+                    # Generate comprehensive report
+                    report_data = {
+                        'timestamp': pd.Timestamp.now(),
+                        'buildings_total': len(buildings_df),
+                        'weather_total': len(weather_df) if not weather_df.empty else 0,
+                        'combinations_total': len(combinations_df) if not combinations_df.empty else 0
+                    }
+                    
+                    st.success("📊 Report generated successfully!")
+                    
+                    # Display key metrics
+                    metric_col1, metric_col2, metric_col3 = st.columns(3)
+                    
+                    with metric_col1:
+                        st.metric("Buildings Analyzed", report_data['buildings_total'])
+                    
+                    with metric_col2:
+                        if include_weather:
+                            st.metric("Weather Locations", report_data['weather_total'])
+                    
+                    with metric_col3:
+                        if include_combinations:
+                            st.metric("Combinations", report_data['combinations_total'])
+                    
+                    # Download report
+                    report_text = f"""
+Building Generator Analysis Report
+Generated: {report_data['timestamp']}
+
+Summary Statistics:
+- Total Buildings: {report_data['buildings_total']}
+- Weather Locations: {report_data['weather_total']}
+- Simulation Combinations: {report_data['combinations_total']}
+
+Building Type Distribution:
+{buildings_df['building_type'].value_counts().to_string() if not buildings_df.empty else 'No data'}
+
+Climate Zone Distribution:
+{buildings_df['climate_zone'].value_counts().to_string() if not buildings_df.empty else 'No data'}
+                    """
+                    
+                    st.download_button(
+                        label="📥 Download Report",
+                        data=report_text,
+                        file_name=f"building_analysis_report_{pd.Timestamp.now().strftime('%Y%m%d_%H%M%S')}.txt",
+                        mime="text/plain"
+                    )
+        
+        elif analysis_type == "🎯 Custom Analysis":
+            st.subheader("Custom Analysis")
+            st.info("🚧 Custom analysis features coming soon! This will include:")
+            
+            col1, col2 = st.columns(2)
+            with col1:
+                st.markdown("""
+                **Planned Features:**
+                - Building performance correlation analysis
+                - Climate impact assessment
+                - Variation effectiveness studies
+                - Energy consumption modeling
+                - Optimization recommendations
+                """)
+            
+            with col2:
+                st.markdown("""
+                **Interactive Tools:**
+                - Custom filter combinations
+                - Advanced statistical analysis
+                - Machine learning insights
+                - Predictive modeling
+                - Export to research formats
+                """)
+
+if __name__ == "__main__":
+    main()