Tag Archives: computer simulation

Modeling A Physical Pendulum – Another Adventure in Coding Nature

Rotational Dynamics Are Difficult to Learn… and to Teach

One of the most difficult units for AP Physics students is rotational mechanics. It can also be one of the hardest to teach. With that said, I really like rotational mechanics, but I want my students to enjoy it more. I want them not be be bogged down in some of the more difficult theoretical aspects of the rotational motion. There are several reasons for this topic being challenging I think – the use of the polar coordinate system, the introduction to the concept of a distribution of mass as opposed to just thinking about objects as point particles, the cross product of vectors producing a result pointing in the Z axis…yikes, it can get pretty heavy.

As a teacher, it is also tricky to come up with good investigations that allow students the opportunity to explore rotational dynamics. They do exist, and some are really good, but I also think that many don’t exactly build a strong link between the conceptual and mathematical models. Rolling a ring and a disk and sphere down a ramp can be a great demonstration that things that roll certainly do not behave like blocks or carts moving down a ramp, but its hard for the students to explore further – to build a predictive model that is mathematically precise. The normal way of things is to jump into the math and reveal the underlying mechanics through fairly complex derivations.

Simulating The Angular Momentum Principle

This year I decided to turn to a computational approach. I wanted the students to computationally experiment and discover the fundamentals of rotational mechanics. In order to do this, we started from the Angular Momentum Principle. This is the approach used in the wonderful textbook Matter and Interactions:

Στ ·Δt = I·Δω

The idea here is simply that a torque acting on an object (that is free to rotate around a pivot point) for a specified amount of time is going to cause an object to experience a change in its rate of spinning – called its rotational velocity.

Simulating A Physical Pendulum

Having the students start with this principle, they could learn some interesting mechanics of rotating bodies by building a simulation of a physical pendulum. A simple pendulum is “simple” in that it represents a single point mass hanging on a massless string. A physical pendulum has physical dimension, and so the body has to be modeled as having a distribution of mass. This gets really tricky to analytically model – especially the time dependent functions describing its motion.

But with a computational approach students could easily apply the momentum principle frame by frame. The students in my class were able to create a simulation of a physical pendulum in just over one class period. The pendulum that they modeled was a bar with weights at either end. The weights had different masses so that the bar would swing.

https://tychos.org/scenarios/250

The students set about building their simulations in Tychos – a web based simulation builder. As the students coded the simulation, they were continuously engaged in discussions about the mechanics of the code and the mechanics of nature. I asked the students to change the masses, or change the length of the bar, or the mass of the bar. They would run their simulations and discover that something didn’t quite match what they thought should happen. Students would then look for errors in the code, or they would question their own assumptions about the physics involved.

When they finished their simulations, and they were confident that their simulations were working, I had the students then use the simulation to investigate the energy of the rotating system. After some discussions about the transference of energy from the gravitational field to the kinetic energy (rotational) of the bar and the weights, the students discovered that their simulations also seemed to model the conservation of energy.

We didn’t stop there though. We had to see if the simulation did indeed match reality. This is called deployment in the modeling pedagogy. Using a meter stick, some disks that I had made for an earlier investigation, and a Vernier rotational sensor, I constructed a real physical pendulum.

To test the simulation, students were asked to identify all the inputs that would need to be measured and then entered them into their simulations. The students then used the conservation of energy to calculate rotational speed of the bar when the bar was released from an angle of 60 degrees – with the heavier weight above the lighter weight.

The students calculated a final rotational velocity of 2.8 radians/second. We then ran our test and graphed the angle of the bar as well as the rotational velocity of the bar (see graphs below). They measured a rotational max velocity of about 2.6 radians/second. The students were pretty satisfied with this result.

omega_graph

angular velocity of the bar

theta_graph

angular position of the bar

I then had the students graph the results of their simulations, and it was quite satisfying to see that the simulations and the sensor readings were matching really well.

sim_phys_pendulum

graphs produced in Tychos

