Spaces:
Sleeping
Sleeping
| import streamlit as st | |
| import matplotlib.pyplot as plt | |
| from vector_physics import Vector2D, VectorPhysicsSimulator, plot_vectors, plot_trajectory, UnitConverter, QuizGenerator | |
| # Configure Streamlit | |
| st.set_page_config(page_title="Vector Physics Tutorial", layout="wide") | |
| # Initialize simulator and quiz generator | |
| simulator = VectorPhysicsSimulator() | |
| quiz_gen = QuizGenerator() | |
| converter = UnitConverter() | |
| # Initialize session state | |
| if 'quiz_question' not in st.session_state: | |
| st.session_state.quiz_question = None | |
| if 'quiz_answer' not in st.session_state: | |
| st.session_state.quiz_answer = None | |
| if 'quiz_submitted' not in st.session_state: | |
| st.session_state.quiz_submitted = False | |
| if 'show_explanation' not in st.session_state: | |
| st.session_state.show_explanation = False | |
| # Title and introduction | |
| st.title("🚢 Vector Physics Interactive Tutorial") | |
| st.markdown(""" | |
| Welcome to the Vector Physics Tutorial! Vectors are quantities that have both magnitude and direction. | |
| Use the controls below to explore different vector scenarios and see how they behave in real-time. | |
| """) | |
| # Sidebar for navigation | |
| st.sidebar.title("Select Physics Problem") | |
| problem_type = st.sidebar.selectbox( | |
| "Choose a problem type:", | |
| ["Boat Crossing", "Projectile Motion", "Vector Addition", "Quiz Mode"] | |
| ) | |
| # Unit selection | |
| st.sidebar.markdown("---") | |
| st.sidebar.subheader("🔧 Unit Settings") | |
| speed_unit = st.sidebar.selectbox("Speed Units:", list(converter.speed_conversions().keys())) | |
| distance_unit = st.sidebar.selectbox("Distance Units:", list(converter.distance_conversions().keys())) | |
| # Reset button | |
| if st.sidebar.button("🔄 Reset to Defaults", help="Reset all controls to default values"): | |
| st.rerun() | |
| if problem_type == "Boat Crossing": | |
| st.header("🚢 Boat Crossing a River") | |
| st.markdown(""" | |
| A boat is trying to cross a river with a current. The boat has its own velocity, | |
| and the river current affects the boat's actual path. | |
| """) | |
| col1, col2 = st.columns([1, 2]) | |
| with col1: | |
| st.subheader("Controls") | |
| # Convert default values to selected units | |
| default_boat_speed = converter.convert_speed(5.0, "m/s", speed_unit) | |
| default_current_speed = converter.convert_speed(3.0, "m/s", speed_unit) | |
| boat_speed_input = st.slider(f"Boat Speed ({speed_unit})", 0.1, | |
| converter.convert_speed(10.0, "m/s", speed_unit), | |
| default_boat_speed, 0.1) | |
| boat_angle = st.slider("Boat Direction (degrees)", -90, 90, 45, 1) | |
| current_speed_input = st.slider(f"Current Speed ({speed_unit})", 0.0, | |
| converter.convert_speed(8.0, "m/s", speed_unit), | |
| default_current_speed, 0.1) | |
| current_angle = st.slider("Current Direction (degrees)", -180, 180, 180, 1) | |
| # Convert back to m/s for calculations | |
| boat_speed = converter.convert_speed(boat_speed_input, speed_unit, "m/s") | |
| current_speed = converter.convert_speed(current_speed_input, speed_unit, "m/s") | |
| # Calculate results | |
| results = simulator.boat_crossing_problem(boat_speed, boat_angle, current_speed, current_angle) | |
| st.subheader("Results") | |
| st.write(f"**Boat Velocity:** {converter.convert_speed(results['boat_velocity'].magnitude, 'm/s', speed_unit):.2f} {speed_unit} at {results['boat_velocity'].angle:.1f}°") | |
| st.write(f"**Current Velocity:** {converter.convert_speed(results['current_velocity'].magnitude, 'm/s', speed_unit):.2f} {speed_unit} at {results['current_velocity'].angle:.1f}°") | |
| st.write(f"**Resultant Velocity:** {converter.convert_speed(results['resultant_velocity'].magnitude, 'm/s', speed_unit):.2f} {speed_unit} at {results['resultant_velocity'].angle:.1f}°") | |
| # Show heading difference | |
| st.markdown("---") | |
| st.subheader("📐 Navigation Analysis") | |
| st.write(f"**Heading Difference:** {results['heading_difference']:.1f}°") | |
| if results['heading_difference'] > 10: | |
| st.warning(f"⚠️ The boat's actual path deviates {results['heading_difference']:.1f}° from intended direction!") | |
| else: | |
| st.success("✅ The boat is following close to its intended path.") | |
| with col2: | |
| # Create plots | |
| fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 5)) | |
| # Vector diagram | |
| vectors = [results['boat_velocity'], results['current_velocity'], results['resultant_velocity']] | |
| labels = ['Boat Velocity (intended)', 'Current Velocity', 'Resultant Velocity (actual)'] | |
| colors = ['blue', 'red', 'green'] | |
| plot_vectors(ax1, vectors, labels, colors) | |
| ax1.set_title("Vector Diagram") | |
| # Trajectory plot | |
| traj_x_converted = [converter.convert_distance(x, "meters", distance_unit) for x in results['trajectory_x'][:50]] | |
| traj_y_converted = [converter.convert_distance(y, "meters", distance_unit) for y in results['trajectory_y'][:50]] | |
| plot_trajectory(ax2, traj_x_converted, traj_y_converted, f"Boat Path ({distance_unit})") | |
| ax2.set_xlabel(f'X Position ({distance_unit})') | |
| ax2.set_ylabel(f'Y Position ({distance_unit})') | |
| st.pyplot(fig) | |
| elif problem_type == "Projectile Motion": | |
| st.header("🎯 Projectile Motion") | |
| st.markdown(""" | |
| A projectile is launched at an angle. Gravity acts downward while the horizontal | |
| component of velocity remains constant. **Error analysis** shows how measurement | |
| uncertainty affects the results. | |
| """) | |
| col1, col2 = st.columns([1, 2]) | |
| with col1: | |
| st.subheader("Controls") | |
| default_speed = converter.convert_speed(20.0, "m/s", speed_unit) | |
| initial_speed_input = st.slider(f"Initial Speed ({speed_unit})", 1.0, | |
| converter.convert_speed(50.0, "m/s", speed_unit), | |
| default_speed, 1.0) | |
| launch_angle = st.slider("Launch Angle (degrees)", 0, 90, 45, 1) | |
| gravity = st.slider("Gravity (m/s²)", 1.0, 15.0, 9.81, 0.1) | |
| show_error = st.checkbox("Show Error Analysis", value=True, help="Shows uncertainty range from measurement errors") | |
| # Convert to m/s for calculations | |
| initial_speed = converter.convert_speed(initial_speed_input, speed_unit, "m/s") | |
| # Calculate results | |
| results = simulator.projectile_motion(initial_speed, launch_angle, gravity) | |
| st.subheader("Results") | |
| st.write(f"**Initial Velocity:** {converter.convert_speed(results['initial_velocity'].magnitude, 'm/s', speed_unit):.2f} {speed_unit} at {results['initial_velocity'].angle:.1f}°") | |
| st.write(f"**Max Range:** {converter.convert_distance(results['max_range'], 'meters', distance_unit):.2f} {distance_unit}") | |
| st.write(f"**Max Height:** {converter.convert_distance(results['max_height'], 'meters', distance_unit):.2f} {distance_unit}") | |
| st.write(f"**Flight Time:** {results['time_points'][-1]:.2f} s") | |
| if show_error: | |
| st.markdown("---") | |
| st.subheader("📊 Uncertainty Analysis") | |
| st.write(f"**Speed Uncertainty:** ±{converter.convert_speed(results['speed_uncertainty'], 'm/s', speed_unit):.2f} {speed_unit}") | |
| st.write(f"**Angle Uncertainty:** ±{results['angle_uncertainty']:.1f}°") | |
| st.info("💡 Small measurement errors can lead to significant differences in trajectory!") | |
| with col2: | |
| # Create plots | |
| fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 5)) | |
| # Vector diagram | |
| initial_vel = results['initial_velocity'] | |
| velocity_x = Vector2D(initial_vel.x, 0) | |
| velocity_y = Vector2D(0, initial_vel.y) | |
| vectors = [velocity_x, velocity_y, initial_vel] | |
| labels = ['Horizontal Component', 'Vertical Component', 'Initial Velocity'] | |
| colors = ['blue', 'red', 'green'] | |
| plot_vectors(ax1, vectors, labels, colors) | |
| ax1.set_title("Velocity Components") | |
| # Trajectory plot with error analysis | |
| traj_x = [converter.convert_distance(x, "meters", distance_unit) for x in results['trajectory_x']] | |
| traj_y = [converter.convert_distance(y, "meters", distance_unit) for y in results['trajectory_y']] | |
| error_bounds = None | |
| if show_error: | |
| error_bounds = { | |
| 'upper_x': [converter.convert_distance(x, "meters", distance_unit) for x in results['error_upper_x']], | |
| 'upper_y': [converter.convert_distance(y, "meters", distance_unit) for y in results['error_upper_y']], | |
| 'lower_x': [converter.convert_distance(x, "meters", distance_unit) for x in results['error_lower_x']], | |
| 'lower_y': [converter.convert_distance(y, "meters", distance_unit) for y in results['error_lower_y']] | |
| } | |
| plot_trajectory(ax2, traj_x, traj_y, f"Projectile Path ({distance_unit})", error_bounds) | |
| ax2.set_xlabel(f'X Position ({distance_unit})') | |
| ax2.set_ylabel(f'Y Position ({distance_unit})') | |
| st.pyplot(fig) | |
| elif problem_type == "Vector Addition": | |
| st.header("➕ Vector Addition Practice") | |
| st.markdown(""" | |
| Practice adding vectors by adjusting their magnitudes and directions. | |
| See how different combinations create different resultant vectors. | |
| """) | |
| col1, col2 = st.columns([1, 2]) | |
| with col1: | |
| st.subheader("Vector A") | |
| default_mag_a = converter.convert_speed(5.0, "m/s", speed_unit) | |
| mag_a_input = st.slider(f"Magnitude A ({speed_unit})", 0.1, | |
| converter.convert_speed(10.0, "m/s", speed_unit), | |
| default_mag_a, 0.1, key="mag_a") | |
| angle_a = st.slider("Angle A (degrees)", -180, 180, 30, 1, key="angle_a") | |
| st.subheader("Vector B") | |
| default_mag_b = converter.convert_speed(3.0, "m/s", speed_unit) | |
| mag_b_input = st.slider(f"Magnitude B ({speed_unit})", 0.1, | |
| converter.convert_speed(10.0, "m/s", speed_unit), | |
| default_mag_b, 0.1, key="mag_b") | |
| angle_b = st.slider("Angle B (degrees)", -180, 180, 120, 1, key="angle_b") | |
| # Convert to m/s for calculations | |
| mag_a = converter.convert_speed(mag_a_input, speed_unit, "m/s") | |
| mag_b = converter.convert_speed(mag_b_input, speed_unit, "m/s") | |
| # Create vectors | |
| vector_a = Vector2D(magnitude=mag_a, angle=angle_a) | |
| vector_b = Vector2D(magnitude=mag_b, angle=angle_b) | |
| resultant = vector_a + vector_b | |
| st.subheader("Results") | |
| st.write(f"**Vector A:** {converter.convert_speed(vector_a.magnitude, 'm/s', speed_unit):.2f} {speed_unit} at {vector_a.angle:.1f}°") | |
| st.write(f"**Vector B:** {converter.convert_speed(vector_b.magnitude, 'm/s', speed_unit):.2f} {speed_unit} at {vector_b.angle:.1f}°") | |
| st.write(f"**Resultant:** {converter.convert_speed(resultant.magnitude, 'm/s', speed_unit):.2f} {speed_unit} at {resultant.angle:.1f}°") | |
| st.write(f"**Dot Product A·B:** {vector_a.dot_product(vector_b):.2f}") | |
| st.write(f"**Angle Between Vectors:** {vector_a.angle_between(vector_b):.1f}°") | |
| with col2: | |
| fig, ax = plt.subplots(figsize=(8, 8)) | |
| vectors = [vector_a, vector_b, resultant] | |
| labels = ['Vector A', 'Vector B', 'Resultant A+B'] | |
| colors = ['blue', 'red', 'green'] | |
| plot_vectors(ax, vectors, labels, colors) | |
| ax.set_title("Vector Addition") | |
| st.pyplot(fig) | |
| elif problem_type == "Quiz Mode": | |
| st.header("🎓 Vector Physics Quiz") | |
| st.markdown(""" | |
| Test your understanding of vector concepts! Click 'New Question' to get a random problem. | |
| """) | |
| col1, col2, col3 = st.columns([1, 1, 1]) | |
| with col1: | |
| if st.button("📝 New Question", type="primary"): | |
| st.session_state.quiz_question = quiz_gen.generate_question() | |
| st.session_state.quiz_answer = None | |
| st.session_state.quiz_submitted = False | |
| st.session_state.show_explanation = False | |
| with col2: | |
| if st.button("💡 Show Explanation") and st.session_state.quiz_question: | |
| st.session_state.show_explanation = True | |
| with col3: | |
| if st.button("🔄 Reset Quiz"): | |
| st.session_state.quiz_question = None | |
| st.session_state.quiz_answer = None | |
| st.session_state.quiz_submitted = False | |
| st.session_state.show_explanation = False | |
| if st.session_state.quiz_question: | |
| question = st.session_state.quiz_question | |
| st.markdown("---") | |
| st.subheader("Question:") | |
| st.write(question["question"]) | |
| # Answer input | |
| user_answer = st.number_input("Your answer:", value=0.0, format="%.2f", key="quiz_input") | |
| if st.button("Submit Answer"): | |
| st.session_state.quiz_answer = user_answer | |
| st.session_state.quiz_submitted = True | |
| # Check answer | |
| if st.session_state.quiz_submitted and st.session_state.quiz_answer is not None: | |
| correct_answer = question["answer"] | |
| tolerance = question["tolerance"] | |
| if abs(st.session_state.quiz_answer - correct_answer) <= tolerance: | |
| st.success(f"✅ Correct! The answer is {correct_answer:.2f}") | |
| st.balloons() | |
| else: | |
| st.error(f"❌ Not quite right. The correct answer is {correct_answer:.2f}") | |
| st.write(f"Your answer: {st.session_state.quiz_answer:.2f}") | |
| # Show explanation | |
| if st.session_state.show_explanation: | |
| st.markdown("---") | |
| st.subheader("💡 Explanation:") | |
| st.write(question["explanation"]) | |
| else: | |
| st.info("Click 'New Question' to start the quiz!") | |
| # Educational notes | |
| st.sidebar.markdown("---") | |
| st.sidebar.markdown("### 📚 Key Concepts") | |
| st.sidebar.markdown(""" | |
| - **Magnitude**: Length of the vector | |
| - **Direction**: Angle the vector makes | |
| - **Components**: x and y parts of vector | |
| - **Addition**: Tip-to-tail method | |
| - **Resultant**: Sum of multiple vectors | |
| """) | |
| st.sidebar.markdown("### 💡 Try This") | |
| st.sidebar.markdown(""" | |
| 1. Set boat angle to 90° to go straight across | |
| 2. Increase current speed and watch the path change | |
| 3. Try launch angles of 45° for maximum range | |
| 4. Make two vectors perpendicular (90° apart) | |
| 5. Test the quiz mode to check your understanding | |
| 6. Change units to see the same physics in different measurements | |
| """) | |
| st.sidebar.markdown("### ⚙️ Features") | |
| st.sidebar.markdown(""" | |
| - **Unit Conversion**: Change between m/s, km/h, mph, etc. | |
| - **Error Analysis**: See how measurement uncertainty affects results | |
| - **Quiz Mode**: Test your vector knowledge | |
| - **Reset Button**: Restore default values | |
| """) |