Module 3: A public health application

3.1 Exercise: Download Simulation.java, compile and execute. You will also need DrawTool.java.

Let's explain:

• We're simulating a public health scenario: the spread of an infection.

• We will simplify for the sake of exposition and ease of programming. For example, a realistic simulation will also feature the period of infectivity (after which an infected person becomes normal), but in ours once a person is infected, they stay infected.

• We start with N particles representing N people (or animals), one of which is infected.

• The N particles move about randomly to simulate random contact between individuals.

• If an uninfected particle comes in close contact with an infected one, it gets infected.

• As the simulation showed, it takes a while for the infection to spread.

• Our goal is to study some quantitative aspects of the spread:
  1. Given a fixed size population of N, how long before half the population gets infected? Is this a fixed number that does not change with N? If it does change with N, how does it change?
  2. Suppose we fix N. What fraction of the population is infected after 10 days, after 20 days, and so on? Does this increase gradually or rapidly?

• Note: simplifying the simulation at this time is fine because we can always come back and modify the simulation to add realism.

3.2 Exercise: Before we study these two questions, do you have any intuition at this point?

Let's now examine some of the code:

public class Simulation {

    // Number of particles (N), the xy location of each, and color.
    static int N = 10;
    static double[] x;
    static double[] y;
    static boolean[] isRed;

    // The bounds of the region.
    static double size = 10;

    static int numSteps = 100;

    // How close do you have to be to get infected?
    static double infectionDistance = 0.5;

    public static void main (String[] argv)
    {
	DrawTool.display ();
	DrawTool.setXYRange (0, size, 0, size);
	DrawTool.startAnimationMode ();

	initialize ();

	for (int step=1; step<=numSteps; step++) {

	    // Spread.
	    infectionSpread ();

	    // Move each particle and draw
	    for (int i=0; i<N; i++) {
		move (i);
		draw (i);
	    }

	    DrawTool.animationPause (100);
	}

	DrawTool.endAnimationMode ();
    }
     

• We're using two arrays to track the location of each particular particle.

      static double[] x;
      static double[] y;
       

  Here x[i] will have the x coordinate of the i-th particle, and [i] will have its y coordinate.

• We use a Boolean array to track whether or not (true or false) a particular particle is infected ("red" indicates infected):

      static boolean[] isRed;
       

• When an uninfected particle is close enough to an infected one, it gets infected. This "close enough" distance is stored here:

      static double infectionDistance = 0.5;
       

• The main loop is quite simple:

  	for (int step=1; step<=numSteps; step++) {
  	    infectionSpread ();
  	    for (int i=0; i<N; i++) {
  		move (i);
  		draw (i);
  	    }
          }
       

  At each step, we determine which particles get infected, then we move each particle randomly, and update the drawing.

• All that's left is to understand the infectionSpread() and move() methods.

Let's take a closer look at the infectionSpread() and move() methods:

• The main idea is:

       for each particle {
           compute the distance to each red particle
           if it's close enough, set the color of this one to red
       }
       

• This idea turns into:

  	for (int n=0; n<N; n++) {      // for each particle...
  	    if (! isRed[n]) {          // if it's not infected
  		// See if this is near some other red
  		for (int m=0; m<N; m++) {    
                      // We must cycle through all to know which are red
  		    if (isRed[m]) {
  			// Check distance.
  			double d = distance (x[n],y[n], x[m], y[m]);
  			if (d < infectionDistance) {
  			    isRed[n] = true;
  			}
  		    }
  		}
  	    }
  	}
       

• The move() method is quite straightforward:

      static void move (int i)
      {
  	double xDiff = randomDouble (-1, 1);
  	double yDiff = randomDouble (-1, 1);
  	if ( withinBounds(x[i]+xDiff, y[i]) ) {
  	    x[i] += xDiff;
  	}
  	if ( withinBounds(x[i], y[i]+yDiff) ) {
  	    y[i] += yDiff;
  	}
      }
       

  • Recall: it is called once for each i.
  • Two random values (such as 0.63 and -0.19) are generated.
  • These are added to x[i] and y[i] respectively.
  • Which has the effect of changing the location of the i-th point.

• We could reduce the range to (-0.5,0.5) if we wanted smoother (less jumpy, but slower) motion.

• We've created the "helper" method randomDouble() to generate a random number within a specified range.

Let's point out something about animation that will be useful later:

• The effect of animation is created when there is a deliberate pause in time between movements.

• To see this, change the pause time from 100 to 10 in the main loop.

• Animation, however, is not what's desired if we want to run the simulation for purely statistical purposes (next section).
         ⇒ It slows down overall execution.

Step 2: Write code to specialize the simulation

    public static int simulateNumSteps (
        int numParticles,               // Desired # particles
        double infDist,                 // Infection distance
        int targetCount)                // Simulate until so many infected.
    {
	// INSERT YOUR CODE HERE
    }

    public static int simulateNumInfected (
        int numParticles,               // Desired # particles
        double infDist,                 // Infection distance
        int desiredNumSteps)            // Simulate for this many steps
    {
	// INSERT YOUR CODE HERE
    }