Update app.py

app.py

@@ -1,150 +1,127 @@
 import streamlit as st
 import pandas as pd
-import datetime
+import numpy as np
 import plotly.graph_objects as go
-from difflib import get_close_matches
-import time
-
-# Function to standardize and find the closest column name
-def get_closest_column(columns, target, threshold=0.6):
-    target = target.lower().replace(" ", "").replace("(", "").replace(")", "").replace("-", "")
-    columns_cleaned = [col.lower().replace(" ", "").replace("(", "").replace(")", "").replace("-", "") for col in columns]
-    matches = get_close_matches(target, columns_cleaned, n=1, cutoff=threshold)
-    if matches:
-        return columns[columns_cleaned.index(matches[0])]
-    return None
+import datetime
 
-# Load the dataset
-@st.cache_data
+# Load dataset function
 def load_data():
-    try:
-        df = pd.read_excel("grid_load_data.xlsx")
-
-        # Identify the closest matches for required columns
-        grid_load_col = get_closest_column(df.columns, "Grid Load (kW)")
-        time_col = get_closest_column(df.columns, "Time")
-
-        if not grid_load_col or not time_col:
-            st.error("The dataset must include columns similar to 'Grid Load (kW)' and 'Time'. Please check the formatting.")
-            return None, None
-
-        # Rename columns for consistent processing
-        df = df.rename(columns={grid_load_col: "Grid Load (kW)", time_col: "Time"})
-
-        # Ensure 'Time' column is datetime formatted
-        df["Time"] = pd.to_datetime(df["Time"], errors="coerce")
-        return df, "Grid Load (kW)"
+    # Ensure this path is correct for your environment
+    df = pd.read_excel("grid_load_data.xlsx")
+    return df
 
-    except FileNotFoundError:
-        st.error("The file 'grid_load_data.xlsx' was not found. Please upload the correct file.")
-        return None, None
-    except Exception as e:
-        st.error(f"An error occurred while loading the dataset: {e}")
-        return None, None
-
-# Function to calculate the predicted grid load for the current hour of the day
-def calculate_predicted_grid_load(df, current_time, grid_load_col):
-    if df is None:
-        st.error("Dataset is not loaded correctly.")
-        return None
-
-    # Extract the hour and day from the current time
+# Calculate grid load based on time and dataset
+def calculate_grid_load(df, current_time):
     current_hour = current_time.hour
-
-    # Filter dataset for the given hour across all days
-    df["Hour"] = df["Time"].dt.hour
-    hourly_data = df[df["Hour"] == current_hour]
-
-    if not hourly_data.empty:
-        # Calculate the average grid load for the given hour across all days
-        avg_grid_load = hourly_data[grid_load_col].mean()
-        return avg_grid_load
+    hourly_load = df[df["Time"].dt.hour == current_hour]["Grid Load (kW)"].mean()
+    return hourly_load
+
+# Create a gauge chart for grid load status
+def create_gauge(load_value):
+    # Define ranges for low, normal, high
+    ranges = [0, 2000, 3000, 4000]
+    colors = ['lightgreen', 'green', 'red']
+    labels = ['Low', 'Normal', 'High']
+    
+    # Determine color and range based on load value
+    if load_value < 2000:
+        color = colors[0]
+        range_label = labels[0]
+    elif load_value < 3000:
+        color = colors[1]
+        range_label = labels[1]
     else:
-        st.warning("No data found for the current hour. Using default value.")
-        return 0  # Default to 0 if no data is found for the given hour
-
-# Display live clock
-def display_clock():
-    current_time = datetime.datetime.now()
-    st.sidebar.markdown(f"### 🕒 {current_time.strftime('%Y-%m-%d %H:%M:%S')}")
-    return current_time
-
-# Create Gauge meter
-def create_gauge(value):
+        color = colors[2]
+        range_label = labels[2]
+    
+    # Create the gauge chart using plotly
     fig = go.Figure(go.Indicator(
-        mode="gauge+number",
-        value=value,
-        title={'text': "Grid Load (kW)"},
+        mode="gauge+number+delta",
+        value=load_value,
+        domain={'x': [0, 1], 'y': [0, 1]},
         gauge={
             'axis': {'range': [0, 5000]},
-            'bar': {'color': "lightgray"},
+            'bar': {'color': color},
             'steps': [
-                {'range': [0, 1700], 'color': "lightcoral"},
-                {'range': [1700, 3400], 'color': "lightgreen"},
-                {'range': [3400, 5000], 'color': "red"}
+                {'range': [0, 2000], 'color': 'lightgreen'},
+                {'range': [2000, 3000], 'color': 'green'},
+                {'range': [3000, 5000], 'color': 'red'}
             ],
-            'threshold': {
-                'line': {'color': "black", 'width': 4},
-                'thickness': 0.75,
-                'value': value
-            }
-        }
+        },
+        title={'text': f"Grid Load Status: {range_label}"},
+        delta={'reference': 2000}
     ))
-    fig.update_layout(margin={'l': 0, 'r': 0, 't': 0, 'b': 0}, height=400)
     return fig
 
