rubylabs 0.6.4 → 0.7.0

data/lib/spherelab.rb

@@ -7,40 +7,86 @@ Definition of Vector and Body objects used for n-body simulations.
 
 =end
 
+include Math
+
 module RubyLabs
 	
 module SphereLab
+  
+=begin rdoc
+  These class variables maintain the state of the display and other miscellaneous
+  global values.
+=end
+  
+  @@dataDirectory = File.join(File.dirname(__FILE__), '..', 'data', 'spheres')
+
+  @@viewerOptions = {
+    :dotColor => '#000080',
+    :dotRadius => 1.0,
+    :origin => :center,
+  }
+  
+  @@droppingOptions = {
+    :canvasSize => 400,
+    :mxmin => 100,
+    :mymin => 50,
+    :hmax => 100,
+  }
+  
+  @@robotOptions = {
+    :canvasSize => 400,
+    :polygon => [4,0,0,10,4,8,8,10],    
+  }
+  
+  @@drawing = nil
+  @@delay = 0.1
+  
+  NBodyView = Struct.new(:bodies, :origin, :scale, :options)
+  TurtleView = Struct.new(:turtle, :center)
+  MelonView = Struct.new(:bodies, :scale, :ground, :startloc, :options)
 
 =begin rdoc
   The constant G is the universal gravitational constant, assuming mass is
   in units of kilograms, distances are in meters, and time is in seconds.
 =end
 
-G = 6.67E-11
+  G = 6.67E-11
 
+=begin rdoc
+  A Vector is a 3-tuple of (x,y,z) coordinates.  Operators defined for
+  vector objects (where v is a vector and a is a scalar):
+     v == v
+     v + v
+     v - v
+     v * a
+     v.add(v)     (equivalent of v += v)
+     v.sub(v)     (equivalent of v -= v)
+     v.scale(a)   (equivalent of v *= a)
+     v.norm
+=end
 
-class Vector
-  attr_accessor :x, :y, :z
+  class Vector
+    attr_accessor :x, :y, :z
   
 =begin rdoc
   Make a new vector with the specified x, y, and z components.
 =end
   
-  def initialize(*args)
-    @x, @y, @z = args
-  end
+    def initialize(*args)
+      @x, @y, @z = args
+    end
   
-  def inspect
-    sprintf "<%s, %s, %s>", @x.to_s, @y.to_s, @z.to_s
-  end
+    def inspect
+      sprintf "<%s, %s, %s>", @x.to_s, @y.to_s, @z.to_s
+    end
   
 =begin rdoc
   v1 == v2 if the three components are the same
 =end
 
-  def ==(v)
-    return (@x == v.x) && (@y == v.y) && (@z == v.z)
-  end
+    def ==(v)
+      return (@x == v.x) && (@y == v.y) && (@z == v.z)
+    end
 
 =begin rdoc
   Arithmetic methods are invoked for a vector v1 when Ruby evaluates an expression of the
@@ -49,51 +95,84 @@ class Vector
   is a vector-scalar multiplication.
 =end
   
-  def +(v)
-    Vector.new(@x + v.x, @y + v.y, @z + v.z)
-  end
+    def +(v)
+      Vector.new(@x + v.x, @y + v.y, @z + v.z)
+    end
   
-  def -(v)
-    Vector.new(@x - v.x, @y - v.y, @z - v.z)
-  end
+    def -(v)
+      Vector.new(@x - v.x, @y - v.y, @z - v.z)
+    end
 
-  def *(a)
-    Vector.new(@x * a, @y * a, @z * a)
-  end
+    def *(a)
+      Vector.new(@x * a, @y * a, @z * a)
+    end
 
 =begin rdoc
   v1.add(v2) adds the components of v2 to v1 -- would be v1 += v2 if Ruby
   allowed us to overload +=
 =end
 
-  def add(v)
-    @x += v.x
-    @y += v.y
-    @z += v.z
-    self
-  end
+    def add(v)
+      @x += v.x
+      @y += v.y
+      @z += v.z
+      self
+    end
   
 =begin rdoc
   v1.sub(v2) subtracts the components of v2 from v1 -- would be v1 -= v2 if Ruby
   allowed us to overload -=
 =end
 
