refined

app.py

@@ -9,264 +9,202 @@ from typing import Dict
 ONE_BR_UNITS = 23
 TWO_BR_UNITS = 45
 SOLAR_PANEL_RATING = 625  # W
-SOLAR_PANEL_COST = 13000  # KSH per panel
 BATTERY_CAPACITY = 200  # Ah
 BATTERY_VOLTAGE = 12  # V
-BATTERY_COST = 39000  # KSH per battery
-SYSTEM_LOSSES = 0.20  # 20% system losses
-GRID_COST_PER_KWH = 28.44  # KSH
-FEED_IN_TARIFF = 12  # KSH per kWh sold back to grid
-
-# Consumption scenarios (kWh/month)
-ONE_BR_CONSUMPTION = 250
-TWO_BR_CONSUMPTION = 400
-COMMON_AREA_CURRENT = 1.974  # kWh
-COMMON_AREA_INCREASED = 5.904  # kWh
+SYSTEM_LOSSES = 0.20
+FEED_IN_TARIFF = 12
 
+# Lighting specifications
+LIGHTS_1BR = 5
+LIGHTS_2BR = 8
+LIGHT_POWER = 6  # Watts per light
 
 def initialize_session_state():
     """Initialize session state variables"""
-    if "solar_panels" not in st.session_state:
-        st.session_state.solar_panels = 100
-    if "batteries" not in st.session_state:
-        st.session_state.batteries = 50
-
+    defaults = {
+        'solar_panels': 100,
+        'batteries': 50,
+        '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
 
-def calculate_consumption(
-    one_br_occupancy: float, two_br_occupancy: float, common_area: float
-) -> float:
-    """Calculate total monthly consumption based on occupancy rates"""
+def calculate_lighting_consumption(occupancy_1br: float, occupancy_2br: float) -> float:
+    """Calculate daily lighting consumption"""
     return (
-        one_br_occupancy * ONE_BR_UNITS * ONE_BR_CONSUMPTION
-        + two_br_occupancy * TWO_BR_UNITS * TWO_BR_CONSUMPTION
-        + common_area * 30  # Convert daily to monthly
-    )
-
-
-def solar_production(panel_count: int, sun_hours: float = 5) -> float:
-    """Calculate daily solar production considering losses"""
-    daily_production = (
-        panel_count * SOLAR_PANEL_RATING * sun_hours * (1 - SYSTEM_LOSSES) / 1000
-    )  # kWh
-    return daily_production * 30  # Monthly production
-
+        (occupancy_1br * ONE_BR_UNITS * LIGHTS_1BR * LIGHT_POWER / 1000) +
+        (occupancy_2br * TWO_BR_UNITS * LIGHTS_2BR * LIGHT_POWER / 1000)
+    ) * 24  # Daily kWh
 
-def battery_storage(battery_count: int) -> float:
-    """Calculate usable battery storage considering losses"""
-    total_capacity = battery_count * BATTERY_CAPACITY * BATTERY_VOLTAGE / 1000  # kWh
-    return total_capacity * (1 - SYSTEM_LOSSES)
-
-
-def financial_analysis(
-    consumption: float, production: float, storage: float
-) -> Dict[str, float]:
-    """Calculate financial metrics with detailed energy flows"""
+def calculate_appliance_consumption(occupancy_1br: float, occupancy_2br: float) -> float:
+    """Calculate daily appliance consumption"""
+    return (
+        (occupancy_1br * ONE_BR_UNITS * (250 - (LIGHTS_1BR * LIGHT_POWER * 24 / 1000))) +
+        (occupancy_2br * TWO_BR_UNITS * (400 - (LIGHTS_2BR * LIGHT_POWER * 24 / 1000)))
+    )  # 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 solar_production(panels: int) -> float:
+    """Monthly solar production with losses"""
+    return panels * SOLAR_PANEL_RATING * 5 * 0.8 * 30 / 1000  # 5 sun hours
+
+def battery_storage(batteries: int) -> float:
+    """Usable battery capacity"""
+    return batteries * BATTERY_CAPACITY * BATTERY_VOLTAGE * 0.8 / 1000
+
+def financial_analysis(consumption: float, production: float, storage: float) -> Dict:
+    """Detailed financial calculations"""
     solar_used = min(production, consumption)
