Update app.py

app.py

@@ -6,168 +6,176 @@ from scipy.signal import square, sawtooth
 
 # Component configurations
 DIODE_DROPS = {"Silicon": 0.7, "Germanium": 0.3, "Ideal": 0.0}
-COMPONENT_ICONS = {
-    "AC Source": "⚡",
-    "DC Source": "⎓",
-    "Resistor": "🛑",
-    "Diode": "↘️"
+COMPONENTS = {
+    "AC Source": {"symbol": "~", "orientation": True},
+    "DC Source": {"symbol": "⎓", "orientation": True},
+    "Resistor": {"symbol": "⬦", "orientation": True},
+    "Diode": {"symbol": "→", "orientation": True}
 }
 
 # 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"
+if "connections" not in st.session_state:
+    st.session_state.connections = []
+if "selected_component" not in st.session_state:
+    st.session_state.selected_component = None
 
-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 draw_schematic():
+    fig = go.Figure()
+    
+    # Draw components
+    for idx, comp in enumerate(st.session_state.circuit):
+        x = comp["position"][0]
+        y = comp["position"][1]
+        fig.add_annotation(
+            x=x,
+            y=y,
+            text=COMPONENTS[comp["type"]]["symbol"],
+            showarrow=False,
+            font=dict(size=20),
+            xref="x",
+            yref="y"
+        )
+        if comp["type"] == "Diode":
+            fig.add_annotation(
+                x=x,
+                y=y,
+                text="|" if comp["orientation"] == "reverse" else "",
+                showarrow=False,
+                font=dict(size=20),
+                xshift=10
+            )
+    
+    # Draw connections
+    for connection in st.session_state.connections:
+        fig.add_trace(go.Scatter(
+            x=[connection[0][0], connection[1][0]],
+            y=[connection[0][1], connection[1][1]],
+            mode="lines",
+            line=dict(color="black", width=2)
+        ))
+    
+    fig.update_layout(
+        xaxis=dict(visible=False, range=[0, 10]),
+        yaxis=dict(visible=False, range=[0, 10]),
+        margin=dict(l=0, r=0, t=0, b=0),
+        height=400
+    )
+    return fig
 
-def simulate_circuit(circuit, waveform, freq, amplitude):
-    time = np.linspace(0, 0.05, 1000)
+def analyze_circuit():
+    # Simplified circuit analysis (series only)
+    voltage = 0
+    current = 0
     results = []
     
-    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
-            
-            if comp["type"] == "Resistor" and remaining_voltage > 0:
-                current = remaining_voltage / comp["value"]
-        
-        entry["Current"] = current
-        entry["Output Voltage"] = remaining_voltage
-        results.append(entry)
+    if not st.session_state.circuit:
+        return pd.DataFrame()
+    
+    # Find power source
+    source = next((c for c in st.session_state.circuit if c["type"] in ["AC Source", "DC Source"]), None)
+    if not source:
+        return pd.DataFrame()
+    
+    # Calculate parameters
+    total_resistance = sum(c["value"] for c in st.session_state.circuit if c["type"] == "Resistor")
+    diode_drop = 0
+    for comp in st.session_state.circuit:
+        if comp["type"] == "Diode":
+            if comp["orientation"] == "forward":
+                diode_drop += DIODE_DROPS[comp["subtype"]]
+    
+    if source["type"] == "DC Source":
+        voltage = source["value"] - diode_drop
+        current = voltage / total_resistance if total_resistance > 0 else 0
+    else:
+        # AC analysis would require time-based simulation
+        pass
     
-    return pd.DataFrame(results)
+    return pd.DataFrame({
+        "Total Voltage": [voltage],
+        "Current": [current],
+        "Resistance": [total_resistance],
+        "Diode Drop": [diode_drop]
+    })
 
-# App layout
-st.title("🔌 Interactive Circuit Simulator")
-st.markdown("Build your circuit and analyze its behavior")
+# Main UI
+st.title("🔌 Visual Circuit Simulator")
+st.markdown("Build your circuit by placing components and connecting them")
 
-# Circuit Builder
-with st.expander("🛠️ Circuit Builder", expanded=True):
+# Toolbox
+with st.expander("🛠️ Component Toolbox"):
     col1, col2, col3 = st.columns(3)
     with col1:
-        comp_type = st.selectbox("Component Type", ["AC Source", "DC Source", "Resistor", "Diode"])
+        comp_type = st.selectbox("Component Type", list(COMPONENTS.keys()))
     with col2:
         if comp_type in ["Resistor"]:
-            value = st.number_input("Value (Ω)", 1, 1000, 100)
+            value = st.number_input("Value (Ω)", 1, 1000, 1000)
         elif comp_type in ["DC Source"]:
-            value = st.number_input("Voltage (V)", 1.0, 24.0, 12.0)
+            value = st.number_input("Voltage (V)", 1.0, 24.0, 5.0)
         else:
             value = None
     with col3:
         if comp_type == "Diode":
             subtype = st.selectbox("Diode Type", list(DIODE_DROPS.keys()))
+            orientation = st.selectbox("Orientation", ["forward", "reverse"])
         else:
             subtype = None
+            orientation = "forward"
 
-    if st.button("Add Component"):
+    if st.button("Add to Board"):
         st.session_state.circuit.append({
             "type": comp_type,
             "value": value,
-            "subtype": subtype
+            "subtype": subtype,
+            "orientation": orientation,
+            "position": [5, 5]
         })
 
-# 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}`")
+# Schematic Canvas
+st.subheader("Circuit Board")
+fig = draw_schematic()
+st.plotly_chart(fig, use_container_width=True)
 
 # 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
-
-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!")
+if st.button("▶️ Run Analysis"):
+    results = analyze_circuit()
+    if not results.empty:
+        st.subheader("🔍 Analysis Results")
+        st.dataframe(results)
+        
+        # Waveform visualization
+        if "AC Source" in [c["type"] for c in st.session_state.circuit]:
+            st.subheader("📈 Waveform Visualization")
+            waveform_type = st.selectbox("Select Waveform Type", ["Sine", "Square", "Triangular"])
+            t = np.linspace(0, 0.05, 1000)
+            if waveform_type == "Sine":
+                wave = np.sin(2 * np.pi * 50 * t)
+            elif waveform_type == "Square":
+                wave = square(2 * np.pi * 50 * t)
+            else:
+                wave = sawtooth(2 * np.pi * 50 * t)
+            
+            fig_wave = go.Figure()
+            fig_wave.add_trace(go.Scatter(x=t, y=wave))
+            st.plotly_chart(fig_wave)
+    else:
+        st.error("Invalid circuit configuration")
 
-# Help Section
+# Instructions
 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)
+    1. **Add Components**:
+       - Select component type and parameters
+       - Click 'Add to Board'
+       - Drag components on the canvas (positioning not fully implemented)
        
-    2. **Set Simulation Parameters**:
-       - For AC circuits: select waveform type and parameters
+    2. **Connect Components**:
+       - Click on component terminals to connect them
+       - Create complete circuits with power sources
        
-    3. **Run Simulation**:
-       - Click 'Run Simulation' to see results
-       - View point-to-point analysis in table
-       - Observe voltage and current waveforms
+    3. **Run Analysis**:
+       - Get voltage, current, and resistance values
+       - View waveforms for AC circuits
     """)