-  def sub(v)
-    @x -= v.x
-    @y -= v.y
-    @z -= v.z
-    self
-  end
+    def sub(v)
+      @x -= v.x
+      @y -= v.y
+      @z -= v.z
+      self
+    end
+    
+=begin rdoc
+  v.scale(a) -- multiply each element in v by scalar a
+=end
+
+    def scale(a)
+      @x *= a
+      @y *= a
+      @z *= a
+    end
 
 =begin rdoc
   The magnitude of a vector is the Euclidean norm: sqrt(x**2 + y**2 + z**2)
 =end
 
-  def norm
-    Math.sqrt(@x*@x + @y*@y + @z*@z)
-  end
+    def norm
+      sqrt(@x*@x + @y*@y + @z*@z)
+    end
+    
+=begin rdoc
+  Compute the angle between this vector and v -- used when drawing 2D vectors, so
+  the z dimension is ignored
+=end
+
+    def angle(v)
+      acos((@x * v.x + @y * v.y) / (norm * v.norm))
+    end
+    
+=begin rdoc
+  Accessor functions for the coordinates as a vector of three floats
+=end
+
+    def coords
+      [@x, @y, @z]
+    end
+    
+    def coords=(a)
+      @x = a[0]
+      @y = a[1]
+      @z = a[2]
+    end
   
-end # Vector
+  end # Vector
 
 
 =begin rdoc
@@ -103,8 +182,9 @@ end # Vector
   the visualization methods.
 =end
 
-class Body
-  attr_accessor :mass, :position, :velocity, :force, :name, :size, :color
+  class Body
+    attr_accessor :mass, :position, :velocity, :force
+    attr_accessor :name, :size, :color, :prevx, :prevy, :graphic
   
 =begin rdoc
   The constructor can be called with a variety of different arguments:
@@ -118,233 +198,510 @@ class Body
     * pass no parameters to get a body with all attributes set to 0
 =end
 
-  def initialize(*args)
-    if args[1].class == Vector
-      @mass, @position, @velocity, @name = args
-    elsif args[0] == :random
-      @mass = rand(10000) * 1e6
-      @position = Vector.new(rand(300)-150, rand(300)-150, 0)
-      @velocity = Vector.new(rand(20)-10, rand(10)-5, 0)
-      @name = "b" + self.object_id.to_s
-    elsif args[0].is_a?(Numeric) && args[1].is_a?(Numeric)
-      @mass = args[0]
-      @position = Vector.new(args[1], 0.0, 0.0)
-      @velocity = Vector.new(0.0, 0.0, 0.0)
-      @name = args[2]
-      @linear = true
-    else
-      @mass = 0.0
-      @position = Vector.new(0.0, 0.0, 0.0)
-      @velocity = Vector.new(0.0, 0.0, 0.0)
-      @name = nil
+    def initialize(*args)
+      if args[1].class == Vector
+        @mass, @position, @velocity, @name = args
+      elsif args[0] == :random
+        @mass = rand(10000) * 1e6
+        @position = Vector.new(rand(300)-150, rand(300)-150, 0)
+        @velocity = Vector.new(rand(20)-10, rand(10)-5, 0)
+        @name = "b" + self.object_id.to_s
+      elsif args[0].is_a?(Numeric) && args[1].is_a?(Numeric)
+        @mass = args[0]
+        @position = Vector.new(args[1], 0.0, 0.0)
+        @velocity = Vector.new(0.0, 0.0, 0.0)
+        @name = args[2]
+        @linear = true
+      else
+        @mass = 0.0
+        @position = Vector.new(0.0, 0.0, 0.0)
+        @velocity = Vector.new(0.0, 0.0, 0.0)
+        @name = nil
+      end
+      @force = Vector.new(0.0, 0.0, 0.0)
     end
-    @force = Vector.new(0.0, 0.0, 0.0)
-  end
   
-  def inspect
-    s = ""
-    s << @name + ": " if @name
-    s << @mass.to_s + "g "
-    if @linear
-      s << "x: " + @position.x.to_s
-    else
-      s << @position.inspect + " " + @velocity.inspect 
+    def inspect
+      s = ""
+      s << @name + ": " if @name
+      s << @mass.to_s + "g "
+      if @linear
+        s << "x: " + @position.x.to_s
+      else
+        s << @position.inspect + " " + @velocity.inspect 
+      end
+      return s
     end
