Fortunately, the pre-defined class MechSystem already implements all the gory details of Lagrangian mechanics and the actual simulation. To define your own mechanical system, you only need to provide information that describes the physics of the particular system that you want to simulate. There are three groups of methods that need to be defined:

1. Methods that return information about the mechanical system, such as the number and names of its parameters and coordinates.
2. Methods that calculate the kinetic and potential energy for the system.
3. Methods that define how the state of the system is to be drawn.

In the methods that you will define, all the calculations are done in actual physical units, such as meters and kilograms, and not in computer units, such as pixels. The relevant conversions to screen coordinates etc. are automatically handeled by the superclass MechSystem. This way, you only need to worry about the physical properties of the mechanical system you are defining.

Example: A Spring Pendulum

The kinetic and potential energy of the spring pendulum are given by:

How to define the SpringPendulum class

class SpringPendulum extends MechSystem {

Instance variables and general methods

  private double m0, m1, l0, l1, k0, g; // physical parameters
  private int rad0, rad1;               // radii of masses

  String getType() {
    return "SpringPendulum";
  }

  Parameter[] getParamInfo() {
    Parameter[] paraminfo = {
      new Parameter("m0", "inner mass", "kg", 2),
      new Parameter("m1", "outer mass", "kg", 1),
      new Parameter("l0", "inner length", "m", 6),
      new Parameter("l1", "outer length", "m", 4),
      new Parameter("k0", "spring constant", "N/m", 60),
      new Parameter("g", "gravity", "m/s^2", 9.81),
    };
    return paraminfo;
  }

  Coordinate[] getCoordInfo() {
    Coordinate[] coordinfo = {
      new Coordinate("x", "coordinate of inner mass, right of pivot", "m", 
		     	2.2, 0, 0),
      new Coordinate("y", "coordinate of inner mass, above pivot", "m", 
		     	3, 0, 0),
      new Coordinate("alpha", 
			"angle of outer leg, counterclockwise from south",
		     	"radians", 4, 0, 2*Math.PI),
    };
    return coordinfo;
  }

  void setphysics(double[] param) {
    m0=param[0];
    m1=param[1];
    l0=param[2];
    l1=param[3];
    k0=param[4];
    g =param[5];
    rad0 = (int)(5*Math.sqrt(m0/Math.max(m0,m1)));
    rad1 = (int)(5*Math.sqrt(m1/Math.max(m0,m1)));
  }

Methods that define the kinetic and potential energy

The simulation of the Lagrange Applet has preservation of energy built-in, so that the system does not spin out of control as easily in the face of numerical errors. For that reason, neither the potential nor the kinetic energy are allowed to have an explicit time dependency. Also, the algorithm used to adjust the total energy uses the fact that the kinetic energy depends quadratically on the first derivatives of the coordinates, and it is likely to fail if the kinetic energy does not have this property. (However, forced preservation of energy can also be turned off).

  // kinetic energy
  double T(double q[], double qp[]) {
    return (m0+m1)/2 * (sq(qp[0])+sq(qp[1]))
      +    m1/2 * sq(l1)*sq(qp[2])
      +    m1 * qp[2]*l1*(qp[0]*Math.cos(q[2])+qp[1]*Math.sin(q[2]));
  }

  // potential energy
  double U(double q[]) {
    return k0/2 * sq(Math.sqrt(sq(q[0])+sq(q[1]))-l0)
           + (m0+m1)*g * q[1]
           - m1*g * l1*Math.cos(q[2]);
  } 

Methods that define how the system is drawn

The recordtrace method must be invoked to draw a trace segment; this is drawn on the background bg as well as on the foreground og.

The method drawsystem() may also invoke arbitrary drawing methods on the Graphics object og; however, in this case, the coordinates must be converted explicitly, for instance og.drawRectangle(c.x(left), c.y(top), c.dx(right-left), c.dy(bot-top)). The methods c.x() and c.y() convert physical coordinates to screen coordinates, and the methods c.dx() and c.dy() convert differences of physical coordinates to differences of screen coordinates. Note that in the physical coordinate system, the y-axis points upwards. Before invoking a drawing method of og, the correct color must be set with og.setColor(Global.fgcolor).

  void drawsystem(Graphics og, Graphics bg) {
    double x0 =  q[0];
    double y0 =  q[1];
    double x1 =  x0+l1*Math.sin(q[2]);
    double y1 =  y0-l1*Math.cos(q[2]);

    recordTrace(bg,og,x1,y1);

    drawSpring(og,0,0,x0,y0,15,0.2);
    drawLine(og,x0,y0,x1,y1);
    drawMass(og,x0,y0,rad0);
    drawMass(og,x1,y1,rad1);
  }

  DoubleRectangle bounds() {
    double l=l1+l0+
      Math.sqrt(sq((m0+m1)*g/k0)+2*l0*(m0+m1)*g/k0+2*m1*g/k0+2*E()/k0);
    double equi=(m0+m1)*g/k0;

    return new DoubleRectangle(-l,-equi-l,l,-equi+l).enlarge(.05); 
  }

Mapping mouse events (optional)

  void mouseMap(double x, double y) {
    map(0, x);
    map(1, y);
  }

  void mouseMap(double x, double y) {
    map(0, Math.atan2(x,-y));
  }	

Other modifications to Lagrange.java

    (new DoublePendulum()).appendInfoVector(infov);
    (new DoubleSpring()).appendInfoVector(infov);
    (new SpringPendulum()).appendInfoVector(infov);
    // *** add your own system here ***
    ...
 
    if (type.equals("doublependulum")) {
      mechsys = new DoublePendulum();
    } else if (type.equals("springpendulum")) {
      mechsys = new SpringPendulum();
    } else if (type.equals("doublespring")) {
      mechsys = new DoubleSpring();
    // *** add your own system here ***

1. Double Pendulum,
2. Double Spring,
3. Spring Pendulum.

Back to main Lagrange page.
Back to Peter Selinger's Homepage: