Update app.py

app.py

@@ -1,192 +1,161 @@
-# Electrical Calculations Software
-# Covering generation, transmission, distribution, load flow, short circuit, cable sizing, transformers, power factor, harmonics
-
 import streamlit as st
 import numpy as np
 
-# Page config
-st.set_page_config(page_title="Comprehensive Electrical Engineering Calculator", layout="wide")
-st.title("⚡ Electrical Engineering Mega Calculator")
+# Page Configuration
+st.set_page_config(page_title="Ultimate Electrical Engineering Calculator", layout="wide", page_icon="⚡")
+st.title("⚡ Electrical Engineering Ultimate Calculator")
 
 # Sidebar Navigation
-st.sidebar.title("Navigation")
-section = st.sidebar.radio("Select Section", [
+st.sidebar.title("🔍 Navigation")
+section = st.sidebar.selectbox("Go to Section", [
     "Generation",
     "Transmission",
     "Distribution",
     "Power Quality",
     "Miscellaneous",
-    "Standards & Codes"
+    "NEPRA Standards"
 ])
 
-# Constants for unit conversions
-M2_IN_ACRE = 4046.86
-M2_IN_KM2 = 1_000_000
-
-# Generation Section
+# Utility Functions
+def calculate_area_conversions(area_acres):
+    m2 = area_acres * 4046.86
+    km2 = area_acres * 0.00404686
+    return m2, km2
+
+# Formulas Documentation
+formulas = {
+    # Generation
+    "Load Factor": "Load Factor = Average Load / Peak Load",
+    "Plant Capacity Factor": "Plant Capacity Factor = Actual Output / Maximum Possible Output",
+    "Cost per MWh": "Cost per MWh = Total Cost / Total Energy Generated",
+
+    # Transmission
+    "Impedance": "Z = √(R² + X²)",
+    "Short Circuit Current": "Isc = Voltage / (√3 × Impedance)",
+    "Grid Requirements": "Grids = Area × Power Density (MW/km²)",
+
+    # Distribution
+    "Voltage Drop": "Voltage Drop = 2 × Resistance × Current",
+    "Cable Size": "Cable Size = Current / Permissible Current Density",
+    "Transformer Sizing": "Transformer Size = Connected Load / Power Factor",
+
+    # Power Quality
+    "Apparent Power": "S = √(P² + Q²)",
+    "Resonant Frequency": "f = 1 / (2π√(LC))",
+    "Harmonic Frequency": "Harmonic Frequency = Base Frequency × Harmonic Order"
+}
+
+# Section: Generation
 if section == "Generation":
-    st.header("🔋 Power Generation Calculations")
-    gen_calc = st.selectbox("Choose Calculation", [
-        "Load Factor",
-        "Plant Capacity Factor",
-        "Cost per MWh",
-        "Energy Generation"
-    ])
-    
-    if gen_calc == "Load Factor":
-        avg_load = st.number_input("Average Load (MW)", min_value=0.0)
-        peak_load = st.number_input("Peak Load (MW)", min_value=0.1)
-        if st.button("Calculate Load Factor"):
+    st.header("🔋 Generation Calculations")
+    calc_type = st.selectbox("Select Calculation", ["Load Factor", "Plant Capacity Factor", "Cost per MWh"])
+    st.markdown(f"**Formula Used:** {formulas[calc_type]}")
+
+    if calc_type == "Load Factor":
+        avg_load = st.slider("Average Load (MW)", 0.0, 500.0, 100.0)
+        peak_load = st.slider("Peak Load (MW)", 0.1, 500.0, 120.0)
+        if peak_load > 0:
             load_factor = avg_load / peak_load
-            st.success(f"Load Factor = {load_factor:.2f} ({load_factor*100:.2f}%)")
-
-    elif gen_calc == "Plant Capacity Factor":
-        actual_output = st.number_input("Actual Energy Output (MWh)", min_value=0.0)
-        max_output = st.number_input("Maximum Possible Output (MWh)", min_value=0.1)
-        if st.button("Calculate Plant Capacity Factor"):
-            pcf = actual_output / max_output
-            st.success(f"Plant Capacity Factor = {pcf:.2f} ({pcf*100:.2f}%)")
-
-    elif gen_calc == "Cost per MWh":
-        total_cost = st.number_input("Total Generation Cost (USD)", min_value=0.0)
-        energy_generated = st.number_input("Energy Generated (MWh)", min_value=0.1)
-        if st.button("Calculate Cost/MWh"):
-            cost_mwh = total_cost / energy_generated
-            st.success(f"Cost per MWh = ${cost_mwh:.2f}")
-
-    elif gen_calc == "Energy Generation":
-        capacity_mw = st.number_input("Installed Capacity (MW)", min_value=0.0)
-        operating_hours = st.number_input("Operating Hours", min_value=0.0)
-        if st.button("Calculate Total Energy"):
-            total_energy = capacity_mw * operating_hours
-            st.success(f"Total Energy Generated = {total_energy:.2f} MWh")
-
-# Transmission Section
+            st.success(f"Load Factor: {load_factor:.2f} ({load_factor * 100:.2f}%)")
+
+    elif calc_type == "Plant Capacity Factor":
+        actual_output = st.slider("Actual Output (MWh)", 0.0, 10000.0, 5000.0)
+        max_output = st.slider("Maximum Output (MWh)", 1.0, 10000.0, 8000.0)
+        if max_output > 0:
+            capacity_factor = actual_output / max_output
+            st.success(f"Plant Capacity Factor: {capacity_factor:.2f} ({capacity_factor * 100:.2f}%)")
+
+    elif calc_type == "Cost per MWh":
+        total_cost = st.slider("Total Cost ($)", 0.0, 500000.0, 100000.0)
+        total_energy = st.slider("Total Energy (MWh)", 1.0, 10000.0, 5000.0)
+        if total_energy > 0:
+            cost_per_mwh = total_cost / total_energy
+            st.success(f"Cost per MWh: ${cost_per_mwh:.2f}")
+
+# Section: Transmission
 elif section == "Transmission":
-    st.header("🚧 Transmission System Calculations")
-    trans_calc = st.selectbox("Choose Calculation", [
-        "Impedance Calculation",
-        "Short Circuit Current",
-        "Grid Requirement"
-    ])
-
-    if trans_calc == "Impedance Calculation":
-        resistance = st.number_input("Resistance (Ohms)", min_value=0.0)
-        reactance = st.number_input("Reactance (Ohms)", min_value=0.0)
-        if st.button("Calculate Impedance"):
-            impedance = np.sqrt(resistance**2 + reactance**2)
-            st.success(f"Impedance = {impedance:.4f} Ω")
-
-    elif trans_calc == "Short Circuit Current":
-        voltage = st.number_input("System Voltage (V)", min_value=0.1)
-        impedance = st.number_input("Impedance (Ohms)", min_value=0.01)
-        if st.button("Calculate Isc"):
-            isc = voltage / (np.sqrt(3) * impedance)
-            st.success(f"Short Circuit Current = {isc:.2f} A")
-
-    elif trans_calc == "Grid Requirement":
-        area_unit = st.selectbox("Area Unit", ["Acres", "m²", "km²"])
-        area_value = st.number_input(f"Area ({area_unit})", min_value=0.1)
-        density = st.slider("Power Density (MW/km²)", 5.0, 100.0, 30.0)
-
-        if area_unit == "Acres":
-            m2 = area_value * M2_IN_ACRE
-        elif area_unit == "m²":
-            m2 = area_value
-        elif area_unit == "km²":
-            m2 = area_value * M2_IN_KM2
-
-        km2 = m2 / M2_IN_KM2
-        required_mw = km2 * density
-
-        st.metric("Area (km²)", f"{km2:.2f}")
-        st.metric("Required MW", f"{required_mw:.2f}")
-
-# Distribution Section
+    st.header("🌐 Transmission Calculations")
+    calc_type = st.selectbox("Select Calculation", ["Impedance", "Short Circuit Current", "Grid Requirements"])
+    st.markdown(f"**Formula Used:** {formulas[calc_type]}")
+
+    if calc_type == "Impedance":
+        resistance = st.slider("Resistance (Ω)", 0.0, 100.0, 10.0)
+        reactance = st.slider("Reactance (Ω)", 0.0, 100.0, 5.0)
+        impedance = np.sqrt(resistance**2 + reactance**2)
+        st.success(f"Total Impedance: {impedance:.2f} Ω")
+
+    elif calc_type == "Short Circuit Current":
+        voltage = st.slider("Voltage (V)", 100.0, 50000.0, 11000.0)
+        impedance = st.slider("System Impedance (Ω)", 0.01, 100.0, 5.0)
+        isc = voltage / (np.sqrt(3) * impedance)
+        st.success(f"Short Circuit Current: {isc:.2f} A")
+
+    elif calc_type == "Grid Requirements":
+        area_acres = st.slider("Area (acres)", 1.0, 10000.0, 100.0)
+        power_density = st.slider("Power Density (MW/km²)", 1.0, 10.0, 5.0)
+        m2, km2 = calculate_area_conversions(area_acres)
+        grids = km2 * power_density
+        st.metric("Area (m²)", f"{m2:.2f} m²")
+        st.metric("Area (km²)", f"{km2:.4f} km²")
+        st.success(f"Estimated Power Generation: {grids:.2f} MW")
+
+# Section: Distribution
 elif section == "Distribution":
-    st.header("🏙️ Distribution System Calculations")
-    dist_calc = st.selectbox("Choose Calculation", [
-        "Cable Sizing",
-        "Voltage Drop",
-        "Transformer Sizing"
-    ])
-
-    if dist_calc == "Cable Sizing":
-        current = st.number_input("Current (A)", min_value=0.0)
-        density = st.number_input("Permissible Current Density (A/mm²)", min_value=0.01)
-        if st.button("Calculate Cable Size"):
-            cable_area = current / density
-            st.success(f"Required Cable Area = {cable_area:.2f} mm²")
-
-    elif dist_calc == "Voltage Drop":
-        resistance = st.number_input("Resistance per phase (Ohms)", min_value=0.0)
-        current = st.number_input("Current (A)", min_value=0.0)
-        system_voltage = st.number_input("System Voltage (V)", min_value=0.1)
-        if st.button("Calculate Voltage Drop"):
-            vd = 2 * resistance * current
-            percentage = (vd / system_voltage) * 100
-            st.success(f"Voltage Drop = {vd:.2f} V ({percentage:.2f}%)")
-
-    elif dist_calc == "Transformer Sizing":
-        connected_load = st.number_input("Connected Load (kW)", min_value=0.0)
-        power_factor = st.number_input("Power Factor", min_value=0.1, max_value=1.0)
-        if st.button("Calculate Transformer Size"):
-            size = connected_load / power_factor
-            st.success(f"Transformer Size = {size:.2f} kVA")
-
-# Power Quality Section
+    st.header("🏘️ Distribution Calculations")
+    calc_type = st.selectbox("Select Calculation", ["Voltage Drop", "Cable Size", "Transformer Sizing"])
+    st.markdown(f"**Formula Used:** {formulas[calc_type]}")
+
+    if calc_type == "Voltage Drop":
+        resistance = st.slider("Resistance (Ω)", 0.0, 10.0, 1.0)
+        current = st.slider("Current (A)", 0.0, 1000.0, 100.0)
+        voltage_drop = 2 * resistance * current
+        st.success(f"Voltage Drop: {voltage_drop:.2f} V")
+
+    elif calc_type == "Cable Size":
+        current = st.slider("Current (A)", 0.0, 5000.0, 200.0)
+        permissible_density = st.slider("Permissible Current Density (A/mm²)", 1.0, 10.0, 5.0)
+        cable_size = current / permissible_density
+        st.success(f"Required Cable Size: {cable_size:.2f} mm²")
+
+    elif calc_type == "Transformer Sizing":
+        load = st.slider("Connected Load (kW)", 0.0, 5000.0, 1000.0)
+        pf = st.slider("Power Factor", 0.1, 1.0, 0.9)
+        transformer_size = load / pf
+        st.success(f"Required Transformer Size: {transformer_size:.2f} kVA")
+
+# Section: Power Quality
 elif section == "Power Quality":
-    st.header("🎯 Power Quality Calculations")
-    quality_calc = st.selectbox("Choose Calculation", [
-        "Power Factor Correction",
-        "Harmonic Frequency"
-    ])
-
-    if quality_calc == "Power Factor Correction":
-        existing_pf = st.number_input("Existing Power Factor", min_value=0.1, max_value=1.0)
-        desired_pf = st.number_input("Desired Power Factor", min_value=0.1, max_value=1.0)
-        load_kw = st.number_input("Load (kW)", min_value=0.0)
-        if st.button("Calculate Required kVAR"):
-            kvar_needed = load_kw * (np.tan(np.arccos(existing_pf)) - np.tan(np.arccos(desired_pf)))
-            st.success(f"Reactive Power (kVAR) needed = {kvar_needed:.2f}")
-
-    elif quality_calc == "Harmonic Frequency":
-        base_freq = st.number_input("Base Frequency (Hz)", value=50)
-        harmonic_order = st.number_input("Harmonic Order", value=3)
-        if st.button("Calculate Harmonic Frequency"):
-            harmonic_freq = base_freq * harmonic_order
-            st.success(f"Harmonic Frequency = {harmonic_freq:.2f} Hz")
-
-# Miscellaneous Section
-elif section == "Miscellaneous":
-    st.header("📈 Other Useful Calculations")
-    misc_calc = st.selectbox("Choose Calculation", [
-        "Apparent Power",
-        "Resonant Frequency"
-    ])
-
-    if misc_calc == "Apparent Power":
-        real_power = st.number_input("Real Power (W)", min_value=0.0)
-        reactive_power = st.number_input("Reactive Power (VAR)", min_value=0.0)
-        if st.button("Calculate Apparent Power"):
-            apparent = np.sqrt(real_power**2 + reactive_power**2)
-            st.success(f"Apparent Power = {apparent:.2f} VA")
-
-    elif misc_calc == "Resonant Frequency":
-        L = st.number_input("Inductance (H)", min_value=0.000001)
-        C = st.number_input("Capacitance (F)", min_value=0.000001)
-        if st.button("Calculate Resonant Frequency"):
-            freq = 1 / (2 * np.pi * np.sqrt(L * C))
-            st.success(f"Resonant Frequency = {freq:.2f} Hz")
-
-# Standards and Codes Section
-elif section == "Standards & Codes":
-    st.header("📚 Electrical Standards and Documents")
-    st.info("Upload NEPRA codes, IEEE standards, or IEC guidelines for reference.")
-    uploaded_file = st.file_uploader("Upload Document", type=["pdf", "docx", "txt"])
+    st.header("⚡ Power Quality Calculations")
+    calc_type = st.selectbox("Select Calculation", ["Apparent Power", "Resonant Frequency", "Harmonic Frequency"])
+    st.markdown(f"**Formula Used:** {formulas[calc_type]}")
+
+    if calc_type == "Apparent Power":
+        real_power = st.slider("Real Power (W)", 0.0, 100000.0, 10000.0)
+        reactive_power = st.slider("Reactive Power (VAR)", 0.0, 100000.0, 5000.0)
+        apparent_power = np.sqrt(real_power**2 + reactive_power**2)
+        st.success(f"Apparent Power: {apparent_power:.2f} VA")
+
+    elif calc_type == "Resonant Frequency":
+        inductance = st.slider("Inductance (H)", 0.0001, 1.0, 0.01)
+        capacitance = st.slider("Capacitance (F)", 0.000001, 0.01, 0.00001)
+        freq = 1 / (2 * np.pi * np.sqrt(inductance * capacitance))
+        st.success(f"Resonant Frequency: {freq:.2f} Hz")
+
+    elif calc_type == "Harmonic Frequency":
+        base_freq = st.slider("Base Frequency (Hz)", 40.0, 70.0, 50.0)
+        order = st.slider("Harmonic Order", 1, 50, 3)
+        harmonic_freq = base_freq * order
+        st.success(f"Harmonic Frequency: {harmonic_freq:.2f} Hz")
+
+# Section: NEPRA Standards
+elif section == "NEPRA Standards":
+    st.header("📚 NEPRA Standards and Documentation")
+    st.info("Upload or download official NEPRA documents here.")
+    uploaded_file = st.file_uploader("Upload NEPRA Standard Document", type=["pdf", "docx"])
     if uploaded_file:
-        st.success(f"Uploaded file: {uploaded_file.name}")
-        st.download_button("Download File", uploaded_file, file_name=uploaded_file.name)
+        st.success(f"Uploaded: {uploaded_file.name}")
+    st.download_button(label="Download Sample NEPRA Guidelines", data=b"Sample NEPRA Content", file_name="nepra_sample.docx")
 
-# End of Code
-   
+# Footer
+st.markdown("---")
+st.caption("Developed with ❤️ for Electrical Engineers")