-    return s
-  end
 
 =begin rdoc
   Reset the force vector to 0 (to get ready for a new round of interaction calculations).
 =end
 
-  def clear_force
-    @force.x = 0.0
-    @force.y = 0.0
-    @force.z = 0.0
-  end
+    def clear_force
+      @force.x = 0.0
+      @force.y = 0.0
+      @force.z = 0.0
+    end
   
 =begin rdoc
   Compute force acting on this body wrt body b
 =end
 
-  def add_force(b)
-    r = @position - b.position
-    nr = r.norm ** 3
-    mr = b.mass / nr
-    @force.add(r * mr)
-  end
+    def add_force(b)
+      r = @position - b.position
+      nr = r.norm ** 3
+      mr = b.mass / nr
+      @force.add(r * mr)
+    end
   
 =begin rdoc
   Move this body by applying current force vector for dt seconds
 =end
 
-  def move(dt)
-    acc = @force * G * -1.0
-    @velocity.add( acc * dt ) 
-    @position.add( @velocity * dt )
-  end
+    def move(dt)
+      acc = @force * G * -1.0
+      @velocity.add( acc * dt ) 
+      @position.add( @velocity * dt )
+    end
   
 =begin rdoc
   Class method to compute the interaction between bodies b1 and b2 and update
   their force vectors.
 =end
 
-  def Body.interaction(b1, b2)
-    r = b1.position - b2.position
-    a = r.norm ** 3
-    b1.force.add(r * (b2.mass / a))
-    b2.force.add(r * (-b1.mass / a))
+    def Body.interaction(b1, b2)
+      r = b1.position - b2.position
+      a = r.norm ** 3
+      b1.force.add(r * (b2.mass / a))
+      b2.force.add(r * (-b1.mass / a))
+    end
+  
+  end # Body
+  
+=begin rdoc
+  A class for rudimentary Turtle graphics.  All we need is enough functionality to
+  implement a robot that draws a circle by moving forward, then correcting its direction.
+  Attributes:  location and velocity vectors.
+=end
+
+  class Turtle
+    
+    attr_accessor :position, :velocity, :graphic
+    
+    @@turtleOptions = {
+      :x => 20,
+      :y => 100,
+      :heading => 0,
+      :speed => 10,
+    }
+    
+    @@north = Vector.new(0, 10, 0)
+
+    def initialize(args = nil)
+      args = { } if args.nil?
+      raise "Turtle: initialize: args must be a Hash" unless args.class == Hash
+      options = @@turtleOptions.merge(args)
+      alpha = Canvas.radians(options[:heading] + 90.0)
+      @position = Vector.new(options[:x], options[:y], 0.0)
+      @velocity = Vector.new(-1.0 * options[:speed] * cos(alpha), options[:speed] * sin(alpha), 0.0)
+      @graphic = nil
+    end
+    
+    def inspect
+      sprintf "#<SphereLab::Turtle x: %d y: %d heading: %d speed: %.2f>", @position.x, @position.y, heading, speed 
+    end
+    
+    def location
+      return [@position.x, @position.y]
+    end
+    
+    def heading
+      d = Canvas.degrees( @velocity.angle(@@north) )
+      return (@velocity.x < 0) ? (360 - d) : d
+    end
+    
+    def speed
+      @velocity.norm
+    end
+    
+    def turn(alpha)
+      theta = -1.0 * Canvas.radians(alpha)
+      x = @velocity.x * cos(theta) - @velocity.y * sin(theta)
+      y = @velocity.x * sin(theta) + @velocity.y * cos(theta)
+      @velocity.x = x
+      @velocity.y = y
+      if graphic
+        Canvas.rotate(graphic,alpha)
+        Canvas.sync
+      end
+      return alpha
+    end
+    
+    def advance(dt)
+      prevx = @position.x
+      prevy = @position.y
+      @position.add( @velocity * dt )
+      if graphic
+        Canvas.move(graphic, @position.x-prevx, prevy-@position.y, :track)
+        Canvas.sync
+      end
+      return dt
+    end    
+  end
+  
+=begin rdoc
+  Set up an experiment with a robot/turtle.  Initialize the canvas, make the turtle,
+  assign it a graphic.  These methods are all defined with respect to a canvas, and
+  they will print an error message if the experiment has not been set up with a call
+  to init_robot (which sets @@drawing).
+=end
+
+  def view_robot(userOptions = {})
+    options = @@robotOptions.merge(userOptions)
+    poly = options[:polygon].clone
+    edge = options[:canvasSize]
+    (0...poly.length).step(2) do |i| 
+      poly[i] += edge/10
+      poly[i+1] += edge/2
+    end
+    Canvas.init(edge, edge, "SphereLab")
+    turtle = Turtle.new( :x => edge/10, :y => edge/2, :heading => 0, :speed => 10 )
+    turtle.graphic = Canvas.polygon(poly, :outline => 'black', :fill => '#00ff88')
+    Canvas.circle( edge/2, edge/2, 3, :fill => 'darkblue' )
+    @@drawing = TurtleView.new( turtle, [edge/2, edge/2] )
+    Canvas.sync
+    return true
+  end
+    
+  def robot
+    if @@drawing.nil?
+      puts "No robot; call view_robot to initialize"
+      return nil
+    else
+      return @@drawing.turtle
+    end
+  end
+    
+  # TODO -- aim toward point on circle at original radius, not current radius...
+
+  def orient_robot
+    r = robot
+    mx, my = @@drawing.center
+    tx, ty = r.position.x, r.position.y
+    mid = Vector.new(tx-my, ty-my, 0.0)
+    theta = Canvas.degrees(mid.angle(r.velocity))
+    alpha = 2 * (90.0 - theta)
+    r.turn(alpha)    
+    Canvas.sync
+    return alpha
   end
   
