Java Tech - Chapter 9 : Physics

We first develop a program with only the physics aspect of the experiment simulation. The following demo shows the dropped mass and the time taken for the drop:

We will use object design to make the program as modular as possible both to clarify the coding and to emulate the actual modularity of the experiment. You can look at an experiment as composed of the following components:

The following classes emulate the experiment with classes for each of these components except for a detector and an analysis tool, which we will add in a later versions of the simulation.

Below we show the code for the code. Note that the drop time is just the sum of the animation frame times. The next version will improve on this.

DropTestApplet

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;

/**
  * This program will run as an applet inside
  * an application frame.<
  *
  * The applet uses DropPanel to simulate the dropping of a
  * mass in a constant gravitational field. A HistPanel displays
  * a histogram of the measurements of the acceleration. PlotFormat
  * is used by HistPanel to format the scale values.
  *
  * The java.util.Timer and java.util.TimerTask are used
  * to update the animation of the drop.
  *
  * Includes "Drop" button to initiate the dropping.
  *
  * The number of values taken from
  * entry in a JTextField. "Clear"  button clears the histogram.
  * In standalone mode, the Exit button closes the program.
  *
**/
public class DropTestApplet extends JApplet
             implements ActionListener
{
  // The DropPanel displays the animation of the
  // falling mass.
  DropPanel fDropPanel;

  // The DropModel generates the physics data.
  DropModel fDropModel;

  // Use the HistPanel JPanel subclass here
  HistPanel fHistPanel;

  Histogram fHistogram;
  int fNumDataPoints = 100;

  boolean fMakingHist = false;
  boolean fUpdateDisplay = false;

  // Use the java.util Timer and TimerTask combo
  // for timing events.
  java.util.Timer fTimer;

  // A text field for getting number of drops per
  // run and the time factor
  JTextField fMaxNumDropsField;
  JTextField fTFactorField;

  // Flag for whether the applet is in a browser
  // or running via the main () below.
  boolean fInBrowser = true;

  //Buttons
  JButton fGoButton;   // start drop
  JButton fClearButton;// resets histogram
  JButton fExitButton;

  // The bottom coordinate of the drop tower
  double fYBottom = 0;

   // Starting coordinates of drop
  double fXBallStart =  25.0; // cm
  double fYBallStart = 200.0; // cm

  // Initial velocity.
  double fVyBallStart = 0.0;
  double fVxBallStart = 0.0;

  // Coordinate of ball.
  double fXBall;
  double fYBall;

  // Time in millisecs when the last drop step made
  double fTDropTotal;

  // Speed up or slow down factor for animation:
  double fTFactor = 1.0;
  double fTFrame = 0.020; // in secs

  // Allow for multiple drops per "run"
  int fMaxNumDrops = 1;
  int fNumDrops = 0;

  /**
    * Create a User Interface with a textarea with sroll bars
    * and a Go button to initiate processing and a Clear button
    * to clear the textarea.
   **/
  public void init () {

    JPanel panel = new JPanel (new BorderLayout ());

    // Use a textfield to get the number of drops per run.
    fMaxNumDropsField =
      new JTextField (Integer.toString (fMaxNumDrops), 10);

    // Use a textfield to get the number of drops per run.
    fTFactorField =
      new JTextField (Double.toString (fTFactor), 10);

    // If return hit after entering text, the
    // actionPerformed will be invoked.
    fMaxNumDropsField.addActionListener (this);
    fTFactorField.addActionListener (this);

    fGoButton = new JButton ("Drop");
    fGoButton.addActionListener (this);

    // Here the clear button will reset the histogram
    fClearButton = new JButton ("Reset");
    fClearButton.addActionListener (this);

    fExitButton = new JButton ("Exit");
    fExitButton.addActionListener (this);

    JPanel controlPanel = new JPanel (new GridLayout (1,2));
    JPanel panel1 = new JPanel (new GridLayout (1,2));
    JPanel panel2 = new JPanel (new GridLayout (1,3));

    panel1.add (fMaxNumDropsField);
    panel1.add (fTFactorField);

    panel2.add (fGoButton);
    panel2.add (fClearButton);
    panel2.add (fExitButton);

    controlPanel.add (panel1);
    controlPanel.add (panel2);

    // Create an instance of the DropPanel
    fDropPanel = new DropPanel (fYBallStart, 0.0);

    // Create a histogram to plot the variance in the
    // drop times.
    fHistogram = new Histogram ("Delta Time","Data", 20,0.0,1.0);
    fHistPanel = new HistPanel (fHistogram);

    JPanel holder_panel = new JPanel (new GridLayout (1,2));
    holder_panel.add (fDropPanel);
    holder_panel.add (fHistPanel);

    panel.add (holder_panel,"Center");
    panel.add (controlPanel,"South");

    // Add text area with scrolling to the content pane.
    add (panel);

    // Create the drop physics model
    fDropModel = new DropModel ();
    fDropModel.setParams (fYBallStart, fVyBallStart);

  } // init

  /** Stop the timer if the browser page unloaded. */
  public void stop () {
    runDone ();
  } // stop

  /** Respond to the buttons.  */
  public void actionPerformed (ActionEvent e) {
    Object source = e.getSource ();
    if (source == fGoButton) {
      if (fGoButton.getText ().equals ("Drop")) {
        try {
          fMaxNumDrops =
            Integer.parseInt (fMaxNumDropsField.getText ());
          fTFactor =
            Double.parseDouble (fTFactorField.getText ());
        }
        catch (NumberFormatException ex) {
          // Could open an error dialog here but just
          // display a message on the browser status line.
          showStatus ("Bad input value");
          return;
        }
        dropReset ();
        fGoButton.setText ("Stop");
        fClearButton.setEnabled (false);

      } else {
          dropDone ();
      }
    }
    else if (source == fClearButton) {
      runReset();
    } else if (!fInBrowser)
        System.exit (0);

  } // actionPerformed

  /**
    *  Before each set of drops, need to create a new timer,
    *  and set up its schedule. The PaintHistTask innner class
    *  object will do the setup for each frame of a drop animation.
   **/
  void dropReset () {

    // Before starting the drop, create the timer task
    // that will cause the histogram display to update
    // during the filling.
    // Create a timer. TimerTask created in MakeHist ()
    fTimer = new java.util.Timer ();

    fDropPanel.reset (fXBallStart, fYBallStart);
    fDropModel.setParams (fYBallStart, fVyBallStart);

    // Start the timer after 20ms and then repeat calls
    // to run in PaintHistTask object by the rate set by
    // the fTFrame value.
    fTimer.schedule (new PaintHistTask (), 20, (int)(fTFrame*1000));

    // Reset time sum
    fTDropTotal = 0.0;
    fNumDrops   = 0;
    fYBall      = fYBallStart;
    fXBall      = fXBallStart;

  } // dropReset

  /**
    * Use the inner class technique to define the
    * TimerTask subclass for stepping through the
    * drop calculation and the frame refresh.
    * Use the real time in the drop calculation instead
    * of the given frame rate times in case there were
    * delays from thread interruptions, the processing
    * in the parts of the program take extra time, etc.
   **/
  class PaintHistTask extends java.util.TimerTask {
    public void run () {
      // Drop the ball
      fYBall = fDropModel.step (fTFactor * fTFrame);

      // Update the position of the ball in the
      // animation and redraw the frame.
      fDropPanel.updatePosition (fXBall, fYBall);

      // Save the time.
      fTDropTotal += fTFactor * fTFrame;

      // Check if ball has crossed the finish line.
      if (fYBall <= fYBottom) dropDone ();

    } // run

  } // PaintHistTask

  /**
    *  Invoked when all the drops are done. Reset
    *  all the parameters to set up for another drop.
   **/
  public void dropDone () {

    // Add time for this drop. Remove the time factor.
    fHistogram.add (fTDropTotal);

    ++fNumDrops;

    // Check if all drops completed.
    if (fNumDrops == fMaxNumDrops){
      // If so then finish up the data recording
      // for this run and return.
      runDone ();
      return;
    }

    // Reset time sum
    fTDropTotal = 0.0;
    fYBall = fYBallStart;
    fXBall = fXBallStart;

    fDropPanel.reset (fXBallStart, fYBallStart);
    fDropModel.setParams (fYBallStart, fVyBallStart);

  } // dropDone

  /** Invoked when Clear button selected. **/
  public void runReset () {

    // Clear the histogram
    fHistogram.clear ();

    // Reset time sum
    fTDropTotal = 0.0;
    fYBall = fYBallStart;
    fXBall = fXBallStart;

    fDropPanel.reset (fXBallStart, fYBallStart);
    fDropModel.setParams (fYBallStart, fVyBallStart);

    repaint();

  } // runReset

  /**
    *  Invoked when all the drops are done. Kill the timer.
    *  A new timer must be created for each run.
    *  Display the histogram with the additional data.
   **/
  public void runDone (){

    // Stop the animation.
    fTimer.cancel ();

    // Update histogram
    fHistPanel.repaint ();

    // Reset the buttons.
    fGoButton.setText ("Drop");
    fClearButton.setEnabled (true);

  } // runDone

  /**  Offer the option of running the applet in an app frame. */
  public static void main (String[] args) {
    //
    int frame_width=450;
    int frame_height=300;

    //
    DropTestApplet applet = new DropTestApplet ();
    applet.fInBrowser = false;
    applet.init ();

    // Following anonymous class used to close window & exit program
    JFrame f = new JFrame ("Drop Test");
    f.setDefaultCloseOperation (JFrame.EXIT_ON_CLOSE);

    // Add applet to the frame
    f.getContentPane ().add ( applet);
    f.setSize (new Dimension (frame_width,frame_height));
    f.setVisible (true);
  } // main

} // DropTestApplet