This led to some more interesting discussions around simulating axel friction and air resistance. We also discussed the shapes of the graphs and what might be going on with their mathematical structure. This was far more interesting than just having them read out of a textbook and then solve some problems on paper, and my guess is that the students gained an understanding of the physical mechanics by having to debug their own simulated mechanics. They were able to investigate errors in their own code, but by doing so, see how the position of the weights, and the masses and the angle changed the behavior of the simulation and the motion graphs. I think the students also really enjoyed this approach, and based on how they were talking about their simulations and the experiment, they demonstrated to me that they had grasped a deeper understanding of rotational mechanics.

 

Computational Deployment: Simulating A Rocket

The model rocket project has long been a favorite at the Academy. For the past fifteen years, students have designed, fabricated and then launched model rockets as the first project of the program. Over the years, I have tweaked the project several times, each time finding new ways to introduce authentic analysis in the process.

This year I have taken a deep dive into computational modeling, and as part of the rocket project, students were asked to create a simulation of their rocket prior to launch. In this post I will discuss how I did this, and how it turned out.

Simulating The Momentum Principle:

Prior to getting started on this, students investigated the causal relationship between forces and changes in motion. Using force sensors, carts, weights and elastic cords of different lengths, students began building a qualitative and quantitative model relating the momentum of a particle to the forces acting on the particle.

Screen Shot 2018-12-22 at 9.27.05 AM

In previous years, I waited to introduce momentum until after a significant amount of time was spent on forces, balanced and unbalanced. This year I decided to go directly to momentum. This is a bit of a break from the established modeling instruction sequence, but I think its a good alternative that is also suggested by the great textbook Matter and Interactions. The momentum principle can easily be modeled computationally and I think the students are able to grasp it conceptually.

I have included a link to a Google Doc that is the introductory activity that I created. My approach here, as it has been with this entire unit is to give the students guided questions that allow the students to discover and investigate the code required to simulate the momentum principle. This is my first attempt, and I am sure it will undergo many revisions:

Simulating The Momentum Principle

Introducing Conditional Behavior

One of the really great things about building a simulation of a rocket has three distinct phases of its trajectory – the thrust phase, the cruise phase and the descent phase. This gives the students three different phenomena to study and simulate: positive acceleration when two unbalanced forces are acting on the rocket during the thrust phase, free fall when the fuel runs out, and then constant velocity when the parachute has been deployed.

In order to simulate this, students needed a way to change the forces acting on the rocket at different time intervals. This is done using a conditional statement:

If This Then That

Conditional statements are very easy to create in Tychos – but they work a bit differently from other programming interfaces. Here is an example:

# The thrust force - F (thrust, rocket, fuel)
Ftrf = if (t < 1.8, [0, 6], [0, 0])

In this code snippet, a force is given a different value based on a condition, in this case whether the time in the simulation is less than 1.8 seconds. If it is, then the force is given a positive 6 value in the Y direction, and if the time is greater than 1.8 seconds, then the force becomes zero.

This allows the students to simulate the thrust phase of the rocket by having the thrust force disappear once the fuel has run out. We conducted tests on Estes C6-5 rocket engines in order to establish the time value. You can read more about how we did this here.

The students did the same thing to figure out when the parachute should deploy. Again this was established based on information from Estes as well as our own tests.

Comparing Simulation Data to Real Data

The students could analyze the simulated rocket behavior by using the graphing tools in Tychos. The students graphed the vertical velocity as well as the vertical position of their simulated rockets. Here is an example of what those graphs look like:

Screen Shot 2018-12-22 at 10.22.21 AM

The last step of the process was for the students to compare their simulated data to the real data that was captured by the altimeter that we use in the rocket’s payload. Below are two images of the graphs of the data they retrieved from the rocket’s altimeter:

rocket_v_graph

velocity data from altimeter – imported into LoggerPro

rocket_y_graph

altitude data from altimeter – imported into LoggerPro

The shapes of the graphs from the simulated data and the real data are very similar! That was certainly exciting to see that the simulations were at least giving results that qualitatively matched the real behavior of the rockets.

Two factors that certainly created significant discrepancies between the real rockets and the simulated rockets was the existence of air resistance on the real rocket, and the fact that the real rockets didn’t always go perfectly straight up! We plan on modifying the simulations, but that will have to wait for a future post.

Simulating Circular Motion: An Inquiry Approach

