redesign

app.py

@@ -1,330 +1,337 @@
-import streamlit as st
-import polars as pl
-import xarray as xr
-import seaborn as sns
-import matplotlib.pyplot as plt
 import numpy as np
-from typing import Dict, List, Tuple
+import pandas as pd
+import matplotlib.pyplot as plt
+import streamlit as st
+from typing import Dict, Tuple
 
 # Constants
-GRID_PRICE = 28.44  # Ksh/kWh
-TIME_RESOLUTION = 24  # hours in a day
-
-# Appliance data structure
-APPLIANCES = {
-    "Lights": {"power_kw": 2088, "usage_hours": 16, "grid_only": False},
-    "TV": {"power_kw": 0.08, "usage_hours": 5, "grid_only": False},
-    "Fridge": {"power_kw": 0.8, "usage_hours": 24, "grid_only": False},
-    "Computer": {"power_kw": 0.15, "usage_hours": 9, "grid_only": False},
-    # "Water Pump": {"power_kw": 0.5, "usage_hours": 2, "grid_only": False},
-    "Instant Shower": {"power_kw": 5.0, "usage_hours": 0.5, "grid_only": True},
-    "Electric Kettle": {"power_kw": 1.5, "usage_hours": 0.25, "grid_only": True},
-    "Microwave": {"power_kw": 2.0, "usage_hours": 0.2, "grid_only": True},
-    # "Oven": {"power_kw": 1.0, "usage_hours": 0.3, "grid_only": True},
-}
+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 = 25  # KSH
+FEED_IN_TARIFF = 12  # KSH per kWh sold back to grid
+
+# Consumption estimates (kWh/month)
+ONE_BR_CONSUMPTION = 250
+TWO_BR_CONSUMPTION = 400
+COMMON_AREA_CONSUMPTION = 1500  # For entire complex
 
 
 def initialize_session_state():
