gradio

README.md

@@ -3,10 +3,10 @@ title: Solar Savings
 emoji: ⚡
 colorFrom: yellow
 colorTo: red
-sdk: gradio
-sdk_version: 5.29.0
+sdk: streamlit
+sdk_version: 1.44.1
 app_file: app.py
 pinned: false
 ---
 
-Check out the configuration reference at <https://huggingface.co/docs/hub/spaces-config-reference>
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -1,49 +1,88 @@
-import gradio as gr
+# Constants
+import numpy as np
 import pandas as pd
 import matplotlib.pyplot as plt
 import seaborn as sns
+import streamlit as st
 from typing import Dict
+from utils.llm import summary_generation
 
-# Constants (replace with your actual values)
-FEED_IN_TARIFF = 12.0  # Example value in cents/kWh
-SOLAR_PANEL_RATING = 625  # Watts
 ONE_BR_UNITS = 23
 TWO_BR_UNITS = 45
-
-
-def initialize_state():
-    return {
-        "solar_panels": 20,
-        "batteries": 5,
-        "panel_price": 25000,
-        "battery_price": 50000,
-        "grid_price": 24.0,
+SOLAR_PANEL_RATING = 625  # W
+BATTERY_CAPACITY = 200  # Ah
+BATTERY_VOLTAGE = 96  # V
+SYSTEM_LOSSES = 0.20
+FEED_IN_TARIFF = 12
+
+# Lighting specifications
+LIGHTS_1BR = 5
+LIGHTS_2BR = 12
+LIGHT_POWER = 6  # Watts per light
+
+
+def initialize_session_state():
+    """Initialize session state variables"""
+    defaults = {
+        "solar_panels": 25,
+        "batteries": 10,
+        "panel_price": 13000,
+        "battery_price": 39000,
+        "grid_price": 28.44,
     }
+    for key, value in defaults.items():
+        if key not in st.session_state:
+            st.session_state[key] = value
 
 
-state = initialize_state()
-
-
-def battery_storage(num_batteries):
-    return num_batteries * 2.4  # kWh per battery
+def calculate_lighting_consumption(occupancy_1br: float, occupancy_2br: float) -> float:
+    """Calculate daily lighting consumption"""
+    return (
+        (occupancy_1br * ONE_BR_UNITS * LIGHTS_1BR * LIGHT_POWER / 1000)
+        + (occupancy_2br * TWO_BR_UNITS * LIGHTS_2BR * LIGHT_POWER / 1000)
+    ) * 6  # 6 hours per day
 
 
-def solar_production(num_panels):
-    return num_panels * SOLAR_PANEL_RATING / 1000 * 5  # 5 sun hours per day
+# assuming that 1br average usage is 250wh and for a 2br is 400wh
 
 
-def calculate_lighting_consumption(occupancy_1br, occupancy_2br):
-    return (occupancy_1br * ONE_BR_UNITS * 0.5) + (occupancy_2br * TWO_BR_UNITS * 0.8)
+def calculate_appliance_consumption(
+    occupancy_1br: float, occupancy_2br: float
+) -> float:
+    """Calculate daily appliance consumption by subtracting the lighting usage from the average total consumption for each house type"""
+    return (
+        occupancy_1br
+        * ONE_BR_UNITS
+        * (3 - (LIGHTS_1BR * LIGHT_POWER * 6 / 1000))
+        # + (500 * 24)  # Fridge
+    ) + (
+        occupancy_2br
+        * TWO_BR_UNITS
+        * (4 - (LIGHTS_2BR * LIGHT_POWER * 6 / 1000))
+        # + (500 * 24)  # Fridge
+    )  # Daily kWh
+
+
+def total_consumption(
+    occupancy_1br: float, occupancy_2br: float, common_area: float
+) -> float:
+    """Calculate total monthly consumption"""
+    lighting = calculate_lighting_consumption(occupancy_1br, occupancy_2br)
+    appliances = calculate_appliance_consumption(occupancy_1br, occupancy_2br)
+    return (lighting + appliances + common_area) * 30  # Monthly kWh
 
 
-def calculate_appliance_consumption(occupancy_1br, occupancy_2br):
-    return (occupancy_1br * ONE_BR_UNITS * 2.0) + (occupancy_2br * TWO_BR_UNITS * 3.0)
+def solar_production(panels: int) -> float:
+    """Monthly solar production with losses"""
+    daily_production = (
+        panels * SOLAR_PANEL_RATING * 6.5 * (1 - SYSTEM_LOSSES) / 1000
+    )  # 6.5 sun hours
+    return daily_production * 30  # Monthly kWh
 
 
-def total_consumption(occupancy_1br, occupancy_2br, common_area):
-    lighting = calculate_lighting_consumption(occupancy_1br, occupancy_2br)
-    appliances = calculate_appliance_consumption(occupancy_1br, occupancy_2br)
-    return lighting + appliances + common_area
+def battery_storage(batteries: int) -> float:
+    """Usable battery capacity"""
+    return batteries * BATTERY_CAPACITY * BATTERY_VOLTAGE * 0.8 / 1000  # kWh
 
 
 def financial_analysis(
@@ -63,12 +102,12 @@ def financial_analysis(
         # Battery can offset some grid purchases
         grid_offset = min(grid_purchased, storage)
         grid_purchased -= grid_offset
-
-    monthly_savings = consumption * state["grid_price"] / 100
+    # Money paid to owner if client used this instead o
+    monthly_savings = consumption * st.session_state.grid_price / 100
 
     total_investment = (
-        state["solar_panels"] * state["panel_price"]
-        + state["batteries"] * state["battery_price"]
+        st.session_state.solar_panels * st.session_state.panel_price
+        + st.session_state.batteries * st.session_state.battery_price
     )
 
     # Avoid division by zero
@@ -101,154 +140,517 @@ def create_consumption_breakdown(
     return pd.DataFrame.from_dict(breakdown, orient="index", columns=["kWh"])
 
 
-def update_state(solar_panels, batteries, panel_price, battery_price, grid_price):
-    state["solar_panels"] = solar_panels
-    state["batteries"] = batteries
-    state["panel_price"] = panel_price
-    state["battery_price"] = battery_price
-    state["grid_price"] = grid_price
-    return state
+# Streamlit Interface
+def main():
+    st.set_page_config(page_title="Solar Analysis Suite", page_icon="🌞", layout="wide")
+    initialize_session_state()
+
+    # Custom CSS
+    st.markdown(
+        """
+        <style>
+        .main .block-container {padding-top: 2rem;}
+        h1, h2, h3 {color: #1E88E5;}
+        .stExpander {border-radius: 8px; border: 1px solid #1E88E5;}
+        .stTabs [data-baseweb="tab-list"] {gap: 10px;}
+        .stTabs [data-baseweb="tab"] {
+            height: 50px;
+            white-space: pre-wrap;
+            background-color: #F0F2F6;
+            border-radius: 4px 4px 0px 0px;
+            gap: 1px;
+            padding-top: 10px;
+            padding-bottom: 10px;
+        }
+        .stTabs [aria-selected="true"] {
+            background-color: #1E88E5;
+            color: white;
+        }
+        </style>
+    """,
+        unsafe_allow_html=True,
+    )
 
+    # Header with logo
+    col1, col2 = st.columns([1, 4])
+    with col1:
+        st.image("https://img.icons8.com/fluency/96/000000/sun.png", width=100)
+    with col2:
+        st.title("🌞 Advanced Solar Performance Analyzer")
+        st.markdown(
+            "Optimize your apartment complex solar installation with data-driven insights"
+        )
 
-def analyze_scenario(occupancy_1br, occupancy_2br, common_area):
-    consumption = total_consumption(occupancy_1br, occupancy_2br, common_area)
-    production = solar_production(state["solar_panels"])
-    storage = battery_storage(state["batteries"])
+    # Sidebar for system configuration
+    with st.sidebar:
+        st.header("System Configuration")
 
-    financials = financial_analysis(consumption, common_area, production, storage)
-    breakdown_df = create_consumption_breakdown(
-        occupancy_1br, occupancy_2br, common_area
-    )
+        # Add a nice header image
+        st.image("https://img.icons8.com/color/96/000000/solar-panel.png", width=80)
 
-    # Create plots
-    fig1, ax1 = plt.subplots(figsize=(10, 5))
-    energy_sources = ["Solar", "Grid"]
-    values = [financials["solar_contribution"], financials["grid_dependency"]]
-    ax1.bar(energy_sources, values, color=["#4CAF50", "#F44336"])
-    ax1.set_ylabel("Percentage (%)")
-    ax1.set_title("Energy Contribution")
-
-    fig2, ax2 = plt.subplots(figsize=(8, 8))
-    breakdown_df["Percentage"] = (
-        breakdown_df["kWh"] / breakdown_df["kWh"].sum() * 100
-    ).round(1)
-    breakdown_df.plot.pie(
-        y="kWh",
-        labels=breakdown_df.index,
-        autopct="%1.1f%%",
-        colors=["#FF9800", "#2196F3", "#4CAF50"],
-        ax=ax2,
-    )
-    ax2.set_ylabel("")
+        # Create tabs for different settings
+        tab1, tab2 = st.tabs(["Hardware", "Pricing"])
 
-    return (
-        f"Total Consumption: {consumption:.1f} kWh/day\n"
-        f"Solar Production: {production:.1f} kWh/day\n"
-        f"Solar Contribution: {financials['solar_contribution']:.1f}%\n"
-        f"Monthly Savings: {financials['monthly_savings']:,.0f} Ksh\n"
-        f"Payback Period: {financials['payback_period']:.1f} years",
-        fig1,
-        fig2,
-        breakdown_df,
-    )
+        with tab1:
+            st.number_input(
+                "Number of Solar Panels",
+                1,
+                300,
+                step=5,
+                key="solar_panels",
+                help="Each panel rated at 625W",
+            )
+            st.number_input(
+                "Number of Batteries",
+                0,
+                150,
+                step=5,
+                key="batteries",
+                help="Each battery has 200Ah capacity at 12V",
+            )
+
+        with tab2:
+            st.number_input(
+                "Panel Price (Ksh)",
+                1000,
+                50000,
+                step=500,
+                key="panel_price",
+                help="Cost per solar panel",
+            )
+            st.number_input(
+                "Battery Price (Ksh)",
+                5000,
+                100000,
+                step=1000,
+                key="battery_price",
+                help="Cost per battery unit",
+            )
+            st.number_input(
+                "Grid Price (Ksh/kWh)",
+                10.0,
+                50.0,
+                step=0.1,
+                key="grid_price",
+                help="Current electricity price from the grid",
+            )
 
+        st.markdown("---")
+        st.markdown(
+            """
+        📊 **System Totals**
+        - **Total Panel Capacity**: {0:.1f} kW
+        - **Total Battery Storage**: {1:.1f} kWh
+        - **Total Investment**: ksh. {2:,.0f}
+          """.format(
+                st.session_state.solar_panels * SOLAR_PANEL_RATING / 1000,
+                battery_storage(st.session_state.batteries),
+                st.session_state.solar_panels * st.session_state.panel_price
+                + st.session_state.batteries * st.session_state.battery_price,
+            )
+        )
 
-with gr.Blocks(title="Solar Analysis Suite", theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# 🌞 Advanced Solar Performance Analyzer")
-    gr.Markdown(
-        "Optimize your apartment complex solar installation with data-driven insights"
+    # Main content
+    # Create scenarios with varying occupancy levels
+    scenarios = {}
+
+    # Common area consumption remains constant
+    common_area_consumption = 23.544  # kWh per day
+
+    # Generate scenarios with different occupancy combinations
+    occupancy_levels = [0.0, 0.25, 0.50, 0.75, 1.0]
+
+    # Create scenarios for 1BR fixed, varying 2BR
+    for br1_level in occupancy_levels:
+        for br2_level in occupancy_levels:
+            scenario_name = f"1BR: {int(br1_level*100)}%, 2BR: {int(br2_level*100)}%"
+            scenarios[scenario_name] = {
+                "1br": br1_level,
+                "2br": br2_level,
+                "common": common_area_consumption,
+            }
+
+    # Analysis tabs
+    st.markdown("---")
+    tab1, tab2, tab3 = st.tabs(
+        ["📊 Energy Analysis", "💰 Financial Metrics", "🔍 Detailed Breakdown"]
     )
 
-    with gr.Row():
-        with gr.Column(scale=1):
-            gr.Markdown("## System Configuration")
+    # Prepare analysis data for all scenarios
+    analysis_data = []
+    for name, params in scenarios.items():
+        consumption = total_consumption(params["1br"], params["2br"], params["common"])
+        production = solar_production(st.session_state.solar_panels)
+        storage = battery_storage(st.session_state.batteries)
+        financials = financial_analysis(
+            consumption, common_area_consumption, production, storage
+        )
+        analysis_data.append({"Scenario": name, **financials})
 
-            with gr.Tab("Hardware"):
-                solar_panels = gr.Slider(
-                    1, 300, value=20, step=5, label="Number of Solar Panels"
-                )
-                batteries = gr.Slider(
-                    0, 150, value=5, step=5, label="Number of Batteries"
-                )
+    df = pd.DataFrame(analysis_data)
 
-            with gr.Tab("Pricing"):
-                panel_price = gr.Slider(
-                    1000, 50000, value=25000, step=500, label="Panel Price (Ksh)"
-                )
-                battery_price = gr.Slider(
-                    5000, 100000, value=50000, step=1000, label="Battery Price (Ksh)"
-                )
-                grid_price = gr.Slider(
-                    10.0, 50.0, value=24.0, step=0.1, label="Grid Price (Ksh/kWh)"
-                )
+    # Tab 1: Energy Analysis
+    with tab1:
+        st.header("Energy Flow Analysis")
+
+        # Allow filtering by 1BR occupancy
+        one_br_filter = st.selectbox(
+            "Filter by 1BR Occupancy",
+            ["All"] + [f"{int(level*100)}%" for level in occupancy_levels],
+            help="Filter scenarios by 1BR occupancy level",
+        )
+
+        # Filter the dataframe based on selection
+        filtered_df = df
+        if one_br_filter != "All":
+            occupancy_value = int(one_br_filter.replace("%", ""))
+            filtered_df = df[df["Scenario"].str.contains(f"1BR: {occupancy_value}%")]
+
+        # Chart 1: Energy Balance
+        st.subheader("Energy Balance by Scenario")
+
+        energy_fig = plt.figure(figsize=(12, 7))
+        ax = energy_fig.add_subplot(111)
+
+        # Create data for stacked bar chart
+        chart_data = filtered_df.copy()
+        chart_data["grid_energy"] = chart_data["grid_purchased"]
+        chart_data["solar_energy"] = (
+            chart_data["consumption"] - chart_data["grid_purchased"]
+        )
+
+        # Create normalized stacked bar chart
+        chart_data = chart_data.set_index("Scenario")
+        energy_proportions = (
+            chart_data[["solar_energy", "grid_energy"]].div(
+                chart_data["consumption"], axis=0
+            )
+            * 100
+        )
+        energy_proportions = energy_proportions.reset_index()
+
+        # Reshape for seaborn
+        energy_melt = pd.melt(
+            energy_proportions,
+            id_vars=["Scenario"],
+            value_vars=["solar_energy", "grid_energy"],
+            var_name="Energy Source",
+            value_name="Percentage",
+        )
 
-            update_btn = gr.Button("Update System Configuration")
+        # Rename for better labels
+        energy_melt["Energy Source"] = energy_melt["Energy Source"].replace(
+            {"solar_energy": "Solar Generated", "grid_energy": "Grid Purchased"}
+        )
 
-            gr.Markdown("### System Totals")
-            total_panel = gr.Textbox(
-                label="Total Panel Capacity (kW)", interactive=False
+        # Plot with seaborn
+        sns.set_theme(style="whitegrid")
+        sns.barplot(
+            data=energy_melt,
+            x="Scenario",
+            y="Percentage",
+            hue="Energy Source",
+            palette=["#4CAF50", "#F44336"],
+            ax=ax,
+        )
+        ax.set_ylabel("Energy Contribution (%)")
+        ax.set_title("Energy Source Distribution by Occupancy Scenario")
+        plt.xticks(rotation=45, ha="right")
+        plt.tight_layout()
+        st.pyplot(energy_fig)
+
+        # Detailed metrics
+        col1, col2, col3 = st.columns(3)
+        with col1:
+            st.metric(
+                "Avg. Solar Contribution",
+                f"{filtered_df['solar_contribution'].mean():.1f}%",
+                (
+                    f"{filtered_df['solar_contribution'].mean() - 50:.1f}%"
+                    if filtered_df["solar_contribution"].mean() > 50
+                    else f"{filtered_df['solar_contribution'].mean() - 50:.1f}%"
+                ),
             )
-            total_battery = gr.Textbox(
-                label="Total Battery Storage (kWh)", interactive=False
+        with col2:
+            st.metric(
+                "Avg. Grid Dependency",
+                f"{filtered_df['grid_dependency'].mean():.1f}%",
+                (
+                    f"{50 - filtered_df['grid_dependency'].mean():.1f}%"
+                    if filtered_df["grid_dependency"].mean() < 50
+                    else f"{50 - filtered_df['grid_dependency'].mean():.1f}%"
+                ),
             )
-            total_investment = gr.Textbox(
-                label="Total Investment (Ksh)", interactive=False
+        with col3:
+            st.metric(
+                "Production/Consumption Ratio",
+                f"{(filtered_df['production'].mean() / filtered_df['consumption'].mean() * 100):.1f}%",
             )
 
-        with gr.Column(scale=2):
-            gr.Markdown("## Scenario Analysis")
+        with st.expander("🔍 Energy Flow Interpretation"):
+            st.markdown(
+                """
+                **Understanding the Chart:**
+                - **Solar Contribution**: Percentage of total energy needs met directly by solar production
+                - **Grid Dependency**: Remaining energy required from the grid
+                - The ideal scenario shows high solar contribution with minimal grid dependency
+                
+                **Key Factors Affecting Energy Balance:**
+                1. **Occupancy Levels**: Higher occupancy means higher consumption, which may exceed solar capacity
+                2. **Solar System Size**: More panels increase production and reduce grid dependency
+                3. **Battery Storage**: Helps utilize excess daytime production for nighttime use
+                """
+            )
 
-            with gr.Tab("Input Parameters"):
-                occupancy_1br = gr.Slider(
-                    0.0, 1.0, value=0.5, step=0.25, label="1BR Occupancy Rate"
-                )
-                occupancy_2br = gr.Slider(
-                    0.0, 1.0, value=0.5, step=0.25, label="2BR Occupancy Rate"
-                )
-                common_area = gr.Number(
-                    value=23.544, label="Common Area Consumption (kWh/day)"
-                )
-                analyze_btn = gr.Button("Analyze Scenario")
-
-            with gr.Tab("Results"):
-                results_text = gr.Textbox(label="Analysis Results", lines=5)
-                energy_plot = gr.Plot(label="Energy Contribution")
-                breakdown_plot = gr.Plot(label="Consumption Breakdown")
-                breakdown_table = gr.Dataframe(label="Detailed Breakdown")
-
-    # Update system totals when configuration changes
-    def update_totals(solar_panels, batteries, panel_price, battery_price):
-        panel_kw = solar_panels * SOLAR_PANEL_RATING / 1000
-        battery_kwh = battery_storage(batteries)
-        investment = solar_panels * panel_price + batteries * battery_price
-        return (
-            f"{panel_kw:.1f} kW",
-            f"{battery_kwh:.1f} kWh",
-            f"{investment:,.0f} Ksh",
+    # Tab 2: Financial Metrics
+    with tab2:
+        st.header("Financial Performance Analysis")
+
+        # Allow filtering by 2BR occupancy
+        two_br_filter = st.selectbox(
+            "Filter by 2BR Occupancy",
+            ["All"] + [f"{int(level*100)}%" for level in occupancy_levels],
+            help="Filter scenarios by 2BR occupancy level",
         )
 
-    update_btn.click(
-        update_state,
-        inputs=[solar_panels, batteries, panel_price, battery_price, grid_price],
-        outputs=None,
-    ).then(
-        update_totals,
-        inputs=[solar_panels, batteries, panel_price, battery_price],
-        outputs=[total_panel, total_battery, total_investment],
-    )
+        # Filter the dataframe based on selection
+        filtered_fin_df = df
+        if two_br_filter != "All":
+            occupancy_value = int(two_br_filter.replace("%", ""))
+            filtered_fin_df = df[
+                df["Scenario"].str.contains(f"2BR: {occupancy_value}%")
+            ]
+
+        # Monthly Savings Chart
+        st.subheader("Monthly Cost Savings")
+
+        # Fix large values
+        filtered_fin_df["monthly_savings_fixed"] = filtered_fin_df[
+            "monthly_savings"
+        ].clip(0, 100000)
+
+        fig1, ax1 = plt.subplots(figsize=(12, 6))
+        sns.barplot(
+            data=filtered_fin_df,
+            x="Scenario",
+            y="monthly_savings_fixed",
+            palette="viridis",
+            ax=ax1,
+        )
+        ax1.set_title("Monthly Cost Savings by Scenario")
+        ax1.set_ylabel("Ksh")
+        plt.xticks(rotation=45, ha="right")
+        plt.tight_layout()
+        st.pyplot(fig1)
+
+        # Payback Period Chart
+        st.subheader("System Payback Period")
+
+        # Fix large values
+        filtered_fin_df["payback_period_fixed"] = filtered_fin_df[
+            "payback_period"
+        ].clip(0, 30)
+
+        fig2, ax2 = plt.subplots(figsize=(12, 6))
+        sns.barplot(
+            data=filtered_fin_df,
+            x="Scenario",
+            y="payback_period_fixed",
+            palette="rocket_r",
+            ax=ax2,
+        )
+        ax2.set_title("Investment Payback Period by Scenario")
+        ax2.set_ylabel("Years")
+        plt.xticks(rotation=45, ha="right")
+        plt.tight_layout()
+        st.pyplot(fig2)
+
+        # Financial summary metrics
+        col1, col2, col3 = st.columns(3)
+        with col1:
+            avg_savings = filtered_fin_df["monthly_savings"].mean()
+            st.metric(
+                "Avg. Monthly Savings",
+                f"{avg_savings:,.0f} Ksh",
+                (
+                    f"{avg_savings - df['monthly_savings'].mean():,.0f} Ksh"
+                    if avg_savings > df["monthly_savings"].mean()
+                    else f"{avg_savings - df['monthly_savings'].mean():,.0f} Ksh"
+                ),
+            )
+        with col2:
+            min_payback = filtered_fin_df["payback_period"].min()
+            st.metric(
+                "Best Payback Period",
+                f"{min_payback:.1f} years",
+                help="Shortest time to recover investment",
+            )
+        with col3:
+            total_investment = (
+                st.session_state.solar_panels * st.session_state.panel_price
+                + st.session_state.batteries * st.session_state.battery_price
+            )
+            annual_roi = (
+                (avg_savings * 12 / total_investment) * 100
+                if total_investment > 0
+                else 0
+            )
+            st.metric(
+                "Annual ROI", f"{annual_roi:.1f}%", help="Annual Return on Investment"
+            )
 
-    analyze_btn.click(
-        analyze_scenario,
-        inputs=[occupancy_1br, occupancy_2br, common_area],
-        outputs=[results_text, energy_plot, breakdown_plot, breakdown_table],
-    )
+        with st.expander("💵 Financial Analysis Details"):
+            st.markdown(
+                f"""
+                **Investment Details:**
+                - Total Solar Panel Investment: {st.session_state.solar_panels:,} panels × {st.session_state.panel_price:,} Ksh = {st.session_state.solar_panels * st.session_state.panel_price:,} Ksh
+                - Total Battery Investment: {st.session_state.batteries:,} batteries × {st.session_state.battery_price:,} Ksh = {st.session_state.batteries * st.session_state.battery_price:,} Ksh
+                - Total System Cost: {total_investment:,} Ksh
+                
+                **Savings Calculation:**
+                - Grid Price: {st.session_state.grid_price} Ksh/kWh
+                - Monthly Savings =(Total Consumption - Common Area) × Grid Price
+                - Payback Period = Total Investment / Annual Savings
+                
+                **Filtered Scenario Data:**
+                """
+            )
+            st.dataframe(
+                filtered_fin_df[
+                    [
+                        "Scenario",
+                        "consumption",
+                        "production",
+                        "monthly_savings",
+                        "payback_period",
+                    ]
+                ].sort_values("monthly_savings", ascending=False),
+                hide_index=True,
+            )
+            # Button to trigger analysis
+            if st.button("🔍 Analyze Financial Data with LLM"):
+                with st.spinner("Generating insights with AI..."):
+                    analysis = summary_generation(filtered_fin_df)
+                    st.success("Analysis Complete!")
+                    st.write(analysis)  # Display the results
+
+    # Tab 3: Detailed Breakdown
+    with tab3:
+        st.header("Consumption Breakdown Analysis")
+
+        # Select specific scenario for detailed analysis
+        scenario_select = st.selectbox(
+            "Select Specific Scenario", list(scenarios.keys())
+        )
+        selected_params = scenarios[scenario_select]
+
+        # Create consumption breakdown
+        breakdown_df = create_consumption_breakdown(
+            selected_params["1br"], selected_params["2br"], selected_params["common"]
+        )
+
+        total_kwh = breakdown_df["kWh"].sum()
 
-    # Initialize with default values
-    demo.load(
-        update_totals,
-        inputs=[solar_panels, batteries, panel_price, battery_price],
-        outputs=[total_panel, total_battery, total_investment],
+        # Add percentage column
+        breakdown_df["Percentage"] = (breakdown_df["kWh"] / total_kwh * 100).round(1)
+
+        col1, col2 = st.columns([2, 3])
+
+        with col1:
+            st.subheader("Energy Composition")
+
+            # Create a more attractive pie chart
+            fig3 = plt.figure(figsize=(8, 8))
+            ax3 = fig3.add_subplot(111)
+
+            colors = ["#FF9800", "#2196F3", "#4CAF50"]
+            explode = (0.1, 0, 0)
+
+            wedges, texts, autotexts = ax3.pie(
+                breakdown_df["kWh"],
+                labels=breakdown_df.index,
+                autopct="%1.1f%%",
+                explode=explode,
+                colors=colors,
+                shadow=True,
+                startangle=90,
+                textprops={"fontsize": 12},
+            )
+
+            # Equal aspect ratio ensures that pie is drawn as a circle
+            ax3.axis("equal")
+            plt.tight_layout()
+            st.pyplot(fig3)
+
+            # Show total consumption
+            st.metric(
+                "Total Monthly Consumption",
+                f"{total_kwh:.1f} kWh",
+                help="Sum of all consumption components",
+            )
+
+        with col2:
+            st.subheader("Detailed Component Analysis")
+
+            # Show breakdown as a horizontal bar chart
+            fig4 = plt.figure(figsize=(10, 5))
+            ax4 = fig4.add_subplot(111)
+
+            # Sort by consumption
+            sorted_df = breakdown_df.sort_values("kWh", ascending=True)
+
+            # Create horizontal bar chart
+            bars = sns.barplot(
+                y=sorted_df.index, x="kWh", data=sorted_df, palette=colors[::-1], ax=ax4
+            )
+
+            # Add data labels
+            for i, v in enumerate(sorted_df["kWh"]):
+                ax4.text(
+                    v + 5,
+                    i,
+                    f"{v:.1f} kWh ({sorted_df['Percentage'].iloc[i]}%)",
+                    va="center",
+                )
+
+            ax4.set_title(f"Energy Consumption Breakdown - {scenario_select}")
+            ax4.set_xlabel("Monthly Consumption (kWh)")
+            ax4.set_ylabel("")
+            plt.tight_layout()
+            st.pyplot(fig4)
+
+            # Add scenario details
+            st.markdown(
+                f"""
+            **Scenario Details:**
+            - 1BR Units Occupancy: {selected_params['1br']*100:.0f}% ({selected_params['1br']*ONE_BR_UNITS:.0f} units)
+            - 2BR Units Occupancy: {selected_params['2br']*100:.0f}% ({selected_params['2br']*TWO_BR_UNITS:.0f} units)
+            - Common Areas Consumption: {selected_params['common']*30:.1f} kWh/month
+            """
+            )
+
+            # Insight box
+            st.info(
+                f"""
+            **Key Insights for {scenario_select}:**
+            - Lighting contributes {breakdown_df.loc['Lighting', 'Percentage']:.1f}% of total consumption
+            - Common areas account for {breakdown_df.loc['Common Areas', 'Percentage']:.1f}% of the total
+            - {'2BR units dominate consumption at ' + str(selected_params['2br']*100) + '% occupancy' if selected_params['2br'] > selected_params['1br'] else '1BR units are the primary consumers at ' + str(selected_params['1br']*100) + '% occupancy'}
+            - Total potential solar offset: {min(solar_production(st.session_state.solar_panels)/total_kwh*100, 100):.1f}%
+            """
+            )
+
+    # Footer
+    st.markdown("---")
+    st.markdown(
+        """
+        <div style="text-align: center; color: #666;">
+        <p>Solar Analysis Suite v1.0 | Developed with ❤️ for sustainable energy solutions</p>
+        </div>
+        """,
+        unsafe_allow_html=True,
     )
 
+
 if __name__ == "__main__":
-    demo.launch()
+    main()