This semester I have been very busy working on a new approach to teaching Physics. This has actually been part of an effort that has spanned more than three years, but this year I have really embraced this change and I have much to share.

This post is a preview of many to come. I am going to write several posts documenting my efforts and experiences throughout the school year. Hopefully these posts will help me capture what I have learned in the process, and perhaps will be a guide for anyone else who might be interested.

Analytical Models Emerge From Computational Models

With the help and insights of others, I have been mapping out a new scope and sequence for teaching Physics that incorporates computational modeling as the primary method of modeling Physics. Rather than looking at computational modeling as an “add on”, I have been exploring the idea that analytical models are emergent. Computational models are more fundamental and analytical models emerge from those computational models.

The basic approach here has been to start with computational modeling, and then to allow the students to discover the analytical models that are revealed. This has been an exciting “unveiling” of physical patterns for the students. The other thing that I have witnessed is that students seem to intuit the principles of Calculus, even though my students are not at that level in mathematics training. More on this in a future post.

In future posts, I will report out on how this has been going and what I have learned in the process. For now, I simply want to share an example.

The Inquiry Lessons: Discovering Centripetal Acceleration

One of the aspects of this project has been to re-invent many of my lessons. I have been creating inquiry based lessons based on an approach known as POGIL. I am not POGIL trained, so I wouldn’t say my activities are actual POGIL activities – they are POGIL “inspired”.

In the first lesson, students learned how to simulate an object moving in a circular path. I have attempted to incorporate an inquiry approach where students are guided using questions, as opposed to holding their hands. This approach can be messy, but I have found it has always lead to great conversations, unanticipated insights from the students and it gives the students a sense of discovery.

I have included a link to the lesson which you are free to copy, modify, etc. without any restrictions.

Lesson 1: Simulating Spinning Motion

Keep in mind that my students had already learned how to code movement, so if you are new to computational modeling, I will soon be writing some posts that introduce students to this approach and to computational modeling in general.

In the second lesson, students simulated circular motion using angular quantities. They then explored how they could represent the tangential velocity and then they explored what the acceleration was. This led them to discover that the simulation revealed that the acceleration vector pointed to the center of the circle. Through some guided inquiry, they discovered a number of interesting details, such as the acceleration increased when the radius declined, and that the tangential speed had a significant affect on the acceleration.

Here is a link to the lesson:

Lesson 2: Circular Motion

I do use a tool, that I am actually partly developing with some friends as the simulation software, called Tychos, but you can modify the lesson to use any coding platform you like (of course I like Tychos, but I am a bit biased!)

Please feel free to comment here to give me feedback on the lessons if you feel inclined. I am certainly on a learning path myself, and I am sure there are many improvements that could be made!

Thanks in advance,

Steve.

 

Helping Students Create Their Own Mini Universes

For the past year, I have been helping a small software development team, headed up by my friend Winston Wolff, in the creation of a web based physics simulation tool. In this blog post, I am going to describe:

  • Why we started this effort,
  • What we hope to achieve,
  • How far we have currently progressed towards our goals,
  • And invite you to try it out.

Simulations Can Be Helpful…

Many Physics teachers use computer simulations as a tool to help students learn physics. With a click of the mouse and a few keystrokes, students can quickly change the inputs to the simulation, producing different simulated behaviors of the system. This allows for quick exploration of the relationship between certain “physical” inputs and the governing dynamics of the system. Often, these explorations would be impossible to set up in the lab, or might take significant time and effort.

projectile-motion-600

A great PHET simulation of projectile motion

…But They Have Limitations.

Although these tools can be used with a high degree of success in the classroom, the students are interacting with a virtual universe created by another human. The rules of behavior and the underlying quantitative relationships have been defined by someone else who has already done the difficult work to model the physical universe. These relationships can be inferred and they can be explored by the student, but ultimately, they are hidden behind an impenetrable wall of software code. There is also a certain faith that the student must have in the simulation – there must exist an acceptance that the simulation creators did their job correctly.

Students Coding Their Own Simulations is Awesome… 

Some highly regarded physics educators have introduced the practice of teaching computer programming in the physics classroom. The advantage of engaging students directly in the construction of simulations, according to Ruth Chabay and Bruce Sherwood