-end # Body
+  # :begin :make_circle
+  def make_circle(nseg, time, angle)
+    view_robot
+    turn_robot( angle/2 )
+    nseg.times { advance_robot(time); turn_robot(angle) }
+    turn_robot( -angle/2 )
+    return true
+  end
+  # :end :make_circle
+
 
 =begin rdoc
-  Make a list of Body objects using data in the file +fn+
+  These methods create a set of bodies with random size, location, and initial
+  velocity.
 =end
 
-def read_bodies(fn)
-  bodies = []
-  File.open(fn).each do |line|
-    line.strip!
-    next if line.length == 0
-    next if line[0] == ?#
-    a = line.chomp.split
-    for i in 1..7
-      a[i] = a[i].to_f
+  def random_vectors(r, i, n)
+    theta = (2 * PI / n) * i + (PI * rand / n)
+    radius = r + (r/3)*(rand-0.5)
+    x = radius * cos(theta)
+    y = radius * sin(theta)
+    vtheta = (PI - theta) * -1 + PI * (rand-0.5)
+    vx = radius/20 * cos(vtheta)
+    vy = radius/20 * sin(vtheta)
+    return Vector.new(x, y, 0), Vector.new(vx, vy, 0)
+  end
+
+  def random_velocity(v, r)
+    res = Vector.new(-r * cos)
+  end
+
+  def random_bodies(n, big = 1)
+    res = []
+    mm = 1e12          # average mass
+    mr = 150          # average distance from origin
+    # write_tuple( :scale, [ 1.0 ] )
+    big.times do |i|
+      r0, v0 = random_vectors(mr/2, i, big)
+      res << Body.new(mm*100/big, r0, v0)
+      # write_tuple( :view, [i, 10, "#0080ff"] )
+    end
+    (n-big).times do |i|
+      r, v = random_vectors(mr, i, n-big)
+      b = Body.new(mm, r, v)
+      # write_tuple( :view, [i+big, 5, "#0080ff"] )
+      res << b
     end
-    b = Body.new( a[1], Vector.new(a[2],a[3],a[4]), Vector.new(a[5],a[6],a[7]), a[0] )
-    b.size = a[-2].to_i
-    b.color = a[-1]
-    bodies << b
+    res.each_with_index { |b,i| b.name = "b#{i}"; b.color = '#0080ff'; b.size = 5 }
+    return res
   end
-  return bodies
-end
+  
+=begin rdoc
+  Initialize a new n-body system, returning an array of body objects.  The
+  parameter is the name of a predefined system, the name of a file, or the
+  symbol :random.
+=end
 
+	def make_system(*args)
+    bodies = []
+		begin
+		  raise "usage: make_system(id)" unless args.length > 0
+		  if args[0] == :random
+		    raise "usage:  make_system(:random, n)" unless args.length == 2 && args[1].class == Fixnum
+		    return random_bodies(args[1])
+	    end
+	    filename = args[0]
+  	  if filename.class == Symbol
+  	    filename = File.join(@@dataDirectory, filename.to_s + ".txt")
+      end
+      File.open(filename).each do |line|
+        line.strip!
+        next if line.length == 0
+        next if line[0] == ?#
+        a = line.chomp.split
+        for i in 1..7
+          a[i] = a[i].to_f
+        end
+        b = Body.new( a[1], Vector.new(a[2],a[3],a[4]), Vector.new(a[5],a[6],a[7]), a[0] )
+        b.size = a[-2].to_i
+        b.color = a[-1]
+        bodies << b
+      end
+		rescue
+			puts "error: #{$!}"
+			return nil
+		end
+		return bodies
+	end
+		
+=begin rdoc
+  Initialize the drawing canvas by drawing a circle for each body in list b.
+=end
+
+  def view_system(blist, userOptions = {})
+    Canvas.init(700, 700, "SphereLab")
+    options = @@viewerOptions.merge(userOptions)
+    origin = setOrigin(options[:origin])
+    sf = setScale(blist, options[:origin], options[:scale])
+    blist.each do |b|
+      x, y = scale(b.position, origin, sf)
+      circle = Canvas.circle(x, y, b.size, :fill => b.color)
+      b.graphic = circle
+      b.prevx = x
+      b.prevy = y
+    end
+    @@drawing = NBodyView.new(blist, origin, sf, options)
+    if options.has_key?(:dash)
+      options[:dashcount] = 0
+      options[:pendown] = :track
+    elsif options.has_key?(:pendown)
+      options[:pendown] = :track
+    end
+    Canvas.sync
+    return true  
+  end
+  
 =begin rdoc
   Call SphereLab::step(bodies, time) to calculate the pairwise interactions between all
   Body objects in the array +bodies+ and then compute their new positions after +time+ seconds.
 =end
 
-# :begin :step
-def step(bodies, time)
-  nb = bodies.length
+# :begin :step_system
+  def step_system(bodies, time)
+    nb = bodies.length
   
-  for i in 0...nb         # compute all pairwise interactions
-    for j in (i+1)...nb
-      Body.interaction( bodies[i], bodies[j] )
+    for i in 0...nb         # compute all pairwise interactions
+      for j in (i+1)...nb
+        Body.interaction( bodies[i], bodies[j] )
+      end
     end
-  end
   
-  bodies.each do |b|
-    b.move(time)          # apply the accumulated forces
-    b.clear_force         # reset force to 0 for next round
-  end
-end
-# :end :step
-
-def random_vectors(r, i, n)
-  theta = (2 * Math::PI / n) * i + (Math::PI * rand / n)
-  radius = r + (r/3)*(rand-0.5)
-  x = radius * Math.cos(theta)
-  y = radius * Math.sin(theta)
-  vtheta = (Math::PI - theta) * -1 + Math::PI * (rand-0.5)
-  vx = radius/20 * Math.cos(vtheta)
-  vy = radius/20 * Math.sin(vtheta)
-  return Vector.new(x, y, 0), Vector.new(vx, vy, 0)
-end
-
-def random_velocity(v, r)
-  res = Vector.new(-r * Math.cos)
-end
-
-def random_bodies(n, big = 1)
-  res = []
-  mm = 1e12          # average mass
-  mr = 150          # average distance from origin
-  write_tuple( :scale, [ 1.0 ] )
-  big.times do |i|
-    r0, v0 = random_vectors(mr/2, i, big)
-    res << Body.new(mm*100/big, r0, v0)
-    write_tuple( :view, [i, 10, "#0080ff"] )
+    bodies.each do |b|
+      b.move(time)          # apply the accumulated forces
+      b.clear_force         # reset force to 0 for next round
+    end
   end