-    excess_solar = max(production - consumption, 0)
-    grid_purchased = max(consumption - solar_used, 0)
-
-    # Battery operations
-    battery_stored = min(excess_solar, storage)
-    battery_used = min(grid_purchased, storage)
-
-    final_grid = max(grid_purchased - battery_used, 0)
-    final_excess = max(excess_solar - battery_stored, 0)
-
-    grid_cost = final_grid * GRID_COST_PER_KWH
-    feed_in_income = final_excess * FEED_IN_TARIFF
-    savings = (consumption * GRID_COST_PER_KWH) - grid_cost + feed_in_income
-
+    grid_purchased = max(consumption - solar_used - storage, 0)
+    
     return {
-        "consumption": consumption,
-        "production": production,
-        "solar_used": solar_used,
-        "excess_solar": final_excess,
-        "grid_purchased": final_grid,
-        "battery_utilization": (
-            (battery_used + battery_stored) / storage if storage > 0 else 0
-        ),
-        "solar_coverage": solar_used / consumption if consumption > 0 else 0,
-        "monthly_savings": savings,
-        "extra_grid_cost_saved": (3.93 * 30 * GRID_COST_PER_KWH)
-        - (final_grid * GRID_COST_PER_KWH),
-        "profit_margin": (feed_in_income + savings)
-        / (consumption * GRID_COST_PER_KWH)
-        * 100,
+        'solar_contribution': solar_used / consumption * 100,
+        'grid_dependency': grid_purchased / consumption * 100,
+        'monthly_savings': (consumption * st.session_state.grid_price) - 
+                          (grid_purchased * st.session_state.grid_price),
+        'payback_period': (st.session_state.solar_panels * st.session_state.panel_price +
+                          st.session_state.batteries * st.session_state.battery_price) /
+                          ((consumption - grid_purchased) * st.session_state.grid_price * 12)
     }
 
+def create_consumption_breakdown(occupancy_1br: float, occupancy_2br: float, common_area: float):
+    """Create detailed consumption breakdown"""
+    breakdown = {
+        'Lighting': calculate_lighting_consumption(occupancy_1br, occupancy_2br) * 30,
+        'Appliances': calculate_appliance_consumption(occupancy_1br, occupancy_2br) * 30,
+        'Common Areas': common_area * 30
+    }
+    return pd.DataFrame.from_dict(breakdown, orient='index', columns=['kWh'])
 
-def plot_comparison(data: pd.DataFrame, metric: str, title: str):
-    """Create comparison plots using Seaborn"""
-    plt.figure(figsize=(10, 6))
-    ax = sns.barplot(data=data, x="Scenario", y=metric, hue="Common Area Usage")
-
-    # Add value annotations
-    for p in ax.patches:
-        ax.annotate(
-            f"{p.get_height():.1f}",
-            (p.get_x() + p.get_width() / 2.0, p.get_height()),
-            ha="center",
-            va="center",
-            xytext=(0, 10),
-            textcoords="offset points",
-        )
-
-    plt.title(title)
-    plt.xticks(rotation=45)
-    plt.tight_layout()
-    st.pyplot(plt)
-
-
+# Streamlit Interface
 def main():
-    st.set_page_config(
-        page_title="Solar Profitability Analyzer", page_icon="📊", layout="wide"
-    )
+    st.set_page_config("Solar Analysis Suite", "🌞", "wide")
     initialize_session_state()
-
-    st.title("📊 Solar Profitability Analysis")
-    st.markdown(
-        """
-    Comparing current vs increased common area usage (1.974kWh vs 5.904kWh daily)  
-    Grid cost: Ksh 28.44/kWh | Extra 3.93kWh would cost Ksh {:.2f} monthly
-    """.format(
-            3.93 * 30 * GRID_COST_PER_KWH
-        )
-    )
-
-    # System configuration
+    
+    st.title("🌞 Advanced Solar Performance Analyzer")
+    
     with st.sidebar:
         st.header("System Configuration")