is that there are no “black boxes”: students write all of the computational statements to model the physical system and to visualize the abstract quantities.”

Additionally, they argue that having students gain some experience and exposure to computational modeling

in the form of programming, even at the introductory level, can be an important component of a general education for living in today’s world.

Giving students the opportunity to write their own simulations gives them the ability to engage in computational physics directly and to give them vital experience in one of the aspects of being a scientist – namely writing some code.

… But There Are Challenges For Teaching Coding.

Although there are great reasons for integrating computer science with Physics, and therefore developing students’ understanding and experience with computational Physics, there are some significant challenges for the teacher.

Teaching students to code their own physics simulations is not trivial. It requires significant instructional time, even given the fact that there are some amazing tools and frameworks for graphics programming (VPython, Processing). Chabay warns that time spent on teaching computer science principles and practices needs to be assessed against the time lost teaching and learning physics.

Due to the complexity and in many cases, the lack of exposure to computer science and “coding”, students can become lost in the syntax and specific computer science discourse, thus leading to confusion about the actual physics principles.  


phymod1

A Hybrid Solution Is Needed: Tychos

Tychos (tychos.org) attempts to address the strengths presented by simulations and combine it with the value of computational modeling. It is a simulation tool that has been built to address the lack of transparency inherent in pre-constructed simulations while also simplifying and accelerating the acquisition of the skills needed to “code” the underlying physics.

We have never seen Tychos as a replacement for laboratory experiments. Quite the opposite, we see this as a way to enhance the laboratory experience. It gives students the ability to quickly define a hypothesis in code for anticipated behavior of a real experiment. Students can then run the real experiment and see if the simulation behavior that they defined matches or does not match the behavior defined by nature.

No Black Boxes

The rules of the simulation are created and coded by the student. At its base, Tychos is really just a “drawing” and computational tool. There are no “virtual physics” built into the environment. Those rules must be defined and implemented by the student.

For example, if a student wants to simulate a particle moving in space with a constant velocity, they simply need to define the particle by using one of the few built in functions to place the particle at a position, set its visible size, and then optionally display with a given color, in this case the color red:

p = Particle([0,0], 10, "red")

The “particle” is really just a graphic “dot” that appears on the screen. The simulator has no concept of movement, or mass, or energy, etc. The student must build in those rules. So for example, the student defines a numerical matrix to represent the particle’s velocity:

p = Particle([0,0], 10, "red")
p.vel = [10, 0]

Then the student can use that variable to define how the particle will move in time. This is done by utilizing one of the few built in physical variables in the simulation software – “dt” which represents delta time:

p = Particle([0,0], 10, "red")
p.vel = [10, 0]
p.pos = p.pos + p.vel*dt

With these three lines of code, a student can simulate a particle moving in space with a constant velocity. The student makes that happen and therefore the mechanics of the behavior are not hidden but rather fully exposed for the student to define.

Built In Physics Analytical Tools

We have tried to create an environment where students have access to a suite of analytical tools that either do not require any coding, or very little.

Visual Representations

As we develop Tychos, we are constantly looking at how we can make the tool easier to use for students. A few features that we have included are important visual representations that are commonly used to help represent motion. For example, we have made it very simple for students to see motion maps of their particles by simply clicking a button. We have also made it very easy to display vector arrows for any vector quantity, and to attach those vectors to a given particle:

cvpm_canvas_6

This allows students to quickly assess the behavior of the simulation without needing to spend time learning how to implement complex tools.

Easily Adjust Simulation Parameters

We have also tried to remove any coding that isn’t specifically targeted at modeling physics. For example, Tychos has a simple set of simulation parameters that can be changed with a few simple controls:

settings

The above panel shows that a student can change the frame rate, the motion map strobe rate, set a simulation stop time, and change the extents of the viewing window – all without writing a line of code.

Coding of the GUI, rendering graphics, running the animation, etc are taken care of so there is less to program. The programs are much shorter and the code is more focused on the physics concepts, e.g calculating how force and momentum affect the position of a particle. There is no “boiler plate” code that needs to be used to get started which we have found to be cumbersome and confusing for students. Students spend less time learning programming and more time learning physics.