-  (n-big).times do |i|
-    r, v = random_vectors(mr, i, n-big)
-    b = Body.new(mm, r, v)
-    b.name = "b" + (i+1).to_s
-    write_tuple( :view, [i+big, 5, "#0080ff"] )
-    res << b
+# :end :step_system
+    
+=begin rdoc
+  After making a canvas with view_system, call this method to move the bodies on the canvas.
+=end
+
+  def update_system(bodies, dt)
+    return false unless @@drawing
+    step_system(bodies, dt)
+    if @@drawing.options.has_key?(:dash)
+      @@drawing.options[:dashcount] = (@@drawing.options[:dashcount] + 1) % @@drawing.options[:dash]
+      if @@drawing.options[:dashcount] == 0
+        @@drawing.options[:pendown] = @@drawing.options[:pendown].nil? ? :track : nil
+      end        
+    end
+    bodies.each do |b|
+      next unless b.graphic
+      newx, newy = scale(b.position, @@drawing.origin, @@drawing.scale)
+      Canvas.move(b.graphic, newx-b.prevx, newy-b.prevy, @@drawing.options[:pendown])
+      b.prevx = newx
+      b.prevy = newy
+    end
+    Canvas.sync
+    return true
   end
-  return res
-end
-
-def urey_hall
-  write_tuple( :scale, [ 1e-7 ] )
-  # a 6.6 lb watermelon 7 stories (84 feet) above the surface of the earth:
-  w = Body.new(3000, 6.37101e6 + 25)
-  w.name = "watermelon"
-  w.size = 2
-  w.color = "#ff6666"
-  write_tuple( :view, [1, w.size, w.color] )
-  # the earth:
-  e = Body.new(5.9736E+24, 0)
-  e.name = "earth"
-  e.size = 100
-  e.color = "#004080"
-  write_tuple( :view, [0, e.size, e.color] )
-  return [e, w]
-end
-
-def four_body
-  write_tuple( :scale, [ 0.5 ] )
-  a = Body.new(1.4e18, Vector.new(50, 70, 0), Vector.new(0, 1, 0))
-  write_tuple( :view, [0, 10, "#ff6666"] )
-  b = Body.new(1.2e16, Vector.new(50, 225, 0), Vector.new(-1000, 2, 0))
-  write_tuple( :view, [1, 3, "#ff6666"] )
-  c = Body.new(2.1e16, Vector.new(175, -75, 0), Vector.new(-1, -5, 0))
-  write_tuple( :view, [2, 5, "#ff6666"] )
-  d = Body.new(4.5e16, Vector.new(300, -75, 0), Vector.new(-5, 2, 0))
-  write_tuple( :view, [3, 6, "#ff6666"] )
-  return [a,b,c,d]  
-end
-
-=begin rdoc
-  Attach a probe to the step method, have it call this method to show the 
-  current state of the simulation.
-=end
-
-def display(bodies)
-  for i in 0...bodies.length
-    write_tuple( :body, [i, bodies[i].position.x, bodies[i].position.y] )
+
+=begin rdoc
+  Map a simulation's (x,y) coordinates to screen coordinates using origin
+  and scale factor
+=end
+
+  def scale(vec, origin, sf)
+    loc = vec.clone
+    loc.scale(sf)
+    loc.add(origin)
+    return loc.x, loc.y
   end
-  write_tuple( :timestep, [] )
-  return true
-end
+    
+=begin rdoc
+  Make a vector that defines the location of the origin (in pixels).
+=end
 
+  def setOrigin(type)
+    case type
+    when :center
+      Vector.new( Canvas.width/2, Canvas.height/2, 0)
+    else
+      Vector.new(0,0,0)
+    end
+  end
+  
 =begin rdoc
-  Call this method to create a "scope" for viewing the state of an n-body simulation.
-  Also creates a proc that will be executed when IRB exits to shut down the tuple
-  space and viewer.
+  Set the scale factor.  Use the parameter passed by the user, or find the
+  largest coordinate in a list of bodies.  Add 20% for a margin
 =end
 