-        st.session_state.solar_panels = st.number_input(
-            "Solar Panels", 0, 1000, st.session_state.solar_panels
-        )
-        st.session_state.batteries = st.number_input(
-            "Batteries", 0, 500, st.session_state.batteries
-        )
-
-        st.markdown(
-            f"""
-        **System Details:**
-        - Panel: {SOLAR_PANEL_RATING}W @ Ksh{SOLAR_PANEL_COST:,}  
-        - Battery: {BATTERY_CAPACITY}Ah @ Ksh{BATTERY_COST:,}  
-        - Losses: {SYSTEM_LOSSES*100:.0f}%
-        """
-        )
-
-    # Occupancy scenarios
+        st.number_input("Solar Panels", 1, 1000, key='solar_panels')
+        st.number_input("Batteries", 0, 500, key='batteries')
+        st.number_input("Panel Price (Ksh)", 1000, 50000, key='panel_price')
+        st.number_input("Battery Price (Ksh)", 5000, 100000, key='battery_price')
+        st.number_input("Grid Price (Ksh/kWh)", 10.0, 50.0, key='grid_price')
+    
     scenarios = {
-        "1BR:0%, 2BR:100%": {"1br": 0.0, "2br": 1.0},
-        "1BR:25%, 2BR:100%": {"1br": 0.25, "2br": 1.0},
-        "1BR:50%, 2BR:100%": {"1br": 0.5, "2br": 1.0},
+        "Low Occupancy": {"1br": 0.0, "2br": 1.0, "common": 5.904},
+        "Medium Occupancy": {"1br": 0.25, "2br": 1.0, "common": 5.904},
+        "High Occupancy": {"1br": 0.5, "2br": 1.0, "common": 5.904}
     }