Graphing

One of the great features that we are excited about and that I have found incredibly useful in class is the built in graphing tools in Tychos. With two simple lines of code, a student can graph any variables on a simple to read graph.

This allows for the student to graph the position, velocity,  and acceleration of a particle as a function of time (called motion graphs) but they can also graph energy, momentum, force, or any virtual quantity defined in the simulation code.

In the following example, the student has defined the kinetic energy of a particle and then has defined and displayed a graph for how the energy is changing with respect to time:

KEgraph = Graph("KE vs Time")
KE = 0.5*p.mass*p.vel*p.vel
KEgraph.plot(t, KE)

The graph then looks like this:

graph

This graph appears just under the simulation window, and the student can then easily connect the behavior of the simulated particle to the behavior of the graph.

Integrated Formative Assessment:

Tychos has been built around the concept of a learning system. From the ground up, we have built in features that are designed to engage the student in the learning process. Tychos includes fast feedback in the form of instructor defined goals which are checked by the system such as “Your simulation should calculate position of particle at time 3 seconds.”

goals

These goals keep students on track and allows for students to self assess. We have also noticed how these goals make the learning exciting. Students have expressed how much they enjoy watching the goals turn green as they accomplish them.

Teachers can also use the Goals as a quick and easy way to assess the learning progress of the entire class, and then focus on individuals that are having trouble. The teacher has the ability to peer into the individual student’s work and we are even building into the application the ability to see a “code history” of each student so that the teacher can track down the origin of a learning challenge and then direct the student to a specific solution.

Our Roadmap

We think we are off to a great start with this app, but we also realize that there are a number of great potential features that we hope to add. This is a rough outline of our future goals:

Tracking Student Progress

Soon the tool will show each student’s progress in realtime to the instructor so the instructor can maximize their time helping the students who need it. The tool will also allow instructors to see the work each student does, e.g. each attempt the student has made, the difference from the last attempt, and its outcome to help the instructor quickly deduce where the student’s thinking is and what is blocking her. Additionally, the instructor will be able to automatically export assessment data based on instructor’s defined criteria.

Custom Defined Classes

We want to give the students the ability to define reusable components so that we can further reduce the amount of code that is needed to create a simulation. We are working on some strategies to build that into Tychos.

Data Export/Import

To extend the connection between Tychos experiments and in class laboratory experiments, we intend to add the ability to export and import data to and from other data collection software like Logger Pro. This will allow more precise comparisons between simulated behavior and measured behavior from motion detectors or force sensors.


Looking For Feedback

We are continuously looking for ways to improve our application, and we have no shortage of ideas. Our next challenge is finding the time and resources to make those future enhancements possible, but we are eager to have other Physics teachers try this tool out and let us know what else we should do to make this a better learning and teaching experience.

If you are interested in trying this application out, please visit our website: tychos.org. If you would like to give us feedback, or have questions, please feel free to post a comment on this blog post or contact me (stemple@srcs.org) or Winston (winston@nitidbit.com). We would love to hear from you!

 

Simulate, Test, Analyze: A Framework For Rigor

trebuchet-launch---08_23970235271_o

“Have Fun Storming The Castle!”

At the end of this fall semester, the second year students in the Academy rolled and carried their medieval mechanisms of mayhem to the SRHS track and we spent the afternoon watching the devices hurl lacrosse balls across the athletic field.This project was the final performance assessment of the semester and required that students design a gravitationally powered projectile launcher. This is an age old engineering/applied physics project.

Like many engineering projects done in high school, the physics principles governing the dynamics of the project are quite complicated, and ultimately the actual “application” of the science principles is often cursory. Students don’t have the background or mathematical abilities to to do the complex calculations needed to make an optimization adjustment to their mechanical device.This leads to the disconnection between the science content and engineering practice. Students don’t have the ability to make an informed decision about design choices. This is because it is difficult, very difficult.

Over the past few years I have been very interested in addressing this problem. This post discusses a framework that I have been working on to incorporate science into engineering projects. I think this framework allows high school students to engage in difficult scientific analysis without overwhelming them.

A Framework For Rigor

