The outline below shows the constructor, methods, and instance variables (or fields) of the CelestialBody class. All instance variables should be private. All methods should be public (if you write helper methods they should be private).

You'll have six instance variables: myXPos, myYPos, myXVel, myYVel, myMass, myFileName. The first five have type double, the last is a String.

You'll have one constructor: it has six parameters, one for each instance variable. The signatures of is shown below.

This method returns the distance between two CelestialBody objects. Use the standard distance formula to determine the distance between this body (using myXPos and myYPos or this.myXPos and this.myYPos) and the CelestialBody object specified by the parameter b. The distance is the value of $r$ in the formula below where

r^2=dx^2 + dy^2

where $dx$ is delta/difference between $x$-coordinates, similarly for $dy$. You can use the static method Math.sqrt to calculate the square root of a number.

This method calculates and returns the force exerted on this body by the body specified as the parameter. You should calculate the force using the formula below. You can read about the physics of the formula in the NBody Physics document.

F = G\frac{m_1m_2}{r^2}

Here $m_1$ and $m_2$ are the masses of the two bodies, $G$ is the gravitational constant ($6.67 \cdot 10^{-11}\frac{N-m^2}{kg^2}$), and $r$ is the distance between the two objects. Call calcDistance to determine this distance. You can specify $G$ as $6.67 \cdot 10^{-11}$ (alternatively, 6.67*1e-11) using scientific notation in Java.

When you've implemented this method, test it by running TestCalcForceExertedBy.java.

These two methods describe the force exerted in the X and Y directions, respectively. The signature of calcForceExertedByX is shown above; calcForceExertedByY has a similar signature.

You can obtain the $x$- and $y$-components from the total force using the formulas below, where $F$ is the value returned by calcForceExertedBy, $r$ is the distance between two bodies, and $F_x$ and $F_y$ are the values to be returned by calcForceExertedByX and calcForceExertedByY, respectively. Note that $dx$ and $dy$ in the formula the differences between $x$ and $y$ coordinates respectively between the original body (this, the object on which the method is called) and the exerting body (the argument to the method).

F_x = F\frac{dx}{r}\\~\\
F_y = F\frac{dy}{r}

Note: Be careful with the signs! In particular, be aware that $dx$ and $dy$ are signed (positive or negative). By convention, we define the positive $x$-direction as towards the right of the screen, and the positive $y$-direction as towards the top.

Also note: While mathematically F/r * dx is the same as F*dx/r, because of roundoff error these may not be the same computationally. You should use F*dx/r in your method.

You can test them using the program in TestCalcForceExertedByXY.java.

This method returns the total/net force exerted on this body by all the bodies in the array parameter. The principle of superposition (see Physics) says that the net force acting on a CelestialBody object by many other bodies is the sum of the pairwise forces acting on the CelestialBody by each body. So you'll need to sum the forces returned by calcForceExertedByX (or Y) in calculating the value to return.

You must make sure NOT to include the force exerted by a body on itself! The universe might collapse (Infinite/NaN error) if an object attracted itself. If you loop over each element in array bodies, you'll need to check explicitly with code that looks something like the following.

You can test your code by running the program in TestCalcNetForceExertedByXY.java.

This method is a so-called mutator. It doesn't return a value, but updates the state/instance variables of the CelestialBody object on which it's called.

This method will be called during the simulation to update the body's position and velocity with small time steps (the value of the first parameter, deltaT). The values of parameter xforce and yforce are the net forces exerted on this body by all other bodies in the simulation. When code calls the update method from NBody.java, you will determine the values of the arguments passed as these two parameters by calling calcNetForceExertedByX (or Y). In the formulas below the parameter xforce is $F_x$ and yforce is $F_y$.

This update method updates the instance variables myXPos, myYPos, myXVel, and myYVel in four steps.

1. First, calculate the acceleration using Newton's second law of motion where $m$ is the mass of the CelestialBody. This creates two variables for acceleration in the $x$ and $y$ directions.

a_x = \frac{F_x}{m}\\~\\
a_y = \frac{F_y}{m}

2. You'll then calculate values for new myXVel and myYVel, we'll call these nvx and nvy where the $n$ is for new, using the relationship between acceleration and velocity, e.g., nvx = myXVel + deltaT*ax.

3. You'll use nvx (and a corresponding nvy) to calculate new values for myXPos and myYPos using the relationship between position and velocity, e.g., nx = myXPos + deltaT*nvx.

4. After you've calculated nx,ny,nvx, and nvy, you'll assign these to the instance variables myXPos, myYPos, myXVel, and myYVel, respectively.

These steps will update the position and velocity of the body making the simulation possible. You can test this method using TestUpdate.java.

This void method is described below in the section for NBody that describes where to call the CelestialBody.draw method. This method is already written, you don't need to write or edit it.

This class consists only of static methods, including the main method that runs the simulation. Your task will be to implement the three static methods that have been outlined for you in the starter code. That code has // TODO comments indicating where you need to make edits.

The data for planets, suns, and celestial bodies in general is in the format shown below. All files in the folder data are in this format. This is the file planets.txt:

The first value is an integer n, the number of bodies for which data is given in the file. The next value is a double, the radius of the universe for the simulation. This value is used to set the scale for the animation.

There are n lines, one line for each CelestialBody. Each line contains six values as shown above. The first five values are doubles: the first two are initial x and y coordinates; the next two are initial x and y velocities; the next is the mass of the CelestialBody. The last value on a line is a String specifying the file in the images folder used for the animation of the simulation.

Given a file name, this method should return a double corresponding to the radius of the universe in that file, e.g. readRadius("./data/planets.txt") should return $2.50 \cdot 10 ^{11}$ (alternatively, 2.50e+11). You'll need to read the int value that's the number of bodies, then read the double value for the radius using the Scanner already created in the starter code. Use s.nextInt() and s.nextDouble() for the Scanner variable s to read an int and double value, respectively. Your code in readRadius must read both values, but only the radius is returned. The number of bodies (first value in a data file) is ignored.

You can test your method using the provided TestReadRadius.java program.

This method returns an array of CelestialBody objects using the data read from the file. For example, readBodies("./data/planets.txt") should return an array of 5 CelestialBody objects. You will use the number of bodies (first value in data file) to create a CelestialBody [] array of the correct size to return. When created, each value in the array will be null, but you will read the values on each line and use these as parameters when you call new and create a CelestialBody object with the parameters on each line of the file.

As you iterate through the information for each of the CelestialBody objects in the file, you will find the nextInt(), nextDouble(), and next() methods in the Scanner useful in reading int, double, and String values, respectively. Note that next() returns a String.

You can test this method using the supplied TestReadBodies.java class.

You'll see four TODO comments in the loop of the main method. Completing these will make your simulation run correctly and provide an animation of the simulation. The four TODOs are:

1. Create an xForces array and yForces array. Each should have the same size as the number of bodies in the simulation.
2. Calculate the net x and y forces for each body, storing these in the xForces and yForces arrays respectively. You can use the CelestialBody methods you wrote previously to do this.
3. Call update on each body, using dt and the corresponding elements of these arrays as parameters.
4. Call draw on each body.