-def make_viewer
-  include Viewer
-  launch_viewer("nbview.rb")
-end
+  def setScale(blist, origin, scale)
+    if scale == nil
+      dmax = 0.0
+      blist.each do |b|
+        b.position.coords.each { |val| dmax = val.abs if val.abs > dmax } 
+      end
+    else
+      dmax = scale
+    end
+    sf = (origin == :center) ? (Canvas.width / 2.0) : Canvas.width 
+    return (sf / dmax) * 0.8
+  end
+  
+=begin rdoc
+  Initialize the drawing for a "2-body system" with a small object and the
+  earth.  The parameters are the list of Body objects and viewing options.
+=end
+  
+  def view_melon(blist, userOptions = {})
+    options = @@droppingOptions.merge(userOptions)
+    options[:dash] = 1
+    options[:dashcount] = 0
+    options[:pendown] = :track
+    edge = options[:canvasSize]
+    mxmin = options[:mxmin]
+    mymin = options[:mymin]
+    hmax = options[:hmax]
+    Canvas.init(edge, edge, "SphereLab")
+    earth = Canvas.circle(200, 2150, 1800, :fill => blist[1].color)
+    blist[1].graphic = earth
+    mymax = earth.coords[1]
+    melon = Canvas.circle(mxmin, mymax, 5, :fill => blist[0].color)
+    blist[0].graphic = melon
+    scale = (mymax-mymin) / hmax.to_f
+    @@drawing = MelonView.new(blist, scale, blist[0].position.y, melon.coords, options)
+    Canvas.sync
+    return true
+  end
+  
+=begin rdoc
+  Position the melon (body 0) at a specified height.  If no drawing, save the current
+  position in prevy, but if drawing, get the earth's surface from the drawing (this allows
+  students to move the melon up or down in the middle of an experiment)
+=end
+  
+  def position_melon(blist, height)
+    melon = blist[0]
+    if @@drawing
+      if height > @@drawing.options[:hmax]
+        puts "max height: #{@@drawing.options[:hmax]}"
+        return false
+      end
+      melon.prevy = @@drawing.ground
+      melon.position.y = @@drawing.ground + height
+      a = @@drawing.startloc.clone
+      a[1] -= height * @@drawing.scale
+      a[3] -= height * @@drawing.scale
+      melon.graphic.coords = a
+      Canvas.sync
+    else
+      melon.prevy = melon.position.y
+      melon.position.y += height
+    end
+    melon.velocity.y = 0.0
+    return height
+  end
+  
+  def update_melon(blist, dt)
+    melon = blist[0]
+    mx = melon.position.x
+    my = melon.position.y
+    return "splat" if melon.prevy.nil? || my < melon.prevy
+    step_system(blist, dt)
+    if @@drawing
+      @@drawing.options[:dashcount] = (@@drawing.options[:dashcount] + 1) % @@drawing.options[:dash]
+      if @@drawing.options[:dashcount] == 0
+        @@drawing.options[:pendown] = @@drawing.options[:pendown].nil? ? :track : nil
+      end        
+      dx = (melon.position.x - mx) * @@drawing.scale
+      dy = (my - melon.position.y) * @@drawing.scale
+      Canvas.move(melon.graphic, dx, dy, @@drawing.options[:pendown])
+      Canvas.sync
+    end
+    return dt
+  end
+  
+  # :begin :drop_melon
+  def drop_melon(blist, dt)
+    count = 0
+    loop do
+      res = update_melon(blist, dt)
+      break if res == "splat"
+      count += 1
+    end
+    Canvas.sync if @@drawing
+    return count * dt
+  end
+  # :end :drop_melon
 
+  
 =begin rdoc
   Methods used in IRB sessions.
 =end
 
 # :begin :dist
-def dist(r, t)
-  return r * t
-end
+  def dist(r, t)
+    return r * t
+  end
 # :end :dist
 
 # :begin :falling
-def falling(t)
-  return 0.5 * 9.8 * t**2
-end
+  def falling(t)
+    return 0.5 * 9.8 * t**2
+  end
 # :end :falling
 
 end # SphereLab