Update src/streamlit_app.py

src/streamlit_app.py

@@ -1,7 +1,6 @@
 import streamlit as st
 import numpy as np
 import plotly.graph_objects as go
-import plotly.express as px
 from plotly.subplots import make_subplots
 from kinematics_visualizer import Motion1D, Motion2D, KinematicsVisualizer
 
@@ -63,25 +62,19 @@ st.markdown("""
 def main():
     st.markdown('<div class="main-header">🚀 Physics Tutorial: Kinematics</div>', unsafe_allow_html=True)
     
-    # Use selectbox instead of radio (forces full page refresh)
+    # Sidebar for navigation
     st.sidebar.title("📚 Select Tutorial")
-    tutorial_type = st.sidebar.selectbox(
+    tutorial_type = st.sidebar.radio(
         "Choose a physics concept:",
-        ["1D Motion", "2D Projectile Motion", "Compare Motions"]
+        ["1D Motion", "2D Projectile Motion"]
     )
     
-    # Force complete refresh when changing tutorials
     if tutorial_type == "1D Motion":
-        st.cache_data.clear()  # Clear all caches
         show_1d_motion()
     elif tutorial_type == "2D Projectile Motion":
-        st.cache_data.clear()  # Clear all caches
         show_2d_motion()
-    elif tutorial_type == "Compare Motions":
-        st.cache_data.clear()  # Clear all caches
-        show_motion_comparison()
 
-def create_1d_motion_plot(motion: Motion1D, duration: float, title: str):
+def create_1d_motion_plot_plotly(motion: Motion1D, duration: float, title: str):
     """Create 1D motion plots using Plotly"""
     # Generate time arrays
     t, x, v, a = motion.time_arrays(duration, dt=0.01)
@@ -138,7 +131,7 @@ def create_1d_motion_plot(motion: Motion1D, duration: float, title: str):
     
     return fig
 
-def create_2d_trajectory_plot(motion: Motion2D, title: str):
+def create_2d_trajectory_plot_plotly(motion: Motion2D, title: str):
     """Create 2D trajectory plot using Plotly"""
     flight_time = motion.calculate_flight_time()
     data = motion.trajectory_data(flight_time)
@@ -177,16 +170,17 @@ def create_2d_trajectory_plot(motion: Motion2D, title: str):
         ))
     
     # Add maximum height point
-    max_height_idx = np.argmax(data['y'])
-    if max_height_idx > 0:
-        fig.add_trace(go.Scatter(
-            x=[data['x'][max_height_idx]],
-            y=[data['y'][max_height_idx]],
-            mode='markers',
-            name='Max Height',
-            marker=dict(color='orange', size=10, symbol='triangle-up'),
-            hovertemplate='Max Height<br>X: %{x:.1f} m<br>Y: %{y:.1f} m<extra></extra>'
-        ))
+    if len(data['y']) > 0:
+        max_height_idx = np.argmax(data['y'])
+        if max_height_idx > 0:
+            fig.add_trace(go.Scatter(
+                x=[data['x'][max_height_idx]],
+                y=[data['y'][max_height_idx]],
+                mode='markers',
+                name='Max Height',
+                marker=dict(color='orange', size=10, symbol='triangle-up'),
+                hovertemplate='Max Height<br>X: %{x:.1f} m<br>Y: %{y:.1f} m<extra></extra>'
+            ))
     
     # Update layout
     fig.update_layout(
@@ -201,8 +195,12 @@ def create_2d_trajectory_plot(motion: Motion2D, title: str):
     )
     
     # Set axis ranges
-    fig.update_xaxes(range=[0, max(data['x']) * 1.1 if len(data['x']) > 0 else 10])
-    fig.update_yaxes(range=[0, max(data['y']) * 1.2 if len(data['y']) > 0 else 10])
+    if len(data['x']) > 0 and len(data['y']) > 0:
+        fig.update_xaxes(range=[0, max(data['x']) * 1.1])
+        fig.update_yaxes(range=[0, max(data['y']) * 1.2])
+    else:
+        fig.update_xaxes(range=[0, 10])
+        fig.update_yaxes(range=[0, 10])
     
     # Add grid
     fig.update_xaxes(showgrid=True, gridwidth=1, gridcolor='rgba(128,128,128,0.3)')
@@ -213,105 +211,93 @@ def create_2d_trajectory_plot(motion: Motion2D, title: str):
 def show_1d_motion():
     st.markdown('<div class="section-header">📏 One-Dimensional Motion</div>', unsafe_allow_html=True)
     
-    # Add unique container key
-    with st.container(key="1d_motion_container"):
-        # Physics equations display
-        with st.expander("📖 Physics Equations (Click to expand)", expanded=False):
-            st.markdown("""
-            <div class="physics-equation">
-            <h4>Kinematic Equations for Constant Acceleration:</h4>
-            <ul>
-                <li><strong>Position:</strong> x(t) = x₀ + v₀t + ½at²</li>
-                <li><strong>Velocity:</strong> v(t) = v₀ + at</li>
-                <li><strong>Acceleration:</strong> a(t) = constant</li>
-            </ul>
-            <p><strong>Where:</strong></p>
-            <ul>
-                <li>x₀ = initial position (m)</li>
-                <li>v₀ = initial velocity (m/s)</li>
-                <li>a = acceleration (m/s²)</li>
-                <li>t = time (s)</li>
-            </ul>
-            </div>
-            """, unsafe_allow_html=True)
-        
-        # Create two columns for controls and results
-        col1, col2 = st.columns([1, 2])
-        
-        with col1:
-            st.markdown('<div class="section-header">🎛️ Control Parameters</div>', unsafe_allow_html=True)
-            
-            # Parameter sliders with unique keys for 1D motion
-            initial_pos = st.slider(
-                "Initial Position (m)", 
-                min_value=-50.0, max_value=50.0, value=0.0, step=1.0,
-                help="Starting position of the object",
-                key="1d_initial_pos"
-            )
-            
-            initial_vel = st.slider(
-                "Initial Velocity (m/s)", 
-                min_value=-30.0, max_value=30.0, value=5.0, step=1.0,
-                help="Starting velocity of the object",
-                key="1d_initial_vel"
-            )
-            
-            acceleration = st.slider(
-                "Acceleration (m/s²)", 
-                min_value=-15.0, max_value=15.0, value=2.0, step=0.5,
-                help="Constant acceleration (positive = speeding up in positive direction)",
-                key="1d_acceleration"
-            )
-            
-            duration = st.slider(
-                "Simulation Duration (s)", 
-                min_value=1.0, max_value=20.0, value=10.0, step=0.5,
-                help="How long to run the simulation",
-                key="1d_duration"
-            )
-            
-            # Display current parameters
-            st.markdown('<div class="parameter-box">', unsafe_allow_html=True)
-            st.markdown("**Current Parameters:**")
-            st.write(f"• Initial Position: {initial_pos:.1f} m")
-            st.write(f"• Initial Velocity: {initial_vel:.1f} m/s")
-            st.write(f"• Acceleration: {acceleration:.1f} m/s²")
-            st.write(f"• Duration: {duration:.1f} s")
-            
-            # Calculate final values
-            final_pos = initial_pos + initial_vel * duration + 0.5 * acceleration * duration**2
-            final_vel = initial_vel + acceleration * duration
-            
-            st.markdown("**Final Values:**")
-            st.write(f"• Final Position: {final_pos:.1f} m")
-            st.write(f"• Final Velocity: {final_vel:.1f} m/s")
-            st.markdown('</div>', unsafe_allow_html=True)
-        
-        with col2:
-            # Create unique cache function for 1D motion ONLY
-            @st.cache_data(show_spinner=False)
-            def create_1d_motion_plot_unique(tab_id, initial_pos, initial_vel, acceleration, duration):
-                """Tab-specific 1D motion plot - includes tab_id to prevent cross-contamination"""
-                motion = Motion1D(
-                    initial_position=initial_pos,
-                    initial_velocity=initial_vel,
-                    acceleration=acceleration
-                )
-                
-                # Generate title based on motion type
-                if acceleration > 0:
-                    motion_type = "Accelerating Motion"
-                elif acceleration < 0:
-                    motion_type = "Decelerating Motion"
-                else:
-                    motion_type = "Constant Velocity Motion"
-                
-                return create_1d_motion_plot(motion, duration, motion_type)
-            
-            # Create and display Plotly chart with tab-specific cache
-            fig = create_1d_motion_plot_unique("1d_tab", initial_pos, initial_vel, acceleration, duration)
-            st.plotly_chart(fig, use_container_width=True, key="1d_motion_plot_unique")
-
+    # Physics equations display
+    with st.expander("📖 Physics Equations (Click to expand)", expanded=False):
+        st.markdown("""
+        <div class="physics-equation">
+        <h4>Kinematic Equations for Constant Acceleration:</h4>
+        <ul>
+            <li><strong>Position:</strong> x(t) = x₀ + v₀t + ½at²</li>
+            <li><strong>Velocity:</strong> v(t) = v₀ + at</li>
+            <li><strong>Acceleration:</strong> a(t) = constant</li>
+        </ul>
+        <p><strong>Where:</strong></p>
+        <ul>
+            <li>x₀ = initial position (m)</li>
+            <li>v₀ = initial velocity (m/s)</li>
+            <li>a = acceleration (m/s²)</li>
+            <li>t = time (s)</li>
+        </ul>
+        </div>
+        """, unsafe_allow_html=True)
+    
+    # Create two columns for controls and results
+    col1, col2 = st.columns([1, 2])
+    
+    with col1:
+        st.markdown('<div class="section-header">🎛️ Control Parameters</div>', unsafe_allow_html=True)
+        
+        # Parameter sliders
+        initial_pos = st.slider(
+            "Initial Position (m)", 
+            min_value=-50.0, max_value=50.0, value=0.0, step=1.0,
+            help="Starting position of the object"
+        )
+        
+        initial_vel = st.slider(
+            "Initial Velocity (m/s)", 
+            min_value=-30.0, max_value=30.0, value=5.0, step=1.0,
+            help="Starting velocity of the object"
+        )
+        
+        acceleration = st.slider(
+            "Acceleration (m/s²)", 
+            min_value=-15.0, max_value=15.0, value=2.0, step=0.5,
+            help="Constant acceleration (positive = speeding up in positive direction)"
+        )
+        
+        duration = st.slider(
+            "Simulation Duration (s)", 
+            min_value=1.0, max_value=20.0, value=10.0, step=0.5,
+            help="How long to run the simulation"
+        )
+        
+        # Display current parameters
+        st.markdown('<div class="parameter-box">', unsafe_allow_html=True)
+        st.markdown("**Current Parameters:**")
+        st.write(f"• Initial Position: {initial_pos:.1f} m")
+        st.write(f"• Initial Velocity: {initial_vel:.1f} m/s")
+        st.write(f"• Acceleration: {acceleration:.1f} m/s²")
+        st.write(f"• Duration: {duration:.1f} s")
+        
+        # Calculate final values
+        final_pos = initial_pos + initial_vel * duration + 0.5 * acceleration * duration**2
+        final_vel = initial_vel + acceleration * duration
+        
+        st.markdown("**Final Values:**")
+        st.write(f"• Final Position: {final_pos:.1f} m")
+        st.write(f"• Final Velocity: {final_vel:.1f} m/s")
+        st.markdown('</div>', unsafe_allow_html=True)
+    
+    with col2:
+        # Create and display motion
+        motion = Motion1D(
+            initial_position=initial_pos,
+            initial_velocity=initial_vel,
+            acceleration=acceleration
+        )
+        
+        # Generate title based on motion type
+        if acceleration > 0:
+            motion_type = "Accelerating Motion"
+        elif acceleration < 0:
+            motion_type = "Decelerating Motion"
+        else:
+            motion_type = "Constant Velocity Motion"
+        
+        # Create and display Plotly chart
+        fig = create_1d_motion_plot_plotly(motion, duration, motion_type)
+        st.plotly_chart(fig, use_container_width=True)
 
 def show_2d_motion():
     st.markdown('<div class="section-header">🎯 Two-Dimensional Projectile Motion</div>', unsafe_allow_html=True)
@@ -566,246 +552,66 @@ def show_2d_motion():
                     del st.session_state[key]
             st.rerun()
     
-        with col2:
-            # Create and display trajectory with model info
-            model_info = f"({'Sphere' if is_sphere else 'Point Mass'})"
-            air_info = " (with Air Resistance)" if air_resistance_enabled else " (No Air Resistance)"
-            trajectory_title = f"Projectile Motion - {launch_angle:.0f}° Launch {model_info}{air_info}"
-            
-            # Create unique cache function for 2D motion ONLY
-            @st.cache_data(show_spinner=False)
-            def create_2d_motion_plot_unique(tab_id, launch_speed, launch_angle, launch_height, gravity, air_resistance_enabled, drag_coeff, is_sphere, sphere_radius, sphere_density, sphere_drag_coeff):
-                """Tab-specific 2D motion plot - includes tab_id to prevent cross-contamination"""
-                motion = Motion2D(
-                    launch_speed=launch_speed,
-                    launch_angle=launch_angle,
-                    launch_height=launch_height,
-                    gravity=gravity,
-                    air_resistance=air_resistance_enabled,
-                    drag_coefficient=drag_coeff,
-                    is_sphere=is_sphere,
-                    sphere_radius=sphere_radius,
-                    sphere_density=sphere_density,
-                    sphere_drag_coeff=sphere_drag_coeff
-                )
-                
-                model_info = f"({'Sphere' if is_sphere else 'Point Mass'})"
-                air_info = " (with Air Resistance)" if air_resistance_enabled else " (No Air Resistance)"
-                trajectory_title = f"Projectile Motion - {launch_angle:.0f}° Launch {model_info}{air_info}"
-                
-                return create_2d_trajectory_plot(motion, trajectory_title)
-            
-            # Create and display main trajectory plot with tab-specific cache
-            fig = create_2d_motion_plot_unique(
-                "2d_tab", launch_speed, launch_angle, launch_height, gravity, 
-                air_resistance_enabled, drag_coeff, is_sphere, sphere_radius, 
-                sphere_density, sphere_drag_coeff
-            )
-            st.plotly_chart(fig, use_container_width=True, key="2d_motion_plot_unique")
+    with col2:
+        # Create and display trajectory with model info
+        model_info = f"({'Sphere' if is_sphere else 'Point Mass'})"
+        air_info = " (with Air Resistance)" if air_resistance_enabled else " (No Air Resistance)"
+        trajectory_title = f"Projectile Motion - {launch_angle:.0f}° Launch {model_info}{air_info}"
+        
+        # Create and display main trajectory plot
+        fig = create_2d_trajectory_plot_plotly(motion, trajectory_title)
+        st.plotly_chart(fig, use_container_width=True)
+        
+        # Show model comparison if using sphere
+        if is_sphere and 'mass_g' in info:
+            st.markdown("### 📊 Sphere vs Point Mass Comparison")
             
-            # Show model comparison if using sphere
-            if is_sphere and 'mass_g' in info:
-                st.markdown("### 📊 Sphere vs Point Mass Comparison")
-                
-                @st.cache_data(show_spinner=False)
-                def create_2d_comparison_plot_unique(tab_id, launch_speed, launch_angle, launch_height, gravity, air_resistance_enabled, drag_coeff, sphere_radius, sphere_density, sphere_drag_coeff, mass_g):
-                    """Tab-specific 2D comparison plot"""
-                    # Create comparison plot
-                    fig_comp = go.Figure()
-                    
-                    # Plot sphere model
-                    motion_sphere = Motion2D(
-                        launch_speed=launch_speed, launch_angle=launch_angle, 
-                        launch_height=launch_height, gravity=gravity, 
-                        air_resistance=air_resistance_enabled, drag_coefficient=drag_coeff,
-                        is_sphere=True, sphere_radius=sphere_radius,
-                        sphere_density=sphere_density, sphere_drag_coeff=sphere_drag_coeff
-                    )
-                    data_sphere = motion_sphere.trajectory_data(motion_sphere.calculate_flight_time())
-                    fig_comp.add_trace(go.Scatter(
-                        x=data_sphere['x'], 
-                        y=data_sphere['y'],
-                        mode='lines',
-                        name=f'Sphere Model ({mass_g:.0f}g)',
-                        line=dict(color='red', width=3),
-                        hovertemplate='<b>Sphere</b><br>X: %{x:.1f} m<br>Y: %{y:.1f} m<extra></extra>'
-                    ))
-                    
-                    # Plot equivalent point mass
-                    motion_point = Motion2D(
-                        launch_speed=launch_speed, launch_angle=launch_angle, 
-                        launch_height=launch_height, gravity=gravity, 
-                        air_resistance=air_resistance_enabled, drag_coefficient=drag_coeff,
-                        is_sphere=False
-                    )
-                    data_point = motion_point.trajectory_data(motion_point.calculate_flight_time())
-                    fig_comp.add_trace(go.Scatter(
-                        x=data_point['x'], 
-                        y=data_point['y'],
-                        mode='lines',
-                        name='Point Mass Model',
-                        line=dict(color='blue', width=2, dash='dash'),
-                        hovertemplate='<b>Point Mass</b><br>X: %{x:.1f} m<br>Y: %{y:.1f} m<extra></extra>'
-                    ))
-                    
-                    # Update layout for comparison plot
-                    fig_comp.update_layout(
-                        title="Sphere Model vs Point Mass Model",
-                        xaxis_title="Horizontal Position (m)",
-                        yaxis_title="Vertical Position (m)",
-                        showlegend=True,
-                        template='plotly_white',
-                        height=400
-                    )
-                    
-                    fig_comp.update_yaxes(range=[0, None])
-                    fig_comp.update_xaxes(showgrid=True, gridwidth=1, gridcolor='rgba(128,128,128,0.3)')
-                    fig_comp.update_yaxes(showgrid=True, gridwidth=1, gridcolor='rgba(128,128,128,0.3)')
-                    
-                    return fig_comp
-                
-                fig_comp = create_2d_comparison_plot_unique(
-                    "2d_comparison", launch_speed, launch_angle, launch_height, gravity,
-                    air_resistance_enabled, drag_coeff, sphere_radius, sphere_density, 
-                    sphere_drag_coeff, info['mass_g']
-                )
-                st.plotly_chart(fig_comp, use_container_width=True, key="2d_comparison_plot_unique")
-
-
-def show_motion_comparison():
-    st.markdown('<div class="section-header">📊 Compare Different Trajectories</div>', unsafe_allow_html=True)
-    
-    st.markdown("**Compare up to 3 different projectile motions side by side**")
-    
-    # Use container with unique identification for comparison section
-    with st.container(key="comparison_container"):
-        # Use columns instead of tabs to avoid tab-related flickering
-        col1, col2, col3 = st.columns(3)
-        
-        with col1:
-            st.subheader("🚀 Trajectory 1")
-            speed1 = st.slider("Speed 1", 5.0, 50.0, 20.0, key="comp_speed1")
-            angle1 = st.slider("Angle 1", 0.0, 90.0, 30.0, key="comp_angle1") 
-            height1 = st.slider("Height 1", 0.0, 30.0, 0.0, key="comp_height1")
-        
-        with col2:
-            st.subheader("🎯 Trajectory 2")
-            speed2 = st.slider("Speed 2", 5.0, 50.0, 25.0, key="comp_speed2")
-            angle2 = st.slider("Angle 2", 0.0, 90.0, 45.0, key="comp_angle2")
-            height2 = st.slider("Height 2", 0.0, 30.0, 0.0, key="comp_height2")
-        
-        with col3:
-            st.subheader("⚽ Trajectory 3")
-            speed3 = st.slider("Speed 3", 5.0, 50.0, 30.0, key="comp_speed3")
-            angle3 = st.slider("Angle 3", 0.0, 90.0, 60.0, key="comp_angle3")
-            height3 = st.slider("Height 3", 0.0, 30.0, 5.0, key="comp_height3")
-    
-    # Single plot and table section
-    st.markdown("---")
-    
-    # Create UNIQUE comparison plot function that can't conflict with 2D motion
-    @st.cache_data(show_spinner=False)
-    def create_trajectory_comparison_plot_unique(tab_id, speed1, angle1, height1, speed2, angle2, height2, speed3, angle3, height3):
-        """UNIQUE comparison plot function - completely separate from 2D motion"""
-        trajectories_data = [
-            ("Trajectory 1", Motion2D(launch_speed=speed1, launch_angle=angle1, launch_height=height1), "blue"),
-            ("Trajectory 2", Motion2D(launch_speed=speed2, launch_angle=angle2, launch_height=height2), "red"),
-            ("Trajectory 3", Motion2D(launch_speed=speed3, launch_angle=angle3, launch_height=height3), "green")
-        ]
-        
-        fig = go.Figure()
-        
-        for name, motion, color in trajectories_data:
-            data = motion.trajectory_data(motion.calculate_flight_time())
+            # Create comparison plot using Plotly
+            fig_comp = go.Figure()
             
-            # Add trajectory line
-            fig.add_trace(go.Scatter(
-                x=data['x'], 
-                y=data['y'],
+            # Plot sphere model
+            data_sphere = motion.trajectory_data(motion.calculate_flight_time())
+            fig_comp.add_trace(go.Scatter(
+                x=data_sphere['x'], 
+                y=data_sphere['y'],
                 mode='lines',
-                name=name,
-                line=dict(color=color, width=3),
-                hovertemplate=f'<b>{name}</b><br>X: %{{x:.1f}} m<br>Y: %{{y:.1f}} m<extra></extra>'
+                name=f'Sphere Model ({info["mass_g"]:.0f}g)',
+                line=dict(color='red', width=3),
+                hovertemplate='<b>Sphere</b><br>X: %{x:.1f} m<br>Y: %{y:.1f} m<extra></extra>'
             ))
             
-            # Add launch point
-            fig.add_trace(go.Scatter(
-                x=[motion.launch_x],
-                y=[motion.launch_height],
-                mode='markers',
-                name=f'{name} Launch',
-                marker=dict(color=color, size=10, symbol='circle'),
-                showlegend=False,
-                hovertemplate=f'<b>{name} Launch</b><br>X: %{{x:.1f}} m<br>Y: %{{y:.1f}} m<extra></extra>'
+            # Plot equivalent point mass
+            motion_point = Motion2D(
+                launch_speed=launch_speed, launch_angle=launch_angle, 
+                launch_height=launch_height, gravity=gravity, 
+                air_resistance=air_resistance_enabled, drag_coefficient=drag_coeff,
+                is_sphere=False
+            )
+            data_point = motion_point.trajectory_data(motion_point.calculate_flight_time())
+            fig_comp.add_trace(go.Scatter(
+                x=data_point['x'], 
+                y=data_point['y'],
+                mode='lines',
+                name='Point Mass Model',
+                line=dict(color='blue', width=2, dash='dash'),
+                hovertemplate='<b>Point Mass</b><br>X: %{x:.1f} m<br>Y: %{y:.1f} m<extra></extra>'
             ))
             
-            # Add landing point
-            if len(data['x']) > 0:
-                fig.add_trace(go.Scatter(
-                    x=[data['x'][-1]],
-                    y=[data['y'][-1]],
-                    mode='markers',
-                    name=f'{name} Landing',
-                    marker=dict(color=color, size=10, symbol='square'),
-                    showlegend=False,
-                    hovertemplate=f'<b>{name} Landing</b><br>X: %{{x:.1f}} m<br>Y: %{{y:.1f}} m<extra></extra>'
-                ))
-        
-        # Update layout
-        fig.update_layout(
-            title=dict(text="Multi-Trajectory Comparison", font=dict(size=18, color="black")),
-            xaxis_title="Horizontal Position (m)",
-            yaxis_title="Vertical Position (m)",
-            showlegend=True,
-            hovermode='closest',
-            template='plotly_white',
-            height=600,
-            margin=dict(l=50, r=50, t=80, b=50)
-        )
-        
-        # Set axis ranges
-        fig.update_xaxes(range=[0, None])
-        fig.update_yaxes(range=[0, None])
-        
-        # Add grid
-        fig.update_xaxes(showgrid=True, gridwidth=1, gridcolor='rgba(128,128,128,0.3)')
-        fig.update_yaxes(showgrid=True, gridwidth=1, gridcolor='rgba(128,128,128,0.3)')
-        
-        return fig
-    
-    # Create cached comparison data with unique function name
-    @st.cache_data(show_spinner=False)
-    def create_trajectory_comparison_data_unique(tab_id, speed1, angle1, height1, speed2, angle2, height2, speed3, angle3, height3):
-        """UNIQUE comparison data function"""
-        trajectories_data = [
-            ("Trajectory 1", Motion2D(launch_speed=speed1, launch_angle=angle1, launch_height=height1)),
-            ("Trajectory 2", Motion2D(launch_speed=speed2, launch_angle=angle2, launch_height=height2)),
-            ("Trajectory 3", Motion2D(launch_speed=speed3, launch_angle=angle3, launch_height=height3))
-        ]
-        
-        comparison_data = []
-        for name, motion in trajectories_data:
-            info = motion.get_launch_info()
-            comparison_data.append({
-                "Trajectory": name,
-                "Speed (m/s)": f"{info['launch_speed']:.1f}",
-                "Angle (°)": f"{info['launch_angle']:.1f}",
-                "Height (m)": f"{info['launch_height']:.1f}",
-                "Flight Time (s)": f"{info['flight_time']:.2f}",
-                "Range (m)": f"{info['range']:.1f}",
-                "Max Height (m)": f"{info['max_height']:.1f}"
-            })
-        
-        return comparison_data
-    
-    # Display Plotly chart with completely unique identifiers
-    fig = create_trajectory_comparison_plot_unique("comparison_tab", speed1, angle1, height1, speed2, angle2, height2, speed3, angle3, height3)
-    st.plotly_chart(fig, use_container_width=True, key="trajectory_comparison_plot_unique")
-    
-    # Display comparison table
-    st.markdown("### 📋 Trajectory Comparison Table")
-    comparison_data = create_trajectory_comparison_data_unique("comparison_tab", speed1, angle1, height1, speed2, angle2, height2, speed3, angle3, height3)
-    st.table(comparison_data)
+            # Update layout for comparison plot
+            fig_comp.update_layout(
+                title="Sphere Model vs Point Mass Model",
+                xaxis_title="Horizontal Position (m)",
+                yaxis_title="Vertical Position (m)",
+                showlegend=True,
+                template='plotly_white',
+                height=400
+            )
+            
+            fig_comp.update_yaxes(range=[0, None])
+            fig_comp.update_xaxes(showgrid=True, gridwidth=1, gridcolor='rgba(128,128,128,0.3)')
+            fig_comp.update_yaxes(showgrid=True, gridwidth=1, gridcolor='rgba(128,128,128,0.3)')
+            
+            st.plotly_chart(fig_comp, use_container_width=True)
 
 if __name__ == "__main__":
     main()