-    """Initialize all session state variables"""
-    if "solar_price" not in st.session_state:
-        st.session_state.solar_price = 10.0
-    if "solar_ratio" not in st.session_state:
-        st.session_state.solar_ratio = 0.5
-    if "appliance_data" not in st.session_state:
-        st.session_state.appliance_data = None
-
-
-def create_appliance_dataframe() -> pl.DataFrame:
-    """Create a Polars DataFrame from the appliance data"""
-    data = []
-    for name, specs in APPLIANCES.items():
-        data.append(
-            {
-                "appliance": name,
-                "power_kw": specs["power_kw"],
-                "usage_hours": specs["usage_hours"],
-                "grid_only": specs["grid_only"],
-                "daily_kwh": specs["power_kw"] * specs["usage_hours"],
-            }
-        )
-    return pl.DataFrame(data)
-
-
-def create_time_series_dataset(df: pl.DataFrame) -> xr.Dataset:
-    """Create an xarray Dataset with time series data"""
-    hours = np.arange(TIME_RESOLUTION)
-    appliances = df["appliance"].to_list()
-
-    # Create empty arrays
-    power_usage = xr.DataArray(
-        np.zeros((len(appliances), TIME_RESOLUTION)),
-        dims=("appliance", "hour"),
-        coords={"appliance": appliances, "hour": hours},
+    """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
+
+
+def calculate_consumption(one_br_occupancy: float, two_br_occupancy: float) -> float:
+    """Calculate total monthly consumption based on occupancy rates"""
+    total_consumption = (
+        one_br_occupancy * ONE_BR_UNITS * ONE_BR_CONSUMPTION
+        + two_br_occupancy * TWO_BR_UNITS * TWO_BR_CONSUMPTION
+        + COMMON_AREA_CONSUMPTION
     )
-
-    # Fill with actual usage patterns (simplified - could be enhanced)
-    for i, row in enumerate(df.iter_rows(named=True)):
-        if row["usage_hours"] > 0:
-            usage_start = 8  # assuming morning start
-            usage_end = min(usage_start + int(row["usage_hours"]), TIME_RESOLUTION)
-            power_usage[i, usage_start:usage_end] = row["power_kw"]
-
-    return xr.Dataset(
-        {
-            "power_usage": power_usage,
-            "daily_kwh": xr.DataArray(df["daily_kwh"].to_numpy(), dims="appliance"),
-            "grid_only": xr.DataArray(df["grid_only"].to_numpy(), dims="appliance"),
-        }
-    )
-
-
-def calculate_consumption(ds: xr.Dataset, solar_ratio: float) -> Dict:
-    """Calculate consumption breakdown and costs"""
-    # Separate grid-only and mixed appliances
-    mixed_mask = ~ds["grid_only"]
-    grid_only_mask = ds["grid_only"]
-
-    # Calculate consumptions
-    grid_only_consumption = ds["daily_kwh"].where(grid_only_mask, 0).sum().item()
-    total_mixed_consumption = ds["daily_kwh"].where(mixed_mask, 0).sum().item()
-
-    solar_consumption = total_mixed_consumption * solar_ratio
-    grid_mixed_consumption = total_mixed_consumption * (1 - solar_ratio)
-    total_grid_consumption = grid_mixed_consumption + grid_only_consumption
-
-    # Calculate costs
-    grid_cost = total_grid_consumption * GRID_PRICE
-    solar_cost = solar_consumption * st.session_state.solar_price
-    total_cost = grid_cost + solar_cost
+    return total_consumption
+
+
+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
+    monthly_production = daily_production * 30
+    return monthly_production
+
+
+def battery_storage(battery_count: int) -> float:
+    """Calculate usable battery storage considering losses"""
+    total_capacity = battery_count * BATTERY_CAPACITY * BATTERY_VOLTAGE / 1000  # kWh
+    usable_capacity = total_capacity * (1 - SYSTEM_LOSSES)
+    return usable_capacity
+
+
+def financial_analysis(
+    monthly_consumption: float,
+    solar_production: float,
+    battery_capacity: float,
+    panel_count: int,
+    battery_count: int,
+) -> Dict[str, float]:
+    """
+    Calculate financial metrics including costs, savings, and ROI
+    """
+    # Initial investment
+    panel_cost = panel_count * SOLAR_PANEL_COST
+    battery_cost = battery_count * BATTERY_COST
+    total_investment = panel_cost + battery_cost
+
+    # Energy calculations
+    solar_used = min(solar_production, monthly_consumption)
+    excess_solar = max(solar_production - monthly_consumption, 0)
+    grid_purchased = max(monthly_consumption - solar_used, 0)
+
+    # Battery can store excess or reduce grid purchases
+    battery_stored = min(excess_solar, battery_capacity)
+    battery_used = min(grid_purchased, battery_capacity)
+
+    # Final energy flows
+    final_grid_purchased = max(grid_purchased - battery_used, 0)
+    final_excess_solar = max(excess_solar - battery_stored, 0)
+
+    # Financial calculations
+    grid_cost = final_grid_purchased * GRID_COST_PER_KWH
+    feed_in_income = final_excess_solar * FEED_IN_TARIFF
+    savings = (monthly_consumption * GRID_COST_PER_KWH) - grid_cost + feed_in_income
 
     return {
-        "solar_consumption": solar_consumption,
-        "grid_consumption": total_grid_consumption,
-        "grid_only_consumption": grid_only_consumption,
-        "total_consumption": total_mixed_consumption + grid_only_consumption,
-        "grid_cost": grid_cost,
-        "solar_cost": solar_cost,
-        "total_cost": total_cost,
-        "hourly_power": ds["power_usage"],
+        "total_investment": total_investment,
+        "monthly_savings": savings,
+        "annual_savings": savings * 12,
+        "simple_payback_years": (
+            total_investment / (savings * 12) if savings > 0 else float("inf")
+        ),
+        "grid_purchased": final_grid_purchased,
+        "excess_solar": final_excess_solar,
+        "battery_utilization": (
+            (battery_used + battery_stored) / battery_capacity
+            if battery_capacity > 0
+            else 0
+        ),
+        "solar_coverage": (
+            solar_used / monthly_consumption if monthly_consumption > 0 else 0
+        ),
     }
 
 
-def find_optimal_solar_price(solar_ratio: float, years: int = 5) -> float:
-    """Calculate optimal solar price considering payback period"""
-    # Simplified model - in reality would need installation costs, etc.
-    # Assumes you want payback within 'years' years
-    daily_savings = GRID_PRICE - (GRID_PRICE * 0.8)  # 20% savings target
-    return max(0, GRID_PRICE - (daily_savings / years))
-
-
-def plot_consumption_breakdown(data: Dict):
-    """Create consumption breakdown visualization"""
-    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 5))
-
-    # Pie chart
-    labels = ["Solar", "Grid (mixed)", "Grid (high load)"]
-    sizes = [
-        data["solar_consumption"],
-        data["grid_consumption"] - data["grid_only_consumption"],
-        data["grid_only_consumption"],
-    ]
-    ax1.pie(sizes, labels=labels, autopct="%1.1f%%", startangle=90)
-    ax1.set_title("Energy Source Breakdown")
-
-    # Cost comparison bar plot
-    cost_df = pl.DataFrame(
-        {
-            "source": ["Solar", "Grid", "Total"],
-            "cost": [data["solar_cost"], data["grid_cost"], data["total_cost"]],
-        }
-    )
-    sns.barplot(data=cost_df.to_pandas(), x="source", y="cost", ax=ax2)
-    ax2.set_title("Daily Cost Comparison")
-    ax2.set_ylabel("Cost (Ksh)")
-
-    st.pyplot(fig)
-
+def plot_scenario_comparison(results: Dict[str, Dict[str, float]]):
+    """Plot comparison of different occupancy scenarios"""
+    scenarios = list(results.keys())
+
+    # Prepare data for plotting
+    metrics = {
+        "Monthly Consumption (kWh)": [results[s]["consumption"] for s in scenarios],
+        "Solar Production (kWh)": [results[s]["solar_production"] for s in scenarios],
+        "Grid Purchased (kWh)": [
+            results[s]["financials"]["grid_purchased"] for s in scenarios
+        ],
+        "Excess Solar (kWh)": [
+            results[s]["financials"]["excess_solar"] for s in scenarios
+        ],
+    }
 
-def plot_hourly_usage(hourly_data: xr.DataArray):
-    """Plot hourly power usage patterns"""
-    fig, ax = plt.subplots(figsize=(10, 5))
+    # Create figure
+    fig, axes = plt.subplots(2, 2, figsize=(15, 12))
+    axes = axes.flatten()
 
-    # Convert to DataFrame for Seaborn
-    df = hourly_data.to_dataframe(name="power_kw").reset_index()
+    for i, (title, values) in enumerate(metrics.items()):
+        axes[i].bar(scenarios, values, color=plt.cm.tab20(i))
+        axes[i].set_title(title)
+        axes[i].tick_params(axis="x", rotation=45)
 
-    # Plot grid-only vs solar-capable appliances separately
-    grid_only_mask = df["appliance"].isin(
-        [name for name, specs in APPLIANCES.items() if specs["grid_only"]]
-    )
+        # Add value labels
+        for j, v in enumerate(values):
+            axes[i].text(j, v * 1.02, f"{v:,.0f}", ha="center", va="bottom")
 
-    sns.lineplot(
-        data=df[~grid_only_mask],
-        x="hour",
-        y="power_kw",
-        hue="appliance",
-        ax=ax,
-        palette="crest",
-        legend=True,
-    )
+    plt.tight_layout()
+    st.pyplot(fig)
 
-    sns.lineplot(
-        data=df[grid_only_mask],
-        x="hour",
-        y="power_kw",
-        hue="appliance",
-        ax=ax,
-        palette="flare",
-        linestyle="--",
-        legend=True,
-    )
 
-    ax.set_title("Hourly Power Consumption Patterns")
-    ax.set_xlabel("Hour of Day")
-    ax.set_ylabel("Power (kW)")
-    ax.legend(title="Appliance", bbox_to_anchor=(1.05, 1), loc="upper left")
+def plot_financial_comparison(results: Dict[str, Dict[str, float]]):
+    """Plot financial comparison across scenarios"""
+    scenarios = list(results.keys())
+
+    # Prepare financial data
+    financial_metrics = {
+        "Monthly Savings (Ksh)": [
+            results[s]["financials"]["monthly_savings"] for s in scenarios
+        ],
+        "Solar Coverage (%)": [
+            results[s]["financials"]["solar_coverage"] * 100 for s in scenarios
+        ],
+        "Payback Period (Years)": [
+            results[s]["financials"]["simple_payback_years"] for s in scenarios
+        ],
+        "Battery Utilization (%)": [
+            results[s]["financials"]["battery_utilization"] * 100 for s in scenarios
+        ],
+    }
 
+    # Create figure
+    fig, axes = plt.subplots(2, 2, figsize=(15, 12))
+    axes = axes.flatten()
+
+    for i, (title, values) in enumerate(financial_metrics.items()):
+        if title == "Payback Period (Years)":
+            # For payback period, we'll do a horizontal bar chart
+            axes[i].barh(scenarios, values, color=plt.cm.tab20(3))
+            axes[i].set_xlabel(title)
+
+            # Add value labels
+            for j, v in enumerate(values):
+                if np.isfinite(v):
+                    axes[i].text(v * 1.02, j, f"{v:.1f}", va="center")
+                else:
+                    axes[i].text(0, j, "Never", va="center")
+        else:
+            axes[i].bar(scenarios, values, color=plt.cm.tab20(i + 4))
+            axes[i].set_title(title)
+            axes[i].tick_params(axis="x", rotation=45)
+
+            # Add value labels
+            for j, v in enumerate(values):
+                axes[i].text(j, v * 1.02, f"{v:,.1f}", ha="center", va="bottom")
+
+    plt.tight_layout()
     st.pyplot(fig)
 
 
 def main():
     st.set_page_config(
-        page_title="Solar vs Grid Consumption Analyzer", page_icon="☀️", layout="wide"
+        page_title="Apartment Complex Solar Analysis", page_icon="🏢", layout="wide"
     )
 
-    # Initialize session state and data structures
+    # Initialize session state
     initialize_session_state()
-    appliance_df = create_appliance_dataframe()
-    ds = create_time_series_dataset(appliance_df)
 
     # Main title and description
-    st.title("☀️ Solar vs National Grid Consumption Analyzer")
-    st.markdown("""
-    Analyze the financial impact of different solar/grid consumption ratios 
-    and optimize your energy costs.
-    """)
+    st.title("🏢 Apartment Complex Solar Energy Analysis")
+    st.markdown(
+        """
+    This tool analyzes solar energy potential for a complex with:
+    - 45 two-bedroom units
+    - 23 one-bedroom units
+    
+    Comparing three specific occupancy scenarios with 2BR at 100% occupancy and varying 1BR occupancy.
+    """
+    )
 
-    # Sidebar for inputs
+    # Sidebar for system configuration
     with st.sidebar:
-        st.header("Configuration")
-        st.session_state.solar_ratio = st.slider(
-            "Solar/Grid Consumption Ratio",
-            min_value=0.0,
-            max_value=1.0,
-            value=0.5,
-            step=0.1,
-            format="%.1f",
+        st.header("System Configuration")
+        st.session_state.solar_panels = st.number_input(
+            "Number of Solar Panels",
+            min_value=0,
+            max_value=1000,
+            value=st.session_state.solar_panels,
+            step=1,
         )
 
-        st.session_state.solar_price = st.number_input(
-            "Custom Solar Price (Ksh/kWh)",
-            min_value=0.0,
-            max_value=float(GRID_PRICE),
-            value=10.0,
-            step=0.1,
+        st.session_state.batteries = st.number_input(
+            "Number of Batteries",
+            min_value=0,
+            max_value=500,
+            value=st.session_state.batteries,
+            step=1,
         )
 
         st.markdown("---")
-        st.metric("Current Grid Price", f"{GRID_PRICE} Ksh/kWh")
-
-    # Calculate consumption and costs
-    data = calculate_consumption(ds, st.session_state.solar_ratio)
-    optimal_price = find_optimal_solar_price(st.session_state.solar_ratio)
-
-    # Main content columns
-    col1, col2, col3 = st.columns(3)
-    with col1:
-        st.metric("Total Daily Consumption", f"{data['total_consumption']:.2f} kWh")
-    with col2:
-        st.metric("Your Solar Price", f"{st.session_state.solar_price} Ksh/kWh")
-    with col3:
-        st.metric("Suggested Optimal Price", f"{optimal_price:.2f} Ksh/kWh")
-
-    # Visualization section
-    st.markdown("---")
-    st.subheader("Consumption Analysis")
-    plot_consumption_breakdown(data)
-
-    st.subheader("Hourly Usage Patterns")
-    plot_hourly_usage(data["hourly_power"])
-
-    # Financial analysis
-    st.subheader("Financial Impact")
-    savings = (GRID_PRICE * data["total_consumption"]) - data["total_cost"]
-    col1, col2 = st.columns(2)
-    with col1:
-        st.metric("Daily Savings vs All-Grid", f"{savings:.2f} Ksh")
-        st.metric("Annual Savings Potential", f"{savings * 365:.2f} Ksh")
-    with col2:
-        st.metric(
-            "Grid Dependency",
-            f"{(data['grid_consumption'] / data['total_consumption']) * 100:.1f}%",
+        st.markdown(
+            f"**Panel Specifications:** {SOLAR_PANEL_RATING}W @ Ksh{SOLAR_PANEL_COST:,} each"
         )
-        st.metric(
-            "Solar Viability",
-            f"{(data['solar_consumption'] / data['total_consumption']) * 100:.1f}%",
+        st.markdown(
+            f"**Battery Specifications:** {BATTERY_CAPACITY}Ah @ Ksh{BATTERY_COST:,} each"
         )
+        st.markdown(f"**System Losses:** {SYSTEM_LOSSES*100:.0f}%")
 
-    # Appliance details table
-    st.subheader("Appliance Details")
-    st.dataframe(
-        appliance_df.select(
-            [
-                pl.col("appliance"),
-                pl.col("power_kw").alias("Power (kW)"),
-                pl.col("usage_hours").alias("Usage (hrs)"),
-                pl.col("daily_kwh").alias("Daily (kWh)"),
-                pl.col("grid_only").alias("Grid Only"),
-            ]
-        ),
-        use_container_width=True,
+    # Define the specific scenarios
+    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},
+    }
+
+    # Calculate results for each scenario
+    results = {}
+    for scenario, occupancy in scenarios.items():
+        # Calculate consumption and production
+        consumption = calculate_consumption(occupancy["1br"], occupancy["2br"])
+        production = solar_production(st.session_state.solar_panels)
+        storage = battery_storage(st.session_state.batteries)
+
+        # Financial analysis
+        financials = financial_analysis(
+            consumption,
+            production,
+            storage,
+            st.session_state.solar_panels,
+            st.session_state.batteries,
+        )
+
+        results[scenario] = {
+            "consumption": consumption,
+            "solar_production": production,
+            "battery_capacity": storage,
+            "financials": financials,
+        }
+
+    # Display system summary
+    st.subheader("System Summary")
+    col1, col2, col3, col4 = st.columns(4)
+    col1.metric("Total Solar Panels", st.session_state.solar_panels)
+    col2.metric("Total Batteries", st.session_state.batteries)
+    col3.metric(
+        "Total Investment",
+        f"Ksh{(st.session_state.solar_panels * SOLAR_PANEL_COST + st.session_state.batteries * BATTERY_COST):,}",
+    )
+    col4.metric(
+        "Total Solar Capacity",
+        f"{st.session_state.solar_panels * SOLAR_PANEL_RATING / 1000:.1f} kW",
     )
 
-    # Grid-only appliances warning
-    grid_only_appliances = [
-        name for name, specs in APPLIANCES.items() if specs["grid_only"]
-    ]
-    st.warning(f"""
-    **Grid-Only Appliances:** These high-load devices cannot be solar-powered:
-    {", ".join(grid_only_appliances)}.
-    They represent fixed grid costs of {data["grid_only_consumption"]:.2f} kWh/day.
-    """)
-
-    # Advanced analysis expander
-    with st.expander("Advanced Analysis"):
-        st.write("""
-        ### Detailed Financial Modeling
-        
-        For a more accurate financial analysis, consider:
-        - Solar installation costs
-        - Maintenance expenses
-        - Battery storage requirements
-        - Grid feed-in tariffs
-        - Equipment degradation over time
-        """)
-
-        # Sensitivity analysis
-        st.write("### Price Sensitivity Analysis")
-        solar_prices = np.linspace(0, GRID_PRICE, 20)
-        costs = []
-        for price in solar_prices:
-            temp_data = calculate_consumption(ds, st.session_state.solar_ratio)
-            temp_data["solar_price"] = price
-            costs.append(temp_data["total_cost"])
-
-        fig, ax = plt.subplots()
-        sns.lineplot(x=solar_prices, y=costs, ax=ax)
-        ax.set_xlabel("Solar Price (Ksh/kWh)")
-        ax.set_ylabel("Total Daily Cost (Ksh)")
-        ax.axvline(x=optimal_price, color="r", linestyle="--", label="Optimal Price")
-        ax.legend()
-        st.pyplot(fig)
-
-    # Footer
-    st.markdown("---")
-    st.caption("""
-    *Note: This analysis provides estimates only. Consult with a solar energy professional 
-    for accurate system sizing and financial projections.*
-    """)
+    # Display scenario comparison
+    st.subheader("Scenario Comparison: Energy Flows")
+    plot_scenario_comparison(results)
+
+    st.subheader("Scenario Comparison: Financial Metrics")
+    plot_financial_comparison(results)
+
+    # Detailed results for each scenario
+    st.subheader("Detailed Results by Scenario")
+
+    for scenario, data in results.items():
+        with st.expander(f"Scenario: {scenario}"):
+            col1, col2, col3 = st.columns(3)
+
+            # Energy metrics
+            col1.metric("Monthly Consumption", f"{data['consumption']:,.0f} kWh")
+            col2.metric("Solar Production", f"{data['solar_production']:,.0f} kWh")
+            col3.metric("Battery Capacity", f"{data['battery_capacity']:,.1f} kWh")
+
+            # Financial metrics
+            col1.metric(
+                "Monthly Savings", f"Ksh{data['financials']['monthly_savings']:,.0f}"
+            )
+            col2.metric(
+                "Annual Savings", f"Ksh{data['financials']['annual_savings']:,.0f}"
+            )
+
+            payback = data["financials"]["simple_payback_years"]
+            payback_text = f"{payback:.1f} years" if np.isfinite(payback) else "Never"
+            col3.metric("Simple Payback Period", payback_text)
+
+            # Energy flow details
+            st.markdown("#### Energy Flow Details")
+            flow_data = {
+                "Metric": [
+                    "Grid Purchased",
+                    "Excess Solar",
+                    "Solar Coverage",
+                    "Battery Utilization",
+                ],
+                "Value": [
+                    f"{data['financials']['grid_purchased']:,.0f} kWh",
+                    f"{data['financials']['excess_solar']:,.0f} kWh",
+                    f"{data['financials']['solar_coverage']*100:.1f}%",
+                    f"{data['financials']['battery_utilization']*100:.1f}%",
+                ],
+            }
+            st.table(pd.DataFrame(flow_data))
 
 
 if __name__ == "__main__":