-# Main app
-def main():
-    st.title("Optimized EV Charging and Grid Management")
-
-    # Load dataset
-    df, grid_load_col = load_data()
-    if df is None or grid_load_col is None:
-        return  # Exit if the dataset is not loaded properly
-
-    # Sidebar for user inputs
-    with st.sidebar:
-        st.header("User Inputs")
-
-        # Battery details (manually entered)
-        state_of_charge = st.number_input("State of Charge (SOC) in kWh", min_value=0, max_value=100, step=1)
-        battery_capacity = st.number_input("Battery Capacity (kWh)", min_value=10, max_value=200, step=1)
-
-        # ON/OFF button for exporting battery power to the grid
-        export_power = st.checkbox("Export Power to Grid (ON/OFF)")
-
-    # Display live clock
-    current_time = display_clock()
-
-    # Predicted grid load
-    predicted_grid_load = calculate_predicted_grid_load(df, current_time, grid_load_col)
-    if predicted_grid_load is not None:
-        st.write(f"### Predicted Grid Load at {current_time.strftime('%H:%M:%S')}: **{predicted_grid_load:.2f} kW**")
-
-        # Create gauge meter based on grid load
-        st.plotly_chart(create_gauge(predicted_grid_load))
-
-        # Evaluate grid status based on the predicted load
-        if predicted_grid_load > 3400:
-            st.error("Grid is Overloaded! EV Charging Disallowed")
-            st.write("🚫 Red Light: EV Charging is Disconnected.")
-        elif predicted_grid_load <= 3400 and predicted_grid_load > 1700:
-            st.success("Grid is Stable! EV Charging Allowed")
-            st.write("✅ Green Light: EV Charging is Active.")
-        else:
-            st.warning("Grid is Low! EV Charging Allowed")
-            st.write("🟠 Light Red Light: EV Charging is Active, but Grid is Low.")
-
-        # Calculate available EV slots
-        available_capacity = 3400 - predicted_grid_load
-        ev_slots = available_capacity // 50  # Assuming each EV slot requires 50kW
-        st.write(f"### Available EV Slots: **{ev_slots}**")
+# Function to calculate the required EVs for grid stabilization
+def calculate_ev_requirements(grid_load, ev_capacity=80, ev_efficiency=0.85):
+    # Assuming each EV contributes its battery capacity (80kWh) and efficiency (85%).
+    # Formula: EVs required = Grid load / (EV capacity * efficiency)
+    evs_needed = grid_load / (ev_capacity * ev_efficiency)
+    return np.ceil(evs_needed)  # Round to the nearest whole number
+
+# Function to calculate power and energy consumption from EV during underload condition
+def calculate_ev_power_consumption(ev_capacity=80, charge_rate=0.85):
+    # Power consumed per EV during underload (assuming 85% depth of charge)
+    power_consumed = ev_capacity * charge_rate
+    return power_consumed
+
+# Display the grid load prediction and related EV info
+def display_grid_load_prediction_and_ev_info():
+    st.header("Grid Load Prediction and EV Charging Info")
+
+    # Allow user to manually set grid load using slider (0 to 5000 kW)
+    grid_load = st.slider(
+        "Select Grid Load (kW):",
+        min_value=0,
+        max_value=5000,
+        value=2000,  # Default value
+        step=100,
+        help="Drag the slider to set the desired grid load."
+    )
+
+    # Display the gauge chart based on selected load value
+    st.plotly_chart(create_gauge(grid_load), use_container_width=True)
+
+    # LED Indicators for overload/normal status
+    if grid_load > 3500:
+        st.markdown('<p style="color: red; font-size: 24px;">&#128313; Left LED: Overload! Grid is in danger.</p>', unsafe_allow_html=True)
+    else:
+        st.markdown('<p style="color: green; font-size: 24px;">&#128313; Right LED: Normal. Grid is stable.</p>', unsafe_allow_html=True)
+
+    # EV Charging Status
+    if grid_load < 3000:
+        st.markdown('<p style="color: green;">Green: Charging allowed. EVs can charge.</p>', unsafe_allow_html=True)
+        # Calculate and display the number of EVs that can be connected based on grid load
+        evs_connected = calculate_ev_requirements(grid_load)
+        st.write(f"Approximately {evs_connected} EVs can be connected to the grid for charging.")
+        
+    else:
+        st.markdown('<p style="color: red;">Red: Grid overload! Disconnecting EV from grid.</p>', unsafe_allow_html=True)
+        # If the load exceeds 3500 kW, calculate how much energy is needed to stabilize the grid
+        if grid_load > 3500:
+            energy_required = grid_load - 3500
+            evs_needed = calculate_ev_requirements(energy_required)
+            st.write(f"To stabilize the grid, {energy_required} kWh of energy is required.")
+            st.write(f"Approximately {evs_needed} EVs are needed to supply this energy to the grid.")
+
+            # Add a button to connect EVs to stabilize the grid
+            if st.button("Connect EVs to Stabilize Grid"):
+                grid_load -= energy_required  # Decrease grid load by the energy provided by EVs
+                st.write(f"Grid load reduced to {grid_load} kW. EVs are stabilizing the grid.")
+
+    # Allow the user to disconnect EVs if the grid load is too high
+    if grid_load > 3000:
+        st.button("Disconnect EV from Grid", key="disconnect_charge", help="Grid load is too high. Disconnect EV.")
+    else:
+        st.button("Allow EV to Charge", key="allow_charge", help="Grid load is normal. EVs can charge.")
 
-        # Export power status
-        if export_power:
-            st.warning("Battery is exporting power to the grid.")
-        else:
-            st.info("Battery is not exporting power.")
+# Display Main Application
+def main():
+    st.sidebar.title("EV Charging Optimization")
+    
+    # Display the Grid Load Prediction and EV Info all on the same page
+    display_grid_load_prediction_and_ev_info()
 
 if __name__ == "__main__":
     main()