I won’t claim that this is a perfect solution, but so far I think we have experienced some success in creating a tighter relationship between science and engineering.  Last December I helped conduct a workshop at the NCCPA Professional Development Conference in Petaluma, CA. The name of the workshop was “NGSS, Prediction Reports and Your Science Class” and the point of this workshop was to give the attendees a framework for incorporating the Engineering standards into the science curriculum.  My co-presenter (Vipul Gupta) and I focused on the creation of prediction reports using computer simulations as a way to address two very important standards in the NGSS framework:

Using Simulations with Informed Input

Computer simulations are very popular in the educational space. They give teachers and students a virtual space where students can interact with virtual lab equipment or virtual objects that behave similarly to physical objects in the real world. With that said, they can fail to address students misconceptions because they do not always succeed in linking a conceptual model to the physical behavior. I also believe that the best simulations are ones that output data that can be analyzed with other scientific/mathematical tools. I also think that a good simulation requires that students provide meaningful input that gives them opportunities for analyzing the relationship between the input and the output.

Simulations used in engineering projects can be extremely helpful in addressing one of the main problems in engineering education. Students often design and build mechanical devices without understanding the physical principles that govern the design. The design process becomes an exercise in trial and error, or simply is reduced to copying a design from the internet.

To do a predictive analysis of a rocket’s flight, or a bridge’s structural performance is extremely difficult and often requires advanced mathematics and physics. Simulations can give the students the ability to analyze their designs and understand how changing the design inputs affects the output. Once again, it is important to find a simulation that requires students to understand the inputs and outputs.

Virtual Trebuchet

For example, in our project, students were introduced to an online Trebuchet simulation tool. This simulation tool is great because it requires that the student learn how to measure and calculate certain inputs. The students must have a working knowledge of rotational inertia, center of mass, and other concepts before they use the simulation. This was ideal for our project because it gave students a relevance and motivation . They had learn about these concepts in order to actually use the simulation. The students could then change certain inputs and see how that would change the efficiency of the design, or the range of the projectile. The point is that they needed physics knowledge in order to use the tool. They might not have the ability to know how the simulation eventually calculated the output, but they knew that the simulation required an understanding of the inputs.

IMG_2674

Example Report

The Prediction Report

The next step is to ask the students to prepare a prediction report. This report is designed to get students to demonstrate their understanding of the inputs, display evidence of the required calculations or measurements needed to create the inputs and then analyze the simulation outputs. In the report for this project, I asked students to show a set of calculations and measurements for determining the center of mass of their throwing arm and the rotational inertia (moment of inertia). Students also had to provide similar information for the counterweight.  The students then had to run the simulation and document the outputs from the simulation.

The Test:  Data is Needed

The next step is to test the device. To make this step more rigorous and to be able to relate the scientific analytical process to the engineering process, it is crucial for the students to collect data that can be used to analyze the performance of their device/product and then reflect on how they would improve their design.

For this project, we decided to use high-speed video and Vernier’s LoggerPro video analysis software to plot the position of the projectile as it was launched from the device.

The Analysis

The analysis is actually broken into two parts. The first part requires a collection of calculations while the second part uses those calculations to make some qualitative assessments.

For example, in the above project, students had to use the collected position data from the video analysis tool to calculate the kinetic energy of the projectile and then the efficiency of the device. They had to be proficient at the analytical tool, which in itself requires physics content knowledge, providing once again an opportunity to apply scientific models in the analysis portion of this engineering project.

I have included the instructions for the analysis report here: Projectile Launcher Analysis Report.

Finally, students are given the opportunity to use the information gathered in the analysis report to reflect on their design, and more importantly use the information to inform how they would improve on a future design. I have included below the set of questions that I asked my students:

  1. Compare the efficiency calculation of the simulation to the efficiency rating that you calculated for your actual performance. Please describe why you think these values are not the same.
  2. Consider the design of your trigger. What design and fabrication decisions would you change in order to improve your trigger, AND explain WHY you would make those changes.
  3.  Consider the design of your sling. What design and fabrication decisions would you change in order to improve your sling, AND explain WHY you would make those changes.
  4. Consider the design of your release mechanism (called the nose). What design and fabrication decisions would you change in order to improve this mechanism, AND explain WHY you would make those changes.
  5. Consider the design of your arm. What design and fabrication decisions would you change in order to improve your arm, AND explain WHY you would make those changes.
  6. Consider the design of all other components and the overall design. What design and fabrication decisions would you change in order to improve your device (other than the trigger, sling and arm), AND explain WHY you would make those changes.

