Update app.py

app.py

@@ -1,105 +1,173 @@
 import streamlit as st
 import numpy as np
+import pandas as pd
 import plotly.graph_objects as go
 from scipy.signal import square, sawtooth
 
-# Diode voltage drops
-DIODE_VOLTAGES = {
-    "Ideal": 0.0,
-    "Silicon": 0.7,
-    "Germanium": 0.3
+# Component configurations
+DIODE_DROPS = {"Silicon": 0.7, "Germanium": 0.3, "Ideal": 0.0}
+COMPONENT_ICONS = {
+    "AC Source": "⚡",
+    "DC Source": "⎓",
+    "Resistor": "🛑",
+    "Diode": "↘️"
 }
 
-def generate_waveform(wave_type, freq, amplitude, duration=0.05):
-    t = np.linspace(0, duration, 1000)
-    if wave_type == "Sine":
-        y = amplitude * np.sin(2 * np.pi * freq * t)
-    elif wave_type == "Square":
-        y = amplitude * square(2 * np.pi * freq * t)
-    elif wave_type == "Triangular":
-        y = amplitude * sawtooth(2 * np.pi * freq * t, width=0.5)
-    return t, y
+# Initialize session state
+if "circuit" not in st.session_state:
+    st.session_state.circuit = []
+if "waveform_type" not in st.session_state:
+    st.session_state.waveform_type = "Sine"
 
-def simulate_circuit(input_wave, diode_type, resistance):
-    v_diode = DIODE_VOLTAGES[diode_type]
-    output_wave = np.zeros_like(input_wave)
+def calculate_voltage_drop(component, voltage, current):
+    if component["type"] == "Resistor":
+        return current * component["value"]
+    elif component["type"] == "Diode":
+        return DIODE_DROPS[component["subtype"]] if voltage > DIODE_DROPS[component["subtype"]] else 0
+    return 0
+
+def simulate_circuit(circuit, waveform, freq, amplitude):
+    time = np.linspace(0, 0.05, 1000)
+    results = []
     
-    for i in range(len(input_wave)):
-        if input_wave[i] > v_diode:
-            output_wave[i] = input_wave[i] - v_diode
-        elif input_wave[i] < -v_diode:
-            output_wave[i] = input_wave[i] + v_diode
-        else:
-            output_wave[i] = 0
+    for t_idx, t in enumerate(time):
+        entry = {"Time": t}
+        if circuit[0]["type"] == "AC Source":
+            if st.session_state.waveform_type == "Sine":
+                v_in = amplitude * np.sin(2 * np.pi * freq * t)
+            elif st.session_state.waveform_type == "Square":
+                v_in = amplitude * square(2 * np.pi * freq * t)
+            else:  # Triangular
+                v_in = amplitude * sawtooth(2 * np.pi * freq * t, width=0.5)
+        else:  # DC Source
+            v_in = circuit[0]["value"]
+        
+        current = 0
+        remaining_voltage = v_in
+        entry["Source Voltage"] = v_in
+        
+        for comp in circuit[1:]:
+            v_drop = calculate_voltage_drop(comp, remaining_voltage, current)
+            entry[f"{comp['type']} {comp.get('subtype', '')}"] = v_drop
+            remaining_voltage -= v_drop
             
-    current = output_wave / resistance  # I = V/R
-    return output_wave, current
-
-# Streamlit UI
-st.title("📈 Electronic Waveform Simulator")
-st.markdown("Simulate circuit behavior with different diodes and waveforms")
-
-col1, col2 = st.columns(2)
-with col1:
-    diode_type = st.selectbox("Diode Type", ["Ideal", "Silicon", "Germanium"])
-    waveform_type = st.selectbox("Waveform Type", ["Sine", "Square", "Triangular"])
+            if comp["type"] == "Resistor" and remaining_voltage > 0:
+                current = remaining_voltage / comp["value"]
+        
+        entry["Current"] = current
+        entry["Output Voltage"] = remaining_voltage
+        results.append(entry)
     
-with col2:
-    freq = st.slider("Frequency (Hz)", 1, 1000, 50)
-    amplitude = st.slider("Amplitude (V)", 1.0, 20.0, 12.0)
-    resistance = st.slider("Resistance (Ω)", 1, 1000, 100)
-
-# Generate waveforms
-t, input_wave = generate_waveform(waveform_type, freq, amplitude)
-output_wave, current = simulate_circuit(input_wave, diode_type, resistance)
+    return pd.DataFrame(results)
 
-# Create plots
-fig = go.Figure()
-fig.add_trace(go.Scatter(x=t, y=input_wave, name="Input Voltage", line=dict(color='blue')))
-fig.add_trace(go.Scatter(x=t, y=output_wave, name="Output Voltage", line=dict(color='red')))
-fig.update_layout(title="Voltage Waveforms",
-                 xaxis_title="Time (s)",
-                 yaxis_title="Voltage (V)",
-                 hovermode="x unified")
+# App layout
+st.title("🔌 Interactive Circuit Simulator")
+st.markdown("Build your circuit and analyze its behavior")
 
-fig2 = go.Figure()
-fig2.add_trace(go.Scatter(x=t, y=current*1000, name="Current", line=dict(color='green')))
-fig2.update_layout(title="Circuit Current",
-                 xaxis_title="Time (s)",
-                 yaxis_title="Current (mA)",
-                 hovermode="x unified")
+# Circuit Builder
+with st.expander("🛠️ Circuit Builder", expanded=True):
+    col1, col2, col3 = st.columns(3)
+    with col1:
+        comp_type = st.selectbox("Component Type", ["AC Source", "DC Source", "Resistor", "Diode"])
+    with col2:
+        if comp_type in ["Resistor"]:
+            value = st.number_input("Value (Ω)", 1, 1000, 100)
+        elif comp_type in ["DC Source"]:
+            value = st.number_input("Voltage (V)", 1.0, 24.0, 12.0)
+        else:
+            value = None
+    with col3:
+        if comp_type == "Diode":
+            subtype = st.selectbox("Diode Type", list(DIODE_DROPS.keys()))
+        else:
+            subtype = None
 
-# Display results
-st.plotly_chart(fig, use_container_width=True)
-st.plotly_chart(fig2, use_container_width=True)
+    if st.button("Add Component"):
+        st.session_state.circuit.append({
+            "type": comp_type,
+            "value": value,
+            "subtype": subtype
+        })
 
-# Circuit analysis
-st.subheader("Circuit Analysis")
-col3, col4, col5 = st.columns(3)
-with col3:
-    st.metric("Peak Input Voltage", f"{np.max(input_wave):.2f} V")
-with col4:
-    st.metric("Peak Output Voltage", f"{np.max(output_wave):.2f} V")
-with col5:
-    st.metric("Max Current", f"{np.max(current)*1000:.2f} mA")
+# Display Circuit
+st.subheader("Your Circuit")
+if not st.session_state.circuit:
+    st.warning("No components in circuit!")
+else:
+    circuit_display = " → ".join([
+        f"{COMPONENT_ICONS[comp['type']]} {comp['type']}" + 
+        (f" ({comp['subtype']})" if comp.get('subtype') else "") +
+        (f" {comp['value']}Ω" if comp['type'] == "Resistor" else "") +
+        (f" {comp['value']}V" if comp['type'] == "DC Source" else "")
+        for comp in st.session_state.circuit
+    ])
+    st.markdown(f"`{circuit_display}`")
 
-# Circuit diagram
-st.subheader("Circuit Diagram")
-st.code(f"""
-    AC Source ({amplitude}V {waveform_type}) 
-    ────┤ Diode ({diode_type}) ├─── Resistor ({resistance}Ω) ────
-    """)
+# Simulation Controls
+st.subheader("Simulation Parameters")
+if st.session_state.circuit and st.session_state.circuit[0]["type"] == "AC Source":
+    st.session_state.waveform_type = st.selectbox("Waveform Type", ["Sine", "Square", "Triangular"])
+    freq = st.slider("Frequency (Hz)", 1, 1000, 50)
+    amplitude = st.slider("Amplitude (V)", 1.0, 24.0, 12.0)
+else:
+    freq = None
+    amplitude = None
 
-# Theory explanation
-st.subheader("Theory Overview")
-st.markdown(f"""
-This simulator shows a simple diode-resistor circuit:
-- **Input**: {waveform_type} wave at {freq}Hz with {amplitude}V amplitude
-- **Diode**: {diode_type} (Forward voltage: {DIODE_VOLTAGES[diode_type]}V)
-- **Load**: {resistance}Ω resistor
+if st.button("▶️ Run Simulation") and st.session_state.circuit:
+    # Run simulation
+    df = simulate_circuit(
+        st.session_state.circuit,
+        st.session_state.waveform_type,
+        freq,
+        amplitude
+    )
+    
+    # Display Results
+    st.subheader("📊 Simulation Results")
+    
+    # Observation Table
+    with st.expander("📋 Point-to-Point Analysis", expanded=True):
+        st.dataframe(df.style.format("{:.4f}"), height=300)
+    
+    # Waveform Visualization
+    fig = go.Figure()
+    fig.add_trace(go.Scatter(x=df["Time"], y=df["Source Voltage"], name="Input Voltage"))
+    fig.add_trace(go.Scatter(x=df["Time"], y=df["Output Voltage"], name="Output Voltage"))
+    fig.update_layout(
+        title="Voltage Waveforms",
+        xaxis_title="Time (s)",
+        yaxis_title="Voltage (V)",
+        hovermode="x unified"
+    )
+    st.plotly_chart(fig, use_container_width=True)
+    
+    # Current Visualization
+    fig2 = go.Figure()
+    fig2.add_trace(go.Scatter(x=df["Time"], y=df["Current"]*1000, name="Current"))
+    fig2.update_layout(
+        title="Circuit Current",
+        xaxis_title="Time (s)",
+        yaxis_title="Current (mA)",
+        hovermode="x unified"
+    )
+    st.plotly_chart(fig2, use_container_width=True)
+elif not st.session_state.circuit:
+    st.error("Please build a circuit first!")
 
-The output waveform shows:
-- Positive half-cycles reduced by {DIODE_VOLTAGES[diode_type]}V diode drop
-- Negative half-cycles {'clipped' if diode_type == 'Ideal' else 'partially conducted'}
-- Current calculated using Ohm's Law (I = V/R)
-""")
+# Help Section
+with st.expander("❓ How to use"):
+    st.markdown("""
+    1. **Build Circuit**:
+       - Select component type from dropdown
+       - Configure parameters (resistance, voltage, diode type)
+       - Click 'Add Component' to add to circuit
+       - First component must be a power source (AC/DC)
+       
+    2. **Set Simulation Parameters**:
+       - For AC circuits: select waveform type and parameters
+       
+    3. **Run Simulation**:
+       - Click 'Run Simulation' to see results
+       - View point-to-point analysis in table
+       - Observe voltage and current waveforms
+    """)