DropModel

/**
  *  This class models the dropping of a mass in
  *  a constant gravitational field.
**/
public class DropModel
{
  double fYStart  = 100.0;
  double fVyStart = 0.0;
  double t, y, vy;

  // Constants
  double g  = -980.0;// centimeter per sec^2

  /** Initialize the drop parameters. **/
  public void init() {
    y = fYStart;
    vy= fVyStart;
  } // init

  /**
    *  Set the initial vertical position and velocity
    *  and the number of integration steps for a given
    *  delta time value.
   **/
  public void setParams(double yStart, double vyStart){

    fYStart  = yStart;
    fVyStart = vyStart;
    y = fYStart;
    vy= vyStart;

  } // setParams

  /**
    *  Calculate the change in position and velocity
    *  for each increment in time. For this case of a
    *  simple constant velocity and no drag, the dt step
    *  is not divided into finer step sizes for the
    *  integration.
   **/
  public double step(double dt){
    y = y + vy * dt;
    vy = vy + g * dt;
    return y;
  } // step

} // DropModel

DropPanel

import java.awt.*;
import javax.swing.*;

/**
  *  This subclass of PlotPanel provides a
  *  display for a dropped object.
 **/
public class DropPanel extends PlotPanel
{

  Color fBgColor   = Color.WHITE;
  Color fBallColor = Color.RED;