-
-    # Common area scenarios
-    common_areas = {
-        "Current (1.974kWh)": COMMON_AREA_CURRENT,
-        "Increased (5.904kWh)": COMMON_AREA_INCREASED,
-    }
-
-    # Calculate all combinations
-    results = []
-    for scenario_name, occupancy in scenarios.items():
-        for area_name, area_usage in common_areas.items():
-            consumption = calculate_consumption(
-                occupancy["1br"], occupancy["2br"], area_usage
-            )
-
-            production = solar_production(st.session_state.solar_panels)
-            storage = battery_storage(st.session_state.batteries)
-
-            financials = financial_analysis(consumption, production, storage)
-
-            results.append(
-                {
-                    "Scenario": scenario_name,
-                    "Common Area Usage": area_name,
-                    **financials,
-                }
-            )
-
-    df = pd.DataFrame(results)
-
-    # Key metrics comparison
-    st.subheader("Performance Comparison")
-    col1, col2, col3 = st.columns(3)
+    
+    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, production, storage)
+        
+        analysis_data.append({
+            "Scenario": name,
+            "Consumption": consumption,
+            "Production": production,
+            **financials
+        })
+    
+    df = pd.DataFrame(analysis_data)
+    
+    # Energy Flow Analysis
+    st.header("Energy Flow Composition")
+    fig, ax = plt.subplots(figsize=(10, 6))
+    sns.barplot(df.melt(id_vars=['Scenario'], 
+                value_vars=['solar_contribution', 'grid_dependency'],
+                x='Scenario', y='value', hue='variable', ax=ax)
+    ax.set_ylabel("Percentage (%)")
+    ax.set_title("Energy Contribution Breakdown")
+    st.pyplot(fig)
+    
+    with st.expander("🔍 Energy Flow Interpretation"):
+        st.markdown("""
+        **Understanding the Chart:**
+        - **Solar Contribution**: Percentage of total energy needs met by solar production
+        - **Grid Dependency**: Remaining energy required from grid
+        - Ideal scenario shows high solar contribution with minimal grid dependency
+        """)
+    
+    # Financial Analysis
+    st.header("Financial Performance Metrics")
+    
+    # Metric 1: Monthly Savings
+    fig1, ax1 = plt.subplots(figsize=(10, 4))
+    sns.barplot(data=df, x='Scenario', y='monthly_savings', ax=ax1)
+    ax1.set_title("Monthly Cost Savings")
+    ax1.set_ylabel("Ksh")
+    st.pyplot(fig1)
+    
+    with st.expander("💵 Savings Analysis"):
+        st.markdown(f"""
+        **Key Observations:**
+        - Savings calculated as: `(Total Consumption × Grid Price) - (Grid Purchased × Grid Price)`
+        - Current Grid Price: Ksh {st.session_state.grid_price}/kWh
+        - Maximum potential savings limited by solar production capacity
+        """)
+        st.table(df[['Scenario', 'Consumption', 'Production', 'monthly_savings']])
+    
+    # Metric 2: Payback Period
+    fig2, ax2 = plt.subplots(figsize=(10, 4))
+    sns.barplot(data=df, x='Scenario', y='payback_period', ax=ax2)
+    ax2.set_title("System Payback Period")
+    ax2.set_ylabel("Years")
+    st.pyplot(fig2)
+    
+    with st.expander("⏳ Payback Explanation"):
+        st.markdown(f"""
+        **Calculation Methodology:**
+        - Total Investment: (Panels × {st.session_state.panel_price:,}Ksh) + (Batteries × {st.session_state.battery_price:,}Ksh)
+        - Annual Savings: Monthly Savings × 12
+        - Payback Period = Total Investment / Annual Savings
+        """)
+        st.table(df[['Scenario', 'payback_period']])
+    
+    # Consumption Breakdown
+    st.header("Detailed Consumption Analysis")
+    scenario_select = st.selectbox("Select Scenario", list(scenarios.keys()))
+    
+    selected_params = scenarios[scenario_select]
+    breakdown_df = create_consumption_breakdown(
+        selected_params["1br"], 
+        selected_params["2br"], 
+        selected_params["common"]
+    )
+    
+    col1, col2 = st.columns(2)
     with col1:
-        plot_comparison(df, "monthly_savings", "Monthly Savings (Ksh)")
+        st.subheader("Energy Composition")
+        fig3, ax3 = plt.subplots()
+        breakdown_df.plot.pie(y='kWh', ax=ax3, autopct='%1.1f%%')
+        st.pyplot(fig3)
+    
     with col2:
-        plot_comparison(df, "extra_grid_cost_saved", "Extra Grid Cost Saved (Ksh)")
-    with col3:
-        plot_comparison(df, "profit_margin", "Profit Margin (%)")
-
-    # Energy flow visualization
-    st.subheader("Energy Flow Analysis")
-    flow_df = df.melt(
-        id_vars=["Scenario", "Common Area Usage"],
-        value_vars=["solar_used", "grid_purchased", "excess_solar"],
-        var_name="Flow",
-        value_name="kWh",
-    )
-
-    plt.figure(figsize=(12, 6))
-    sns.barplot(
-        data=flow_df,
-        x="Scenario",
-        y="kWh",
-        hue="Flow",
-        palette="viridis",
-    )
-    plt.title("Energy Flow Composition")
-    plt.ylabel("Monthly Energy (kWh)")
-    plt.xticks(rotation=45)
-    st.pyplot(plt)
-
-    # Detailed data table
-    st.subheader("Detailed Financial Analysis")
-    display_df = df[
-        [
-            "Scenario",
-            "Common Area Usage",
-            "consumption",
-            "production",
-            "solar_coverage",
-            "grid_purchased",
-            "monthly_savings",
-            "extra_grid_cost_saved",
-            "profit_margin",
-        ]
-    ].copy()
-
-    display_df.columns = [
-        "Scenario",
-        "Common Area",
-        "Consumption (kWh)",
-        "Production (kWh)",
-        "Solar Coverage (%)",
-        "Grid Purchased (kWh)",
-        "Savings (Ksh)",
-        "Extra Cost Saved (Ksh)",
-        "Profit Margin (%)",
-    ]
-
-    # Format numeric columns
-    for col in display_df.columns[2:]:
-        display_df[col] = display_df[col].apply(lambda x: f"{x:,.1f}")
-
-    st.dataframe(display_df, hide_index=True)
-
-    # Savings potential highlight
-    max_saving = df["extra_grid_cost_saved"].max()
-    best_case = df[df["extra_grid_cost_saved"] == max_saving].iloc[0]
-
-    st.success(
-        f"""
-    **Maximum Extra Cost Savings Potential:**  
-    Ksh {max_saving:,.2f}/month in scenario:  
-    {best_case['Scenario']} with {best_case['Common Area Usage']}  
-    (Current profit margin: {best_case['profit_margin']:.1f}%)
-    """
-    )
-
+        st.subheader("Component Breakdown")
+        st.table(breakdown_df)
+        
+        analysis_text = f"""
+        **Key Insights for {scenario_select}:**
+        - Lighting contributes {breakdown_df.loc['Lighting', 'kWh']/breakdown_df.sum().values[0]*100:.1f}% of total consumption
+        - Common areas account for {breakdown_df.loc['Common Areas', 'kWh']:.0f}kWh monthly
+        - 2BR units dominate appliance usage at {selected_params['2br']*100}% occupancy
+        """
+        st.markdown(analysis_text)
 
 if __name__ == "__main__":
     main()