N-Bodies

N-Bodies preview image

1 collaborator

Uri_dolphin3 Uri Wilensky (Author)
Add Collaborator

Close

Tags

chemistry and physics 

Tagged by Reuven M. Lerner over 11 years ago

mechanics 

Tagged by Reuven M. Lerner over 11 years ago

Add New Tag

Close

Model group CCL | Visible to everyone | Changeable by group members (CCL)
Model was written in NetLogo 5.0.4 • Viewed 451 times • Downloaded 77 times • Run 1 time
Download the 'N-Bodies' modelDownload this model • Embed this model

Do you have questions or comments about this model? Ask them here! (You'll first need to log in.)

WHAT IS IT?

This project displays the common natural phenomenon expressed by the inverse-square law. Essentially this displays what happens when the strength of the force between two objects varies inversely with the square of the distance between these two objects. In this case, the formula used is the standard formula for the Law of Gravitational Attraction:

(m1 * m2 * G) / r2

This particular model demonstrates the effect of gravity upon a system of interdependent particles. You will see each particle in the collection of small masses (each of the n bodies, n being the total number of particles present in the system) exert gravitational pull upon all others, resulting in unpredictable, chaotic behavior.

HOW TO USE IT

First select the number of particles with the NUMBER slider.

The SYMMETRICAL-SETUP? switch determines whether or not the particles' initial velocities will sum to zero. If On, they will. Their initial positions will also be randomly, but symmetrically, distributed across the world. If SYMMETRICAL-SETUP? is Off, each particle will have a randomly determined mass, initial velocity, and initial position.

MAX-INITIAL-MASS and MAX-INITIAL-SPEED determine the maximum initial values of each particle's mass and velocity. The actual initial values will be randomly distributed in the range from zero to the values specified.

The FADE-RATE slider controls the percent of color that the paths marked by the particles fade after each cycle. Thus at 100% there won't be any paths as they fade immediately, and at 0% the paths won't fade at all. With this you can see the ellipses and parabolas formed by different particles' travels.

The KEEP-CENTERED? switch controls whether the simulation will re-center itself after each cycle. When On, the system will shift the positions of the particles so that the center of mass is at the origin (0, 0).

If you want to design your own custom system, press SETUP to initialize the model, and then use the CREATE-PARTICLE button to create a particle with the settings set with the INITIAL-VELOCITY-X, INITIAL-VELOCITY-Y, INITIAL-MASS, and PARTICLE-COLOR sliders. Particles are created by clicking in the View where you want to place the particle while the CREATE-PARTICLE button is running. (Note, if KEEP-CENTERED? is On the particles will always move so that the center of mass is at the origin.)

THINGS TO TRY

After you have set the sliders to the desired levels, press SETUP to initialize all particles, or SETUP TWO-PLANET to setup a predesigned stable two-planet system. Next, press GO to begin running the simulation. You have two choices: you can either let it run without stopping (the GO forever button), or you can just advance the simulation by one time-step (the GO ONCE button). It may be useful to step through the simulation moment by moment, so that you can carefully watch the interaction of the particles.

THINGS TO NOTICE

The most important thing to observe is the behavior of the particles. Notice how (and to what degree) the initial conditions influence the model.

Compare the two different modes of the model, with SYMMETRICAL-SETUP? On and Off. Observe the initial symmetry of the zero-summed system, and what happens to it. Why do you think this is?

As each particle acts on all the others, the number of particles present directly affects the run of the model. Every additional body changes the center of mass of the system. Watch what happens with 2 bodies, 4 bodies, etc... How is the behavior different?

It may seem strange to think of n discrete particles exerting small forces on one other particle, determining its behavior. However, you can think of it as just one large force emanating from the center of mass of the system. Watch as the center of mass changes over time. In the main procedure, go, look at the two lines of code where each body's position (xc, yc) is established- we shift each particle back towards the center of mass. As no other forces are present in the model (the n-bodies represent a closed system), our real positions are relative, defined only in relation to the center of mass itself. Recall Newton's third law, which states that for each internal force acting on a particle, it exerts an equal but opposite force on another particle. Hence the internal forces cancel out, and we have no net force acting on the center of mass. (If particle 1 exerts a force on particle 2, then particle 2 exerts the same force on particle 1. Run the model with just two particles to watch this in action.)

THINGS TO TRY

Compare this model to the other inverse square model, 'Gravitation'. Look at the paths made by the two different groups of particles. What do you notice about each group? How would you explain the types of paths made by each model?

The force acting upon each turtle is multiplied by a constant, 'g' (a global variable). In classical Newtonian Mechanics, 'g' is the universal gravitational constant, used in the equation for determining the force of gravitational attraction between any two bodies:

f = (g * (mass1 * mass2)) / distance2

In real life, g is difficult to calculate, but is approximately 6.67e-11 (or 0.0000000000667). However, in our model, the use of g keeps the forces from growing too high, so that you might better view the simulation. Feel free to play with the value of g to see how changes to the gravitational constant affect the behavior of the system as a whole. g is defined in the 'setup' procedure.

EXTENDING THE MODEL

Each time-step, every turtle sums over all other turtles to determine the net acting force upon it. Thus, if we have n turtles, each one doing n operations each step, we're approximately taking what is called 'n-squared time'. By this, we mean that the time it takes to run the model is proportional to how many particles we're using. 'n-time', also called linear time, means that the speed of the model is directly proportional to how many turtles are present for each turtle added, there is a corresponding slow-down. But 'n-squared time' (also quadratic time or polynomial time) is worse --- each turtle slows the model down much more. The speed of the model, compared to linear time, is as the total number of turtles, squared. (So a linear time model with 100 turtles would theoretically be as fast as a quadratic time model with just 10 turtles!)

For small values of n (very few turtles), speed isn't a problem. However, we can see that the speed of the model decreases quadratically (as n-squared) as the number of turtles (n itself) increases. How could you speed this up? (It may help you that the center of mass of the system is already being computed each new time-step.)

As the particles all can have different initial positions, masses, and velocities, it makes sense to think of the model as representational of a planetary system, with suns, moons, planets, and other astronomical bodies. Establish different breeds for these different classes- you could give each kind a separate shape and range of masses. See if you could create a model of a solar system similar to ours, or try to create a binary system (a system that orbits about two close stars instead of one).

NETLOGO FEATURES

This model creates the illusion of a plane of infinite size, to better model the behavior of the particles. Notice that with path marking you can see most of the ellipse a particle draws, even though the particle periodically shoots out of bounds. This is done through a combination of the basic turtle primitives hide-turtle and show-turtle, keeping every turtle's true coordinates as special turtle variables xc and yc, and calculations similar to the distance primitive but using xc and yc instead of xcor and ycor.

When you examine the procedure window, take note that standard turtle commands like set heading and fd 1 aren't used here. Everything is done directly to the x-coordinates and y-coordinates of the turtles.

HOW TO CITE

If you mention this model in a publication, we ask that you include these citations for the model itself and for the NetLogo software:

  • Wilensky, U. (1998). NetLogo N-Bodies model. http://ccl.northwestern.edu/netlogo/models/N-Bodies. Center for Connected Learning and Computer-Based Modeling, Northwestern Institute on Complex Systems, Northwestern University, Evanston, IL.
  • Wilensky, U. (1999). NetLogo. http://ccl.northwestern.edu/netlogo/. Center for Connected Learning and Computer-Based Modeling, Northwestern Institute on Complex Systems, Northwestern University, Evanston, IL.

COPYRIGHT AND LICENSE

Copyright 1998 Uri Wilensky.

CC BY-NC-SA 3.0

This work is licensed under the Creative Commons Attribution-NonCommercial-ShareAlike 3.0 License. To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-sa/3.0/ or send a letter to Creative Commons, 559 Nathan Abbott Way, Stanford, California 94305, USA.

Commercial licenses are also available. To inquire about commercial licenses, please contact Uri Wilensky at uri@northwestern.edu.

This model was created as part of the project: CONNECTED MATHEMATICS: MAKING SENSE OF COMPLEX PHENOMENA THROUGH BUILDING OBJECT-BASED PARALLEL MODELS (OBPML). The project gratefully acknowledges the support of the National Science Foundation (Applications of Advanced Technologies Program) -- grant numbers RED #9552950 and REC #9632612.

This model was converted to NetLogo as part of the projects: PARTICIPATORY SIMULATIONS: NETWORK-BASED DESIGN FOR SYSTEMS LEARNING IN CLASSROOMS and/or INTEGRATED SIMULATION AND MODELING ENVIRONMENT. The project gratefully acknowledges the support of the National Science Foundation (REPP & ROLE programs) -- grant numbers REC #9814682 and REC-0126227. Converted from StarLogoT to NetLogo, 2002.

Comments and Questions

Please start the discussion about this model! (You'll first need to log in.)

Click to Run Model 

turtles-own
[ fx     ;; x-component of force vector
  fy     ;; y-component of force vector
  vx     ;; x-component of velocity vector
  vy     ;; y-component of velocity vector
  xc     ;; real x-coordinate (in case particle leaves world)
  yc     ;; real y-coordinate (in case particle leaves world)
  mass   ;; the particle's mass
]

globals
[ center-of-mass-yc ;; y-coordinate of the center of mass
  center-of-mass-xc ;; x-coordinate of the center of mass
  g  ;; Gravitational Constant
]

;;;;;;;;;;;;;;;;;;;;;;;;
;;; Setup Procedures ;;;
;;;;;;;;;;;;;;;;;;;;;;;;

to setup
  clear-all
  set g 20
  set-default-shape turtles "circle"
  crt number
  ifelse symmetrical-setup?
  [ zero-sum-initial-setup ]
  [ random-initial-setup ]
  if keep-centered?
  [ recenter ]
  reset-ticks
end 

to random-initial-setup
  ask turtles
  [ set vx ((random-float ((2 * max-initial-speed) - 1)) - max-initial-speed)
    set vy ((random-float ((2 * max-initial-speed) - 1)) - max-initial-speed)
    set mass (random-float max-initial-mass) + 1
    set size sqrt mass
    set heading (random-float 360)
    jump (random-float (max-pxcor - 10))
    set xc xcor
    set yc ycor
  ]
end 

to zero-sum-initial-setup
  ;; First we set up the initial velocities of the first half of the particles.
  ask turtles with [who < (number / 2)]
  [ set vx (random-float (((2 * max-initial-speed) - 1)) - max-initial-speed)
    set vy (random-float (((2 * max-initial-speed) - 1)) - max-initial-speed)
    setxy random-xcor random-ycor
    set xc xcor
    set yc ycor
    set mass (random-float max-initial-mass) + 1
    set size sqrt mass
  ]
  ;; Now, as we're zero-summing, we set the velocities of the second half of the
  ;; particles to be the opposites of their counterparts in the first half.
  ask turtles with [who >= (number / 2)]
  [ set vx (- ([vx] of turtle (who - (number / 2))))
    set vy (- ([vy] of turtle (who - (number / 2))))
    set xc (- ([xc] of turtle (who - (number / 2))))
    set yc (- ([yc] of turtle (who - (number / 2))))
    setxy xc yc
    set mass [mass] of turtle (who - (number / 2))
    set size sqrt mass
  ]
  set center-of-mass-xc 0
  set center-of-mass-yc 0
end 

to create-particle
  if mouse-down?
  [ let mx mouse-xcor
    let my mouse-ycor
    if (not any? turtles-on patch mx my)
    [
      crt 1
      [ set xc mx ;initial-position-x
        set yc my ;initial-position-y
        setxy xc yc
        set vx initial-velocity-x
        set vy initial-velocity-y
        set mass initial-mass
        set size sqrt mass
        set color particle-color
      ]
      display
    ]
  ]
  while [mouse-down?]
  []
  if keep-centered?
  [
    recenter
    display
  ]
end 

to setup-two-planet
  set number 0
  setup
  crt 1
  [ set color yellow
    set mass 200
    set size sqrt mass
  ]
  crt 1
  [ set color blue
    set mass 5
    set size sqrt mass
    set xc 50
    set yc 0
    setxy xc yc
    set vx 0
    set vy 9
  ]
  crt 1
  [ set color red
    set mass 5
    set size sqrt mass
    set xc 90
    set yc 0
    setxy xc yc
    set vx 0
    set vy 7
  ]
end 

;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Runtime Procedures ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;

to go
  ask turtles
  [ set fx 0
    set fy 0
  ]
  ;; must do all of these steps separately to get correct results
  ;; since all turtles interact with one another
  ask turtles [ check-for-collisions ]
  ask turtles [ update-force ]
  ask turtles [ update-velocity ]
  ask turtles [ update-position ]
  if keep-centered?
  [ recenter ]
  fade-patches
  tick
end 

to check-for-collisions
  if any? other turtles-here
  [
    ask other turtles-here
    [
      set vx vx + [vx] of myself
      set vy vy + [vy] of myself
      set mass mass + [mass] of myself
      set size sqrt mass
    ]
    die
  ]
end 

to update-force ;; Turtle Procedure
  ;; This is recursive over all the turtles, each turtle asks this of all other turtles
  ask other turtles [ sum-its-force-on-me myself ]
end 

to sum-its-force-on-me [it] ;; Turtle Procedure
  let xd xc - [xc] of it
  let yd yc - [yc] of it
  let d sqrt ((xd * xd) + (yd * yd))
  set fx fx + (cos (atan (- yd) (- xd))) * ([mass] of it * mass) / (d * d)
  set fy fy + (sin (atan (- yd) (- xd))) * ([mass] of it * mass) / (d * d)
end 

to update-velocity ;; Turtle Procedure
  ;; Now we update each particle's velocity, by taking last time-step's velocity
  ;; and adding the effect of the force to it.
  set vx (vx + (fx * g / mass))
  set vy (vy + (fy * g / mass))
end 

to update-position ;; Turtle Procedure
  ;; As our system is closed, we can safely recenter the center of mass to the origin.
  set xc (xc + vx)
  set yc (yc + vy)
  adjust-position
end 

to adjust-position ;; Turtle Procedure
  ;; If we're in the visible world (the world inside the view)
  ;; update our x and y coordinates.
  ;; if there is no patch at xc yc that means it is outside the world
  ;; and the turtle should just be hidden until it returns to the
  ;; viewable world.
  ifelse patch-at (xc - xcor) (yc - ycor) != nobody
  [ setxy xc yc
    show-turtle
    if (fade-rate != 100)
    [ set pcolor color + 3 ]
  ]
  [ hide-turtle ]
end 

;; Center of Mass

to recenter
  find-center-of-mass
  ask turtles
  [ set xc (xc - center-of-mass-xc)
    set yc (yc - center-of-mass-yc)
    adjust-position
  ]
end 

to find-center-of-mass
  if any? turtles
  [ set center-of-mass-xc sum [mass * xc] of turtles / sum [mass] of turtles
    set center-of-mass-yc sum [mass * yc] of turtles / sum [mass] of turtles
  ]
end 

to fade-patches
  ask patches with [pcolor != black]
  [ ifelse (fade-rate = 100)
    [ set pcolor black ]
    [ if (fade-rate != 0)
      [ fade ]
    ]
  ]
end 

to fade ;; Patch Procedure
  let new-color pcolor - 8 * fade-rate / 100
  ;; if the new-color is no longer the same shade then it's faded to black.
  ifelse (shade-of? pcolor new-color)
  [ set pcolor new-color ]
  [ set pcolor black ]
end 


; Copyright 1998 Uri Wilensky.
; See Info tab for full copyright and license.

There are 10 versions of this model.

Uploaded by When Description Download
Uri Wilensky over 11 years ago Updated to NetLogo 5.0.4 Download this version
Uri Wilensky about 12 years ago Updated version tag Download this version
Uri Wilensky about 12 years ago Updated to version from NetLogo 5.0.3 distribution Download this version
Uri Wilensky almost 13 years ago Updated to NetLogo 5.0 Download this version
Uri Wilensky over 14 years ago Updated from NetLogo 4.1 Download this version
Uri Wilensky over 14 years ago Updated from NetLogo 4.1 Download this version
Uri Wilensky over 14 years ago Updated from NetLogo 4.1 Download this version
Uri Wilensky over 14 years ago Updated from NetLogo 4.1 Download this version
Uri Wilensky over 14 years ago Model from NetLogo distribution Download this version
Uri Wilensky over 14 years ago N-Bodies Download this version

Attached files

File Type Description Last updated
N-Bodies.png preview Preview for 'N-Bodies' over 11 years ago, by Uri Wilensky Download

This model does not have any ancestors.

This model does not have any descendants.