Conclusion

The overall design of this framework can be boiled down to this:

  • Engage students in a computer simulation that simplifies the process of modeling and analyzing a complex physical/chemical/biological process, but be sure that the simulation requires some conceptual and computational thinking.
  • When testing the performance of the design (bridge, rocket, etc.) make sure that the students are required to  collect data that can be analyzed and that once again demands that they apply their theoretical models.
  • Design an assessment that uses the analysis and gives the students an opportunity to make informed judgements of their designs for the purpose of redesign.

Simulating Planetary Motion (Using Code!)

Simulating Newton’s Law of Universal Law of Gravity

Interactive simulations (like those created by the University of Colorado – PhET) can be really nice for impressing students, and giving them a way to explore the dynamics of a simulation. If incorporated into a lesson well, they can add to the active learning process. The question that I always struggle with though is “are the students learning how the simulation works, or are they learning how nature works?”

I have a nagging feeling that the students would possibly get more out of being able to see the simulation source code, specifically the rules of behavior of the simulation, and then through “tweaking” the code, see how those rules govern behavior. I would like to develop curriculum that would allow my students more opportunities to explore the code “behind” the simulations. This presents a few challenges that have been identified by other great physics educators, and if you are thinking about doing the same thing – I would suggest reviewing their insights. I include a quote from Ruth Chabay’s brief, but very interesting article on this topic:

To integrate computation, especially programming, into an introductory course, it is necessary to minimize the amount of non-physics related material that must be taught. To do so it is necessary to teach a minimal subset of programming constructs; employ an environment and language that are easy to learn and use; ensure that program constructs match key physics constructs; provide a structured set of scaffolded activities that introduce students to programming in the con- text of solving physics problems

This was my first attempt at doing just this, and I had some success and realized that I have some work to do.

Which Code?

A popular programming language in the Physics Modeling community is VPython. I have chosen to use a different language to use called Processing. There are reasons I chose this language, but I am sure there are reasons one would choose VPython (or other languages). At this point, I have not had the opportunity to work with VPython, so this post will not attempt to compare Processing to other languages. Perhaps I will do so in the future…

Here are some general reasons why I like Processing:

  1. It’s free and open source.
  2. Because its built on a visual programming interface, its really easy for the students to create visual content on the screen, and it is very easy to create visual animations due to the embedded “draw” loop.
  3. The official website has great examples and tutorials. It is full of great code samples and quick tutorials. You can loose yourself for hours (or days!) just having fun exploring the examples and tutorials.
  4. The IDE is simple and very similar to the Arduino IDE, so if you plan on doing any Arduino programming, the similarity is nice for the students.
  5. There is a nice vector library for doing vector operations (.add, .mult, .norm, .dot, etc.)
  6. Its object oriented so that you can have the added benefit of teaching important programming concepts – though this might be why some people might not like it.

The Simulation

The simulation that the students were introduced to was a simulation that modeled Newton’s Law of Universal Gravitation. The students were given some instructions on the basic structure of the program, and I made sure that there was some guiding comments embedded in the code. This program was inspired/adapted from a similar program created by Daniel Shiffman who has also written an amazing book on simulating nature through code called Nature of Code.

The program defines two classes. First, there is the parent class called Particle. This class defines some basic attributes like location, velocity and acceleration as well as mass. It also has some basic functions that allow it to move and allow it to respond to a force. The second class is the child class called Planet. It can do everything that a Particle can (because it inherits from the Particle class), but it can also exert an attractive force on other Planets.  Here is the code below:

/* A parent class for all moving particles
class Particle {
  PVector location;
  PVector velocity;
  PVector acceleration;
  float mass;

  Particle(float x, float y, float m) {
    mass = m;
    location = new PVector(x, y);
    velocity = new PVector(0, 0);
    acceleration = new PVector(0, 0);
  }
  
  void applyForce(PVector force) {
    // Newton’s second law at its simplest.
    PVector f = PVector.div(force,mass);
    acceleration.add(f);
  }

  void move() {
    velocity.add(acceleration);
    location.add(velocity);
    acceleration.mult(0);
  }
}

/** 
 This class defines an object that behaves like a planet.
 Planet objects extend Mover objects, so they can move. They
 also can attract other planet objects.
 **/
   
class Planet extends Particle {

  float size;
  float G = 1;

  // To create a planet, you need to supply coordinates, mass, and size
  Planet(float x, float y, float m, float s) {
    super(x, y, m);
    size = s;
  }

  // This function allows a planet to exert an attractive force on another planet.
  PVector attract(Planet p) {

    // We first have to figure out the direction of the force
    // This creates a unit vector for the direction
    PVector force = PVector.sub(this.location, p.location);
    float distance = force.mag();
    distance = constrain(distance,size + p.size,500);
    force.normalize();

    // This is where we use Newton's Law of Universal Gravitation!
    // The stength of the attraction force is proportional to the
    // product of the mass of this planet and the mass of the other planet
    // as well as the value of G. It is also inverseley proportional to
    // the distance squared.
    float strength = (G * mass * p.mass) / (distance * distance);
    
    // To get the final force vector, we need to 
    // multiply the unit vector by the scalar strength
    force.mult(strength);

    // Return the force so that it can be applied!
    return force;
  }
  
  // Just displays the planet as a circle (ellipse)
  void display() {
    stroke(255);
    fill(255, 100);
    ellipse(location.x, location.y, size/2, size/2);
  }
  
}


/** 
  This program simulates the gravitational interaction between planet objects
  **/
  
Planet planet1;
Planet planet2;

void setup() {
  background(0);
  size(800,800);
  // Inputs for each planet:
  // (x, y, mass, radius)
  planet1 = new Planet(width/2,height/4,6000,60);
  planet2 = new Planet(width/2,height/1.25,6000,60);
  
  // This is where you can change the initial velocities of the planets.
  planet1.velocity.x = 0;
  planet1.velocity.y = 0;
  planet2.velocity.x = 0;
  planet2.velocity.y = 0;
}

void draw() {
  background(0);
  
  // f1 is a force vector that is created by calling the planet's attract function
  PVector f1 = planet1.attract(planet2); 
  // Now apply that force on the other planet.
  planet2.applyForce(f1);
  // Now deal with the opposite force pair
  PVector f2 = PVector.mult(f1, -1);
  planet1.applyForce(f2);
  
  // Allow the planets to now move.
  planet1.move();
  planet2.move();
  
  // Display the planets
  planet1.display();
  planet2.display();
}

Experimenting With The Code

The students could change the initial values of the planets, such as the starting positions, the masses and radii by changing the input values of these two lines of code:

planet1 = new Planet(width/2,height/4,6000,60);
planet2 = new Planet(width/2,height/1.25,6000,60);

The planets initial velocities could also be modified by changing the values assigned in these four lines of code:

planet1.velocity.x = 0;
planet1.velocity.y = 0;
planet2.velocity.x = 0;
planet2.velocity.y = 0;

The code that actually guides the strength of the gravitational attraction between the two planets is actually very simple. This is the magnitude of the force as defined by Newton’s Law of Universal Gravity in code:

float strength = (G * mass * p.mass) / (distance * distance);

There is some slightly complicated code that controls the direction of the force and how that force is then applied to the planet object’s state of motion, but I didn’t have the time to explain this, which was a bit disappointing (see below).

For The Future

I am currently really interested in incorporating programming into the academy program, but have found myself a bit intimidated by the challenges identified by Ruth Chabay. The most significant challenge is time:

In an already full introductory physics curriculum, there is little or no time to teach major programming skills. Students who are new to programming are also new to the process of debugging; teaching debugging strategies requires even more time…Working on programming activities only once a week in a lab or recitation section may not be adequate to keep knowledge of syntax and program structure fresh in the students’ minds.

I plan on taking some time this summer to see how I could integrate computer programming more significantly into the curriculum without causing the learning of Physics to suffer – that would of course defeat the purpose!