Celestial Dancers

Edit (06/06/16): In light of the recent passing of Dr. Klug at UCLA, this project is a dedication to him, his amazing work as a teacher, and the family he talked about so frequently and loved so clearly. Dr. Klug taught me dynamics, engineering programming, and finite element analysis, all of which were utilized in this project and essential to my development as an engineer. I couldn’t have asked for a better professor, and my heart goes out to friends and family he leaves behind.

Celestial Dancers is an orbital mechanics simulation I made using React and A-Frame VR. The simulation is built for virtual reality browsers, so it’s best viewed with google cardboard and a smart phone. It still works on desktop, and with the keyboard you can fly through space and use your mouse to look around.

Screen Shot 2016-05-20 at 2.24.50 PM

I built the physics engine for this project entirely in JavaScript. The engine incorporates gravitational forces and collisions with custom React components, and updates itself with A-Frame’s component lifecycle events.

I maintained the interactions between each pair of bodies, adding new interactions as new bodies entered the scene. On every cycle, each interaction would calculate the distance between its two bodies, use Newton’s law of universal gravitation to calculate a gravity force, and use Hooke’s law to calculate a collision force. Roughly 10 times per second, the sum of the collision and gravity forces would update the acceleration, velocity, and finally position of each body.

I ran into an interesting technical challenge related to the update cycle of the simulation and the order of the force calculation and position update. When I first built the simulation, I iterated over each body to calculate its interaction with each other body, and then I would move it accordingly before beginning the calculations for the next body. My process looked like:

on each update cycle of the simulation
   for each body in the simulation
      calculate the forces due to all the other bodies in the simulation
      sum those forces
      update the current body's acceleration from that sum
      update the current body's velocity from that acceleration
      update the current body's position from that velocity
   end
end

I realized that because I updated the position of body A before calculating the forces on body B, the force from A to B would be slightly different than the force from B to A. This worked just fine when bodies were far apart, but if they got too close to one another, their interactions became erratic. Bodies would approach one another and then rapidly fly off into the distance.

To solve this problem, I rearranged the calculation and update steps so that all of the forces were calculated before any of the positions were updated:

on each update cycle of the simulation
   for each interaction in the simulation
      calculate the force between the interaction's two bodies
   end
   for each interaction in the simulation
      update the simulation's bodies' accelerations
      update the simulation's bodies' velocities from those accelerations
      update the simulation's bodies' positions from those velocities
   end
end

This update pattern solved the problem perfectly because all of the forces for a given update cycle were calculated using the same state.

Advertisements

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s