  double fXBall, fYBall;
  int fXBallOld = 0,fYBallOld = -1;
  double fXStart,fYStart;

  // Limits for the vertical scale
  double fYDataMax; // Height in cm
  double fYDataMin;

  // Limits for the horizontal scale
  double fXDataMax = 50.0;
  double fXDataMin =  0.0;

  // Numbers to use for plotting axes scale values
  double [] fXScaleValue = new double[2];;
  double [] fYScaleValue;
  int fNumYScaleValues = 5;
  int fNumXScaleValues = 2;

  /**
    *  Create the panel and set up the scaling for the
    *  box in which to plot the dropped object.
    *
    *  @param fYDataMax - vertical scale max limit
    *  @param fYDataMin - vertical scale min limit
   **/
  public DropPanel (double y_data_max, double y_data_min) {
    fYDataMax = y_data_max;
    fYDataMin = y_data_min;

    // Put starting point at 90% of max
    fYStart = y_data_max * 0.9;
    fYBall = fYStart;
    fXBall = fXDataMax/2.0;// Put ball in middle

    // The horizontal axes scaling will be fixed
    // Use arbitrary default of 0 to 50 for scale.
    fXScaleValue[0] = 0.0;
    fXScaleValue[fNumXScaleValues-1] = fXDataMax;

    // The vertical  (y) values can be changed
    // so do the scaling in this method.
    getScaling ();

    setBackground (fBgColor);
  } // ctor

  /**
    * Get the values for the scaling numbers on
    * the vertical axis in case the limits have
    * changed.
   **/
  void getScaling () {
    getPositions ();

    fYScaleValue = new double[fNumYScaleValues];

    fYScaleValue[0] = fYDataMin;
    fYScaleValue[fNumYScaleValues-1] = fYDataMax;

    // Then calculate the difference between the values
    double range = fYScaleValue[fNumYScaleValues-1]
                        - fYScaleValue[0];
    double del = range/(fNumYScaleValues-1);

    // Now set the intermediate scale values.
    for (int i=1; i < (fNumYScaleValues-1); i++) {
        fYScaleValue[i] = i*del + fYScaleValue[0];
    }
  } // getScaling

  /**
    *  For each time increment, update the position
    *  of the falling object.
   **/
  public void updatePosition (double x, double y) {
    fXBall = x;
    fYBall = y;
    if (y >= fYDataMin) {

       repaint ();
    }
  } // updatePosition

  /**
    *  For a new drop, reset the starting position
    *  and redraw the plot area.
   **/
  public void reset (double x_start, double y_start){
    fXBall = x_start;
    fYBall = y_start;
    fYBallOld = -1;

    fYDataMax = y_start * 1.1;
    getScaling ();

    repaint ();
  } // reset

  /** Draw the ball falling. */
  void paintContents (Graphics g) {
    // Draw the numbers along the axes
    drawAxesNumbers (g, fXScaleValue, fYScaleValue);

    // Need conversion factor from data scale to pixel scale
    double y_convert = fFrameHeight/ (fYDataMax - fYDataMin);
    double x_convert = fFrameWidth/fXDataMax;

    // For dropped object use size relative to the frame.
    int symDim =  (int)(fFrameWidth *.04);

    // Clear old ball position
    if (fYBallOld > 0 ){
      g.setColor (fBgColor);
      g.fillOval (fXBallOld-symDim,fYBallOld-symDim, 2*symDim, 2*symDim);
    }

    // Set the foreground color back to the ball color
    g.setColor (fBallColor);

    int x =  (int)(fXBall*x_convert) + fFrameX;
    int y = fFrameHeight - (int)(fYBall*y_convert) + fFrameY;

    g.fillOval (x-symDim,y-symDim, 2*symDim, 2*symDim);

    // Save current ball coords for erasure in
    // next frame.
    fXBallOld = x; fYBallOld = y;

  } // paintContents

  /**
    * Return the title at the top of the plot.
    * Overrides method in PlotPanel.
   **/
  String getTitle ()
  {  return "Drop Tower Demo";}

  /**
    * Return the label on the horizontal axis.
    * Overrides method in PlotPanel.
   **/
  String getXLabel ()
  {  return "";}

} // DropPanel