From 68218746d03d8e3e5e68dbe232e13aa40442366f Mon Sep 17 00:00:00 2001
From: watem <watem.main@gmail.com>
Date: Mon, 21 May 2018 18:44:01 -0400
Subject: [PATCH 1/4] Add files via upload

---
 BodyMaths.java          | 187 ++++++++++++++++
 ElectrostaticMaths.java |  30 +++
 Electrostatics.java     | 103 +++++++++
 Main.java               |  32 +++
 MainPanel.java          | 478 ++++++++++++++++++++++++++++++++++++++++
 NBody.java              | 324 +++++++++++++++++++++++++++
 NBodyGraph.java         |  45 ++++
 Object.java             |  75 +++++++
 SolarBody.java          | 236 ++++++++++++++++++++
 9 files changed, 1510 insertions(+)
 create mode 100644 BodyMaths.java
 create mode 100644 ElectrostaticMaths.java
 create mode 100644 Electrostatics.java
 create mode 100644 Main.java
 create mode 100644 MainPanel.java
 create mode 100644 NBody.java
 create mode 100644 NBodyGraph.java
 create mode 100644 Object.java
 create mode 100644 SolarBody.java

diff --git a/BodyMaths.java b/BodyMaths.java
new file mode 100644
index 0000000..8db887f
--- /dev/null
+++ b/BodyMaths.java
@@ -0,0 +1,187 @@
+/**
+* This logic class contains all of the equations for three body problems involving gravity or electrostatics.
+* This class also contains the formulae for gravitational Lagrange points.
+* @author Matthew Williams, Yulia Kosharych
+* @version 2018-05-16
+**/
+public class BodyMaths {
+
+
+  // import constants
+  public static final double G = SolarBody.G;
+
+
+  /**
+  * This method calculates the acceleration that one body causes on another due to gravity
+  * @param obj[][] double               these are the positions of the object that the acceleration is calculated on
+  * @param body[][] double              these are the positions of the body that causes the gravitional acceleration on the object
+  * @param massBody double              this is the mass of the body that causes the acceleration
+  * @param i int                        this is the current timestep
+  * @param axis int                     this is the axis that is currently being calculated (0=x, y=1)
+  * @return acceleration double         this is the value of acceleration along the selected axis
+  * @version 2018-04-25
+  **/
+  public static double gravityAccel(double obj[][], double body[][], double massBody, int i, int axis){
+    double acceleration;
+    acceleration = -G*massBody*(obj[axis][i]-body[axis][i])/Math.pow(radius(obj, body, i), 3);
+    return acceleration;
+  }//dualBodyAccel()
+
+
+
+  /**
+  * This method calculates the magnitude of a two dimensional vector
+  * @param x double         this is the x component of the vector
+  * @param y double         this is the y component of the vector
+  * @return norm double     this is the magnitude of the vector
+  * @version 2018-04-25
+  **/
+  public static double norm(double x, double y) {
+    double norm = Math.sqrt(x*x+y*y);
+    return norm;
+  }//norm()
+
+  /**
+  * This method calculates the distance between two bodies at a specific timestep
+  * @param body1[][] double       these are the positions of first body
+  * @param body2[][] double       these are the positions of second body
+  * @param i int                  this is the current timestep
+  * @return norm                  this is the magnitude of the distance between the two bodies
+  * @version 2018-04-25
+  **/
+  public static double radius(double body1[][], double body2[][], int i) {
+    double x = body1[0][i] - body2[0][i];
+    double y = body1[1][i] - body2[1][i];
+    return norm(x, y);
+  }//radius()
+
+  /**
+  * This method updates the velcity and positions for a timestep based on the acceleration
+  * @param obj[][][] double       these are the position, velocity, acceleration vectors for a body
+  * @param dt double              this is the timestep length
+  * @param i int                  this is the current timestep
+  * @version 2018-05-16
+  **/
+  public static void updateBody(double obj[][][], double dt, int i){
+    // velocity = vI + a*dt
+    obj[1][0][0]+=obj[2][0][i]*dt;
+    obj[1][1][0]+=obj[2][1][i]*dt;
+    // position = xI + v*dt
+    obj[0][0][i]=obj[0][0][i-1]+obj[1][0][0]*dt;
+    obj[0][1][i]=obj[0][1][i-1]+obj[1][1][0]*dt;
+  }//updateBody()
+
+
+
+  // Lagrange points
+  /**
+  * These methods give the distances to the legrange points. m1>m2
+  *
+  * @param distance double    this is the distance between the major bodies
+  * @param m1       double    this is the mass of the body that is much larger than m2
+  * @param m2       double    this is the mass of the body that is much smaller than m1
+  *
+  * @return r       double    for L1 this is the distance from the smaller object towards the larger object
+  *                           for L2 this is the distance from the smaller object away from the larger object
+  *                           for L3 this is the distance from the larger object away from the smaller object
+  * @version 2018-05-08
+  **/
+  public static double L1(double distance, double m1, double m2){
+    double r = Math.abs(distance)*Math.pow(m2/(3*m1), 1./3.);
+    return r;
+  }//L1()
+  public static double L2(double distance, double m1, double m2){
+    double r = distance*Math.pow(m2/(3*m1), 1./3.);
+    return r;
+  }//L2()
+  public static double L3(double distance, double m1, double m2){
+    double r = 7./12.*distance*m2/m1;
+    return r;
+  }//L3()
+
+
+
+  /**
+  * This method calculates the required orbital velocity for a circular orbit
+  * @param massBig double       this is the mass of the driving body
+  * @param dis double           this is the starting distance between the two bodies
+  * @return velocity double     this is velocity required for a circular orbit
+  * @version 2018-05-16
+  **/
+  public static double circleVelocityG(double massBig, double dis){
+    double velocity = Math.sqrt(G*massBig/dis);
+    return velocity;
+  }//circleVelocityG()
+
+  /**
+  * This method calculates the the angularVelocity of a body in circular gravitational motion
+  * @param massBig double       this is the mass of the driving body
+  * @param dis double           this is the distance between the two bodies
+  * @return omega double        this is the angular velocity of the body
+  * @version 2018-05-16
+  **/
+  public static double angularVelocity(double massBig, double dis){
+    double omega = circleVelocityG(massBig, dis)/dis;
+    return omega;
+  }//angularVelocity()
+
+  /**
+  * This method calculates the orbital period of two bodies in circular gravitational motion
+  * @param massBig double       this is the mass of the driving body
+  * @param dis double           this is the distance between the two bodies
+  * @return time double         this is the orbital period in hours
+  * @version 2018-05-16
+  **/
+  public static double orbitalPeriod(double massBig, double dis){
+    double time = 2*Math.PI/angularVelocity(massBig, dis);
+    return time;
+  }//orbitalPeriod()
+
+
+  /**
+  * This method converts the positions from cartesian to polar coordinates in order to make the plot relative to one body
+  * @param body[][][][] double    these are the position, velocity, acceleration vectors for a body
+  * @param inertiaNum int         this is the body number to use for the reference
+  * @version 2018-05-18
+  **/
+  public static void inertialReference(double body[][][][], int inertiaNum){
+    int bodies = body.length;
+    int imax = body[0][0][0].length;
+    double bodyTheta[][] = new double[bodies][imax];
+    double radial[][] = new double[bodies][imax];
+    for (int i=0;i<bodyTheta[0].length;i++) {
+      if (body[inertiaNum][0][0][i]==0) {
+        bodyTheta[inertiaNum][i]=Math.PI/2;
+      }
+      else {
+        bodyTheta[inertiaNum][i]=Math.atan(body[inertiaNum][0][1][i]/body[inertiaNum][0][0][i]);
+      }
+      if (body[inertiaNum][0][0][i]<0) {
+        bodyTheta[inertiaNum][i]+=Math.PI;
+      }
+      radial[inertiaNum][i]=BodyMaths.norm(body[inertiaNum][0][1][i],body[inertiaNum][0][0][i]);
+      body[inertiaNum][0][0][i]=radial[inertiaNum][i];
+      body[inertiaNum][0][1][i]=0;
+    }
+    for (int bodynum=1;bodynum<bodyTheta.length;bodynum++) {
+      if (bodynum!=inertiaNum) {
+        for (int i=0;i<bodyTheta[0].length;i++) {
+          if (body[bodynum][0][0][i]==0) {
+            bodyTheta[bodynum][i]=Math.PI/2;
+          }
+          else {
+            bodyTheta[bodynum][i]=Math.atan(body[bodynum][0][1][i]/body[bodynum][0][0][i]);
+          }
+          if (body[bodynum][0][0][i]<0) {
+            bodyTheta[bodynum][i]+=Math.PI;
+          }
+          bodyTheta[bodynum][i]-=bodyTheta[inertiaNum][i];
+          radial[bodynum][i]=BodyMaths.norm(body[bodynum][0][1][i],body[bodynum][0][0][i]);
+          body[bodynum][0][0][i]=radial[bodynum][i]*Math.cos(bodyTheta[bodynum][i]);
+          body[bodynum][0][1][i]=radial[bodynum][i]*Math.sin(bodyTheta[bodynum][i]);
+        }
+      }
+    }
+  }//inertialReference()
+
+}//class
diff --git a/ElectrostaticMaths.java b/ElectrostaticMaths.java
new file mode 100644
index 0000000..d0a753f
--- /dev/null
+++ b/ElectrostaticMaths.java
@@ -0,0 +1,30 @@
+/**
+* This logic class contains all of the equations for three body problems involving electrostatics.
+* has BodyMaths.java as a dependency
+* @author Matthew Williams, Yulia Kosharych
+* @version 2018-05-16
+**/
+public class BodyMaths {
+
+  // import constants
+  public static final double Ke = Electrostatics.Ke;
+
+  /**
+  * This method calculates the acceleration that one body causes on another due to electrostatic forces
+  * @param obj[][] double               these are the positions of the object that the acceleration is calculated on
+  * @param body[][] double              these are the positions of the body that causes the electrostatic forces on the object
+  * @param qObj double                  this is the charge of the object that is acted apon
+  * @param qBody double                 this is the charge of the other body
+  * @param massObj double               this is the mass of the object whose acceleration is calculated
+  * @param i int                        this is the current timestep
+  * @param axis int                     this is the axis that is currently being calculated (0=x, y=1)
+  * @return acceleration double         this is the value of acceleration along the selected axis
+  * @version 2018-04-30
+  **/
+  public static double electrostaticAccel(double obj[][], double body[][], double qObj, double qBody, double massObj, int i, int axis){
+    double acceleration;
+    acceleration = Ke*qObj*qBody*(obj[axis][i]-body[axis][i])/Math.pow(Bodymaths.radius(obj, body, i), 3)/massObj;
+    return acceleration;
+  }//electrostaticAccel()
+}
+   
diff --git a/Electrostatics.java b/Electrostatics.java
new file mode 100644
index 0000000..041eb65
--- /dev/null
+++ b/Electrostatics.java
@@ -0,0 +1,103 @@
+import java.util.Scanner;
+/**
+* This class contains premade values and situations for electrostatic objects.
+* more methods to easily add premades can easily be created.
+* @author Matthew Williams, Yulia Kosharych
+* @version 2018-05-16
+**/
+public class Electrostatics{
+  public static final double Ke = 8.9875*Math.pow(10, 9);//N*m^2/C^2
+
+  public String name;
+  public double mass;
+  public double charge;
+  public double radius;
+  public double centreDis;
+  public double vInitial;
+  public double theta;
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+
+  public Electrostatics(String name, double mass, double charge, double centreDis, double vInitial, double radius, double theta){
+    this.name=name;
+    this.mass=mass;
+    this.charge=charge;
+    this.centreDis=centreDis;
+    this.vInitial=vInitial;
+    this.radius=radius;
+    this.theta=theta;
+  }
+
+  public Electrostatics(String name){
+    this.name=name;
+    this.mass=-1;
+    setCharge();
+    this.centreDis=-1;
+    setVelocity();
+    this.radius=-1;
+    setTheta();
+  }//input constructor
+  public Electrostatics(double mass, double charge, double centreDis, double vInitial, double rad, String name){
+    this.name=name;
+    this.mass=mass;
+    this.charge=charge;
+    this.centreDis=centreDis;
+    this.vInitial=vInitial;
+    this.radius=rad;
+    setTheta();
+  }
+  public Electrostatics(double mass, double charge, double centreDis, String name, double rad, double theta){
+    this.name=name;
+    this.mass=mass;
+    this.charge=charge;
+    this.centreDis=centreDis;
+    setVelocity();
+    this.radius=rad;
+    this.theta=theta;
+  }//select a velocity constructor
+  public Electrostatics(String name, double mass, double charge, double centreDis, double rad){
+    this.name=name;
+    this.mass=mass;
+    this.charge=charge;
+    this.centreDis=centreDis;
+    setVelocity();
+    this.radius=rad;
+    setTheta();
+  }//select theta and velocity constructor
+
+
+
+
+
+
+
+  public void setPath(){
+    this.mass=0;
+    this.name=this.name+"'s path";
+  }
+  public void setTheta(){
+    Scanner kb = new Scanner(System.in);
+    System.out.println("desired theta for "+this.name+" in pi radians");
+    this.theta=kb.nextDouble()*Math.PI;
+  }
+  public void setVelocity(){
+    Scanner kb = new Scanner(System.in);
+    System.out.println("desired initial velocity for "+this.name+" in km/h");
+    double vInit = kb.nextDouble();
+    System.out.print("times 10^");
+    double power = Math.pow(10, kb.nextDouble());
+    this.vInitial=vInit*power;
+    System.out.println("initial velcity = "+this.vInitial);
+  }
+  public void setCharge(){
+    Scanner kb = new Scanner(System.in);
+    System.out.println("desired total charge for "+this.name+" in C");
+    double vInit = kb.nextDouble();
+    System.out.print("times 10^");
+    double power = Math.pow(10, kb.nextDouble());
+    this.vInitial=vInit*power;
+    System.out.println("charge = "+this.vInitial);
+  }
+
+
+}
diff --git a/Main.java b/Main.java
new file mode 100644
index 0000000..4369b66
--- /dev/null
+++ b/Main.java
@@ -0,0 +1,32 @@
+import java.awt.Dimension;
+import java.awt.Toolkit;
+
+import javax.swing.JFrame;
+
+public class Main {
+
+	static Dimension screenDim = Toolkit.getDefaultToolkit().getScreenSize();
+	static Dimension dim = new Dimension(1200,800);
+	static Dimension dim2 = new Dimension(1000,800);
+	static Dimension dim3 = new Dimension(800,600);
+	
+	static Dimension frameDim = screenDim;
+	
+	
+	
+	public static void main(String[] args) {
+		// TODO Auto-generated method stub
+
+		
+		JFrame win = new JFrame("Realtime: Drawing of a Solar System [IN PROGRESS]");
+		
+		MainPanel mainPanel = new MainPanel();
+		
+		win.setSize(frameDim);
+		win.setLocationRelativeTo(null);
+		win.setContentPane(mainPanel);
+		win.setVisible(true);
+		
+	}
+
+}
diff --git a/MainPanel.java b/MainPanel.java
new file mode 100644
index 0000000..5ad2a02
--- /dev/null
+++ b/MainPanel.java
@@ -0,0 +1,478 @@
+import java.awt.BasicStroke;
+import java.awt.Color;
+import java.awt.Dimension;
+import java.awt.Graphics;
+import java.awt.Graphics2D;
+import java.awt.geom.Ellipse2D;
+import java.util.Arrays;
+import java.util.Scanner;
+import javax.swing.JPanel;
+
+
+
+public class MainPanel extends JPanel{
+
+	public static double scaling =350;
+
+	public static Dimension MainPanelDim = Main.frameDim;
+
+	Object sun;
+	Object sat;
+	Object earth;
+
+	public static final double x0 = MainPanelDim.getWidth()/2;
+	public static final double y0 = MainPanelDim.getHeight()/2;
+
+	final double sunR = 75;
+	final double satR = 35;
+	final double earthR = 35;
+
+	Color sunColor;
+	Color satColor;
+	Color earthColor;
+
+	double t = 0;
+
+	public static final double G = SolarBody.G;//gravitational constant (km^3/kg/h^2)
+	public static final double dt = 1.0; //delta t in hours
+	public static final double tmax = BodyMaths.orbitalPeriod(SolarBody.massSol, SolarBody.solDisEarth) ; //number of hours to run (1 year)
+	public static double time = 0; //initial time
+	public static final boolean graphing = true;
+	public static final double au = SolarBody.au;//initial distance of earth from the sun in km
+
+
+	public static final double massEarth=SolarBody.massEarth; //kg
+	public static final double velocityEarth = SolarBody.vEarth;// initial velocity of Earth
+
+	public static final double massJupiter =SolarBody.massJupiter;//kg
+	public static final double velocityJupiter = SolarBody.vJupiter;//velocity jupiter
+
+
+	public static final double massL5 = SolarBody.SE_L5; //kg
+
+	public static final double massSun=SolarBody.massSun;  //kg
+	public static double massSat; //kg
+
+	public static Scanner kb = new Scanner(System.in);
+	public static double [][][] object = new double[3][3][2];
+	public static double [] maxAccel, minPosSun, minPosEarth;
+
+	public static double massPlanet; //mass of the planet
+
+
+
+
+	double satX, satY, velInitialX, velInitialY;
+	double planetX, planetY, velInitialPlanetX, velInitialPlanetY;
+
+
+	public void initSunEarthLuna()
+	{
+		 scaling = 350;
+			//Sat Conditions
+		  massSat = SolarBody.massLuna;
+		  satX = SolarBody.solDisLuna;
+		  satY = 0;
+		  velInitialX = 0;
+		  velInitialY = SolarBody.vLuna;
+
+		  	//Earth Condition
+		  massPlanet = massEarth;
+		  planetX = au;
+		  planetY = 0;
+			velInitialPlanetX = 0;
+			velInitialPlanetY = velocityEarth;
+
+	}
+
+
+	public void initSunEarthL5()
+	{
+		 scaling = 350;
+			//Sat Conditions
+		  massSat = massL5;
+		  satX = au*Math.cos(-Math.PI/3);
+		  satY = au*Math.sin(-Math.PI/3);
+		  velInitialX = -velocityEarth*Math.sin(theta[0]);
+		  velInitialY = velocityEarth*Math.cos(theta[0]);
+
+		  	//Planet Condition
+		  massPlanet = massEarth;
+		  planetX = au;
+		  planetY = 0;
+		  velInitialPlanetX = 0;
+		  velInitialPlanetY =velocityEarth;
+
+	}
+
+	public void initSunJupiterProbe()
+	{
+		 scaling =75;
+			//Sat Conditions
+		 System.out.println("Please enter the mass of the satellite:");
+		  massSat = kb.nextDouble();
+
+		  System.out.println("Please enter the x position of the satellite:");
+		  satX = kb.nextDouble();
+		  System.out.println("Please enter the y position of the satellite:");
+		  satY = kb.nextDouble();
+		  System.out.println("Please enter the initial  x component of the velocity of satellite");
+		  velInitialX = kb.nextDouble();
+		  System.out.println("Please enter the initial  y component of the velocity of satellite");
+		  velInitialY = kb.nextDouble();
+
+		  	//Jupiter Condition
+		  massPlanet=massJupiter;
+		  planetX =SolarBody.solDisJupiter;
+		  planetY = 0;
+		  velInitialPlanetX = 0;
+		  velInitialPlanetY = velocityJupiter;
+
+
+	}
+
+
+	public void Algorithm()
+	{
+		  //Earth
+		  object[0][0][0] = planetX;
+		  object[0][0][1] = planetY;
+
+		  object[0][1][0] = velInitialPlanetX;
+		  object[0][1][1] = velInitialPlanetY;
+
+		  object[0][2][0] = 0;
+		  object[0][2][1] = 0;
+
+		  //Sun
+		  object[1][0][0] = 0;
+		  object[1][0][1] = 0;
+
+		  object[1][1][0] = 0;
+		  object[1][1][1] = 0;
+
+		  object[1][2][0] = 0;
+		  object[1][2][1] = 0;
+
+		  //Sat
+		  object[2][0][0] = satX;
+		  object[2][0][1] = satY;
+
+		  object[2][1][0] = velInitialX;
+		  object[2][1][1] = velInitialY;
+
+		  object[2][2][0] = 0;
+		  object[2][2][1] = 0;
+
+
+	}
+
+	public MainPanel()
+	{
+
+
+		this.setSize(Main.dim2);
+		int sim;
+		System.out.println("Please enter the simulation number: ");
+		sim = kb.nextInt();
+
+		if(sim == 1) initSunEarthLuna();
+
+		if (sim == 2) initSunEarthL5();
+
+		if (sim == 3) initSunJupiterProbe();
+
+
+
+		Algorithm();
+
+
+
+		sunColor = new Color(255, 172, 0);
+		sun = new Object(object[1][0][0] + x0, object[1][0][1] +  y0, sunR);
+
+		satColor = new Color(211,211,211);
+		sat = new Object((scaling*object[2][0][0]/au) + x0, (275*object[2][0][1]/au) +  y0, satR);
+
+		earthColor = new Color(47,94,79);
+		earth = new Object((scaling*object[0][0][0]/au) + x0, (275*object[0][0][1]/au) +  y0, earthR);
+
+
+
+		  maxAccel = object[2][2];
+
+		  minPosSun = differencePos(object[2][0],object[1][0]);
+		  minPosEarth = differencePos(object[2][0],object[0][0]);
+
+	}
+
+
+	public double[] ellipticalOrbit(double[] initPos,double t,double radius, double speed, double kx, double ky)	{
+
+
+		double[] posVec = new double[2];
+
+
+
+		posVec[0] = kx*radius*Math.sin((speed*t)/70) + initPos[0];
+		posVec[1] = ky*radius*Math.cos((speed*t)/70) + initPos[1];
+
+
+		return posVec;
+
+	}
+
+	public void update()
+	{
+
+		  object[0][2] = accelSunAnyObj(massSun,object[0][0],object[1][0]);
+		  object[1][2] = accelSunAnyObj(massPlanet,object[1][0],object[0][0]);
+		  object[2][2] = accelSunAnyObj(massSun,object[2][0], object[1][0]);
+
+		  object[1][2] = add(object[1][2], accelSunAnyObj(massSat,object[1][0], object[2][0]));
+		  object[0][2] = add(object[0][2], accelSunAnyObj(massSat,object[0][0],object[2][0]));
+		  object[2][2] = add(object[2][2], accelSunAnyObj(massPlanet, object[2][0],object[0][0]));
+
+
+		  object[0][1] = add((mult(object[0][2])), object[0][1]);
+		  object[1][1] = add((mult(object[1][2])), object[1][1]);
+		  object[2][1] = add((mult(object[2][2])), object[2][1]);
+
+
+		  object[0][0] = add((mult(object[0][1])), object[0][0]);
+		  object[1][0] = add((mult(object[1][1])), object[1][0]);
+		  object[2][0] = add((mult(object[2][1])), object[2][0]);
+
+
+	}
+
+
+
+	public void paintChildren(Graphics g)
+	{
+
+		super.paintChildren(g);
+
+
+		  maxAccel = compareAccel(maxAccel,object[2][2]);
+		  // findMinDis(); //sun
+		minPosSun = comparePosition(minPosSun, differencePos(object[2][0],object[1][0]));
+
+		// findMinDis(); //earth
+		minPosEarth = comparePosition(minPosEarth, differencePos(object[2][0],object[0][0]));
+
+
+		Graphics2D g2 = (Graphics2D) g;
+
+		g2.setColor(Color.BLACK);
+		g2.fillRect(0, 0, MainPanelDim.width, MainPanelDim.height);
+
+
+
+
+		//Drawing Sun
+		sun.updateCelestialObj(object[1][0]);
+		sun.paintObj(g2, sunColor);
+
+
+		//Drawing Planet
+		earth.updateCelestialObj(object[0][0]);
+		earth.paintObj(g2, earthColor);
+
+
+
+
+		//Drawing Sat
+		sat.updateCelestialObj(object[2][0]);
+		sat.paintObj(g2, satColor);
+
+		update();
+
+		//adjust for DELAY
+
+
+		//Display Time
+
+		g2.setColor(Color.RED);
+		time += dt;
+
+		g2.setStroke(new BasicStroke(3));
+		g2.drawString("Number of hours : " + Double.toString(time), 10, 12);
+		g2.drawString("Number of years : " + Double.toString(time/8760), 10, 29);
+
+		//Acceleration Vectors
+
+		g2.drawLine((int) ((scaling*object[1][0][0]/au) + x0),(int) ((scaling*object[1][0][1]/au) + y0),  (int)(((scaling*object[1][0][0]/au) + x0 ) + (0.7*sunR)*getUnit(object[1][2], getMag(object[1][2]))[0]), (int)(((scaling*object[1][0][1]/au) + y0 ) + (0.7*sunR)*getUnit(object[1][2], getMag(object[1][2]))[1]));
+
+		g2.drawLine((int) ((scaling*object[0][0][0]/au) + x0),(int) ((scaling*object[0][0][1]/au) + y0 ),  (int)(((scaling*object[0][0][0]/au) + x0 ) + (0.7*earthR)*getUnit(object[0][2], getMag(object[0][2]))[0]), (int)(((scaling*object[0][0][1]/au) + y0 ) + (0.7*earthR)*getUnit(object[0][2], getMag(object[0][2]))[1]));
+
+		g2.drawLine((int) ((scaling*object[2][0][0]/au) + x0),(int) ((scaling*object[2][0][1]/au) + y0 ),  (int)(((scaling*object[2][0][0]/au) + x0 ) + (0.7*satR)*getUnit(object[2][2], getMag(object[2][2]))[0]), (int)(((scaling*object[2][0][1]/au) + y0 ) + (0.7*satR)*getUnit(object[2][2], getMag(object[2][2]))[1]));
+
+
+		repaint();
+
+
+		if(time==tmax) {
+			System.out.println("The maximim acceleration is: " +getMag(maxAccel));
+			System.out.println("The minimum position of the satellite to the planet is: "+getMag(minPosEarth));
+			System.out.println("The minimum position of the satellite to the Sun is: "+getMag(minPosSun));
+			System.exit(0);
+
+		}
+
+
+	}
+
+
+	//YuliaMethods
+
+public static double [] mult(double [] array) {
+
+	for(int i =0; i<array.length;i++) {
+
+		array[i] = array[i]*dt;
+	}
+
+
+	return array;
+
+
+}public static double [] add(double [] array1, double [] array2) {
+
+
+	double [] add = new double [array1.length];
+
+	for(int i = 0; i < array1.length; i++)
+	{
+		add[i] = array1[i] + array2[i];
+
+
+	}
+
+	return add;
+
+}
+public static double [] differencePos(double[] pos1, double [] pos2){
+
+			double [] result = new double[2];
+			for(int i =0; i<pos1.length;i++) {
+
+				result[i] = pos1[i]-pos2[i];
+
+
+			}
+			return result;
+
+		}
+public static double [] getR(double [] objPos1, double [] objPos2) {
+
+	double [] rVector = new double [2];
+
+	rVector[0]= objPos2[0] - objPos1[0];
+	rVector[1]= objPos2[1] - objPos1[1];
+
+	return rVector;
+	}
+public static double getMag(double [] rVector) {
+
+	double rMagnitude;
+	rMagnitude = Math.sqrt(Math.pow(rVector[0],2) + Math.pow(rVector[1], 2));
+	return rMagnitude;
+}
+public static double [] getUnit(double [] rVector, double rMagnitude ) {
+
+	double [] unit = new double[2];
+
+	unit[0] = rVector[0]/rMagnitude;
+	unit[1] = rVector[1]/rMagnitude;
+
+return unit;
+}
+public static double [] accelSunAnyObj( double mPullObj,double [] objPos1, double [] objPos2) {
+
+double rMagnitude;
+double [] rVector = new double [2];
+double [] unit = new double [2];
+double [] accelVector = new double [2];
+double accelMagnitude;
+
+rVector = getR(objPos1,objPos2);
+rMagnitude = getMag(rVector);
+unit = getUnit(rVector,rMagnitude);
+
+accelMagnitude= (G*mPullObj)/ Math.pow(rMagnitude, 2);
+accelVector[0] = accelMagnitude * unit[0];
+accelVector[1] = accelMagnitude * unit[1];
+
+  return accelVector;
+}
+public static double [] compareAccel(double [] accelInitial, double [] accelFinal) {
+
+	double accelMagIn = getMag(accelInitial);
+	double accelMagFin = getMag(accelFinal);
+
+
+
+	if (accelMagIn < accelMagFin) {
+
+		return accelFinal;
+
+	}else {
+
+		return accelInitial;
+	}
+
+
+}
+public static double [] updateVel(double [] velInitial, double [] accel) {
+
+
+	velInitial[0] = accel[0] *dt + velInitial[0];
+	velInitial[1] = accel[1] *dt + velInitial[1];
+
+
+	return velInitial;
+}
+public static double [] updatePos(double [] posInitial, double [] vel) {
+
+
+	posInitial[0] = vel[0] * dt + posInitial[0];
+	posInitial[1] = vel[1] * dt + posInitial[1];
+
+	return posInitial;
+
+}
+public static double[] comparePosition(double[] posInitial, double[] posFinal) {
+
+	double magPosIn = getMag(posInitial);
+	double magPosFin = getMag(posFinal);
+
+
+	if (magPosIn > magPosFin ) {
+
+		return posFinal;
+
+	}else {
+
+		return posInitial;
+	}
+
+}
+public static double compareVelocity(double[] velInitial, double[] velFinal) {
+
+	double magVelIn = getMag(velInitial);
+	double magVelFin = getMag(velFinal);
+
+
+	if (magVelIn < magVelFin ) {
+
+		return magVelFin;
+
+	}else {
+
+		return magVelIn;
+	}
+
+}
+
+}
diff --git a/NBody.java b/NBody.java
new file mode 100644
index 0000000..fdd22ce
--- /dev/null
+++ b/NBody.java
@@ -0,0 +1,324 @@
+import java.io.*;
+import java.awt.*;
+import javax.swing.*;
+import java.util.Scanner;
+
+/**
+* This is the driving class for the N body solution for the problem using the Euler computational analysis method.
+* not to be confused with the Euler general solution for 3 body problems involving two fixed bodies.
+* @author Matthew Williams, Yulia Kosharych
+* @version 2018-05-16
+**/
+public class NBody{
+  //presets
+  public static SolarBody body0 = SolarBody.Sol;
+  public static SolarBody body1 = SolarBody.Earth;
+  // public static SolarBody body1 = SolarBody.Jupiter;
+  // public static SolarBody body2 = new SolarBody("satellite", 100, SolarBody.au/7, SolarBody.vJupiter, 0.001, 3*Math.PI/2);
+  public static SolarBody body2 = SolarBody.PlanetX;
+  // public static SolarBody body2 = SolarBody.Horseshoe;
+  // public static SolarBody body2 = SolarBody.Luna;
+
+  // public static double dis = SolarBody.solDisJupiter+Math.pow(10, 5);
+  // public static SolarBody body2 = new SolarBody("Tadpole orbit", 10, dis, BodyMaths.circleVelocityG(body0.mass, dis), 0, -Math.PI/6);
+  // public static SolarBody body2 = SolarBody.IrregularTadpole;
+
+  // public static SolarBody body3 = new SolarBody("probe", -1, -1, SolarBody.vEarth, 0, 0);
+  public static SolarBody body3 = SolarBody.Jupiter;
+
+
+  // if set to true, it shows the path the body without exerting any gravity on other bodies
+  public static boolean setPath0 = false;
+  public static boolean setPath1 = false;
+  public static boolean setPath2 = false;
+  public static boolean setPath3 = false;
+  // useful to compare the affects of gravity on another object
+
+
+  public static final double dt = 1.;                            //delta t in hours
+  // public static final double tmax = 8765.82*5*3.54;                  //number of hours to run
+  public static final double tmax =0.1*BodyMaths.orbitalPeriod(body0.mass, body1.solDis); //number of "years" to run (in hours)
+  public static final int imax =(int) (tmax/dt);                   //number of time steps
+  // number of bodies to use
+  public static final int bodies = 3;
+
+  public static final double G = SolarBody.G;
+
+
+  // toggle outputs
+
+  public static final double timeStart = 6*BodyMaths.orbitalPeriod(body0.mass, body1.solDis);
+  public static final double timeEnd = 7*BodyMaths.orbitalPeriod(body0.mass, body1.solDis);;;
+  public static final boolean partial = false;
+
+
+  public static final boolean graphing = false;  //plots locations
+  public static final boolean print = false;    //prints all steps in calculations. not recommended.
+  public static final boolean verbose = true;   //provides details as to what the program is doing
+
+  public static final boolean inertialPlot = true;
+  public static final int inertiaNum = 1;          //which body the inertial frame is in reference to
+
+
+
+
+  public static void main(String[] args) {
+    final int maxJavaHeap = 55855815; //max number of points that java can handle
+    int nPoints=bodies*3*2*imax+bodies*5;
+    // System.out.println(nPoints);
+    if (nPoints>maxJavaHeap) {
+      System.out.println("WARNING. Datapoints exceed maximum acceptable number of points within java (trying to use "+nPoints+" with a maximum of "+maxJavaHeap+" points)\nConsider either lowering accuracy or lowering the max time of simulation");
+      // System.exit(0);
+    }
+    // body2.setName("Tadpole");
+    // body2.setDisAU();
+    // body2.addDis();
+    // body2.addVel();
+
+
+
+
+
+    if (setPath0) {
+      body0.setPath();
+    }
+    if (setPath1) {
+      body1.setPath();
+    }
+    if (setPath2) {
+      body2.setPath();
+    }
+    if (setPath3) {
+      body3.setPath();
+    }
+
+    Scanner kb = new Scanner(System.in);
+    double[] mass = new double[bodies];
+    double[][][][] body= new double[bodies][3][2][imax];//[body][pos][x/y][timestep]
+    String bodyName[] = new String[bodies];
+    double vInit[] = new double[bodies];
+    double radius[] = new double[bodies];
+    double theta[] = new double[bodies];
+    double distance;
+
+
+    for (int i =0;i<body.length;i++) {
+      body[i][1]=new double[2][1];
+    }
+    // System.out.println("multiple of vEarth");
+    // double n = kb.nextDouble();
+    // double l = 1;
+    // kb.nextDouble();
+    // for (;l<10;l+=0.1) {//long for(;;) loop
+    // SolarBody body2 = SolarBody.other("satellite", 100, SolarBody.au/7, SolarBody.vEarth*3.694, 0.001, (5+l/10)*Math.PI/4);
+
+    if (verbose) {
+    System.out.println("\nstarting input phase");
+    System.out.print("inputting names...");
+    }
+    // names
+    bodyName[0]=body0.name;
+    bodyName[1]=body1.name;
+    if (bodyName.length>2) {
+      bodyName[2]=body2.name;
+    }
+    if (bodyName.length>3) {
+      bodyName[3]=body3.name;
+    }
+    for (int i = 4;i<bodyName.length;i++) {
+      bodyName[i]="body "+(i+1);
+    }
+    if (verbose) {
+      System.out.print("done\ninputting mass...");
+    }
+    // masses
+    mass[0]=body0.mass;
+    mass[1]=body1.mass;
+    if (mass.length>2) {
+      mass[2]=body2.mass;
+    }
+    if (mass.length>3) {
+      mass[3]=body3.mass;
+    }
+    for (int i=4;i<mass.length;i++) {
+      mass[i] = -1;
+    }
+    for (int i=0;i<mass.length;i++) {
+      if (mass[i]<0) {
+        System.out.print("\nMass #"+i+":");
+        mass[i] = kb.nextDouble();
+      }
+    }
+    if (verbose) {
+      System.out.print("done\ninputting angles...");
+    }
+    // thetas
+    theta[0]=body0.theta;
+    theta[1]=body1.theta;
+    if (theta.length>2) {
+      theta[2]=body2.theta;
+    }
+    if (theta.length>3) {
+      theta[3]=body3.theta;
+    }
+    for (int i=4;i<theta.length;i++) {
+      System.out.print("\nTheta #"+i+":");
+      theta[i] = kb.nextDouble();
+    }
+    while (body0.solDis<0){
+      System.out.println("distance from centre for "+body0.name);
+      body0.solDis = kb.nextDouble();
+    }
+    while (body1.solDis<0) {
+      System.out.println("distance from centre for "+body1.name);
+      body1.solDis = kb.nextDouble();
+    }
+    if (verbose) {
+      System.out.print("done\ninputting initial positions...");
+    }
+    // initial position
+    body[0][0][0][0]=body0.solDis*Math.cos(theta[0]); //body 1 x
+    body[0][0][1][0]=body0.solDis*Math.sin(theta[0]); //body 1 y
+    body[1][0][0][0]=body1.solDis*Math.cos(theta[1]); //body 2 x
+    body[1][0][1][0]=body1.solDis*Math.sin(theta[1]); //body 2 y
+    if (body.length>2){
+      while (body2.solDis<0) {
+        System.out.println("distance from centre for "+body2.name);
+        body2.solDis = kb.nextDouble();
+      }
+      body[2][0][0][0]=body2.solDis*Math.cos(theta[2]);
+      body[2][0][1][0]=body2.solDis*Math.sin(theta[2]);
+    }
+    if (body.length>3){
+      while (body3.solDis<0) {
+        System.out.println("distance from centre for "+body3.name);
+        body3.solDis = kb.nextDouble();
+      }
+      body[3][0][0][0]=body3.solDis*Math.cos(theta[3]);
+      body[3][0][1][0]=body3.solDis*Math.sin(theta[3]);
+    }
+    for (int i = 4;i<body.length;i++) {
+      System.out.println("distance from centre");
+      distance = kb.nextDouble();
+      body[i][0][0][0]=distance*Math.cos(theta[i]);
+      body[i][0][1][0]=distance*Math.sin(theta[i]);
+    }
+    if (verbose) {
+      System.out.print("done\ninputting initial velocities...");
+    }
+    // while (body0.vInitial<0) {
+    //   System.out.println("initial velocity for "+body0.name);
+      // body0.vInitial = kb.nextDouble();
+    // }
+    body[0][1][0][0]=-body0.vInitial*Math.sin(theta[0]);
+    body[0][1][1][0]=body0.vInitial*Math.cos(theta[0]);
+
+    // while (body1.vInitial<0) {
+    //   System.out.println("initial velocity for "+body1.name);
+    //   body1.vInitial = kb.nextDouble();
+    // }
+    body[1][1][0][0]=-body1.vInitial*Math.sin(theta[1]);
+    body[1][1][1][0]=body1.vInitial*Math.cos(theta[1]);
+    if (body.length>2){
+      // while (body2.vInitial<0) {
+      //   System.out.println("initial velocity for "+body2.name);
+      //   body2.vInitial = kb.nextDouble();
+      // }
+      body[2][1][0][0]=-body2.vInitial*Math.sin(theta[2]);
+      body[2][1][1][0]=body2.vInitial*Math.cos(theta[2]);
+    }
+    if (body.length>3){
+      // while (body3.vInitial<0) {
+      //   System.out.println("initial velocity for "+body3.name);
+      //   body3.vInitial = kb.nextDouble();
+      // }
+      body[3][1][0][0]=-body3.vInitial*Math.sin(theta[3]);
+      body[3][1][1][0]=body3.vInitial*Math.cos(theta[3]);
+    }
+    for (int i = 4;i<body.length;i++) {
+      System.out.println("initial velocity");
+      distance = kb.nextDouble();
+      body[i][1][0][0]=-distance*Math.sin(theta[i]);
+      body[i][1][1][0]=distance*Math.cos(theta[i]);
+    }
+
+    vInit = null;
+    theta = null;
+    if (verbose) {
+      System.out.print("done\nFinished input\n");
+    }
+
+
+
+
+    if (verbose) {
+      System.out.println("\nStarting calculation...");
+    }
+    for (int t=1;t<imax;t++) {
+      for (int num=0;num<bodies;num++) {
+        for (int j=0;j<bodies;j++) {
+          // System.out.println("J:"+j+" num:"+num);
+          if (j!=num) {
+            // System.out.println("update accel x");
+            body[num][2][0][t]+=BodyMaths.gravityAccel(body[num][0], body[j][0], mass[j], t-1, 0);
+            // System.out.println("update accel y");
+            body[num][2][1][t]+=BodyMaths.gravityAccel(body[num][0], body[j][0], mass[j], t-1, 1);
+          }
+          else if (print) {
+           System.out.println("j=num");
+          }
+        }
+        BodyMaths.updateBody(body[num], dt, t);
+        if (print) {
+          System.out.println("body"+ (num+1) +" x,y");
+          System.out.println(body[num][0][0][t]+","+body[num][0][1][t]);
+        }
+      }
+    }
+    if (verbose) {
+      System.out.println("calculation complete");
+    }
+
+    if (partial) {
+      int partialLength = (int)((timeEnd-timeStart)/dt);
+      double partialBody[] = new double[partialLength];
+      for (int bodynum=0;bodynum<body.length;bodynum++) {
+        for (int axis=0;axis<2;axis++) {
+          for (int i=0,j=(int)(timeStart/dt);i<partialBody.length&&j<body[bodynum][0][1].length;i++,j++) {
+            partialBody[i]=body[bodynum][0][axis][j];
+          }
+          body[bodynum][0][axis]=partialBody;
+        }
+      }
+      partialBody = null;
+    }//partialLength
+
+    if (graphing) {
+      if (verbose) {
+        System.out.println("starting graph");
+      }
+      NBodyGraph.graphNBody(bodyName, body, "cartesian plot");
+      if (verbose) {
+        System.out.println("graph input complete");
+      }
+    }
+
+    else if (inertialPlot) {
+      if (verbose) {
+        System.out.println("calculating with respect to an inertial frame of reference");
+      }
+
+      BodyMaths.inertialReference(body, inertiaNum);
+
+      if (verbose) {
+        System.out.println("inertial calculations complete\nstarting inertial graph");
+      }
+      NBodyGraph.graphNBody(bodyName, body, "inertial Reference plot");
+      if (verbose) {
+        System.out.println("inertial graph input complete");
+      }
+    }
+
+// }//long for(;;) loop
+  }//main()
+}//class
diff --git a/NBodyGraph.java b/NBodyGraph.java
new file mode 100644
index 0000000..cf4b3af
--- /dev/null
+++ b/NBodyGraph.java
@@ -0,0 +1,45 @@
+import java.io.*;
+import java.awt.*;
+import javax.swing.*;
+import java.util.Scanner;
+import org.math.plot.*;
+import org.math.plot.plotObjects.*;
+import java.util.Arrays;
+
+/**
+* This class is used for the plotting tools
+* @author Matthew Williams, Yulia Kosharych, J. Summer, J.F. Briere
+* @version 2018-05-16
+**/
+
+public class NBodyGraph{
+
+  /**
+  * This method plots the positions of the bodies
+  * @param bodyName[] String        these are the names of the bodies
+  * @param body[][][][] double      these are the bodies that will be plotted
+  * @param graphtype String         this is the type of plot that is printed
+  **/
+  public static void graphNBody(String bodyName[], double body[][][][], String graphtype){
+    Plot2DPanel plot = new Plot2DPanel();
+
+    // Define the legend position
+    plot.addLegend("SOUTH");
+
+    // Add a line plot to the PlotPanel
+    for (int i=0;i<body.length;i++) {
+      plot.addLinePlot(bodyName[i], body[i][0][0], body[i][0][1]);
+    }
+    plot.setAxisLabel(0,"x position");
+    plot.getAxis(0).setLabelPosition(0.5,-0.1);
+    plot.setAxisLabel(1,"y postion");
+    BaseLabel title = new BaseLabel("N("+body.length+") body problem: "+graphtype, Color.BLACK, 0.5, 1.1);
+    title.setFont(new Font("Courier", Font.BOLD, 14));
+    plot.addPlotable(title);
+
+    JFrame frame = new JFrame("Output of NBody.java");
+    frame.setSize(525, 525);
+    frame.setContentPane(plot);
+    frame.setVisible(true);
+  }//graphNBody()
+}//class
diff --git a/Object.java b/Object.java
new file mode 100644
index 0000000..3056fc8
--- /dev/null
+++ b/Object.java
@@ -0,0 +1,75 @@
+import java.awt.Color;
+import java.awt.Graphics2D;
+import java.awt.geom.Ellipse2D;
+
+public class Object {
+
+	
+	double[] initPosVec = new double[2];
+	double[] PosVec = new double[2];
+	
+	double radius;
+	
+	Ellipse2D object;
+	
+	public Object(double _x0, double _y0, double _radius)
+	{
+		
+		
+		radius = _radius;
+
+		initPosVec[0] = _x0 - radius/2;
+		initPosVec[1] = _y0 - radius/2;
+		
+		PosVec[0] = _x0 - radius/2;
+		PosVec[1] = _y0 - radius/2;
+		
+		
+		
+		object = new Ellipse2D.Double(initPosVec[0], initPosVec[1], radius, radius); //sets centered object at x0, y0
+	
+		
+	}
+	
+	public double[] getInitPosVec()
+	{
+		return initPosVec;
+		
+	}
+	
+	public void updateObj(double[] posVec)
+	{
+		
+		PosVec[0] = posVec[0];
+		PosVec[1] = posVec[1];
+		
+		object.setFrame(PosVec[0], PosVec[1], radius, radius);
+	}
+	
+	public void updateCelestialObj(double[] posVec)
+	{
+		
+		PosVec[0] = (MainPanel.scaling*posVec[0])/MainPanel.au + MainPanel.x0 - radius/2;
+		PosVec[1] = (MainPanel.scaling*posVec[1])/MainPanel.au + MainPanel.y0 - radius/2;
+		
+		object.setFrame(PosVec[0], PosVec[1], radius, radius);
+	}
+	
+	public void readObj(double[][] posVec, int t)
+	{
+		
+		PosVec[0] = posVec[0][t];
+		PosVec[1] = posVec[1][t];
+		
+		object.setFrame(posVec[0][t], posVec[1][t], radius, radius);
+	}
+	
+	public void paintObj(Graphics2D g, Color color)
+	{
+	
+		g.setColor(color);
+		g.fill(object);
+		
+	}
+	
+}
diff --git a/SolarBody.java b/SolarBody.java
new file mode 100644
index 0000000..36f2f87
--- /dev/null
+++ b/SolarBody.java
@@ -0,0 +1,236 @@
+import java.util.Scanner;
+
+/**
+* This class contains premade values and situations for gravitational objects.
+* It already contains several important sol system values.
+* This class also allows for easy reference to starting positions.
+* @author Matthew Williams, Yulia Kosharych
+* @version 2018-05-16
+**/
+public class SolarBody{
+  // mass*     = mass of the body (kg)
+  // v*        = initial velocity of body (km/h)
+  // solDis*   = distance from Sol (km)
+  // rad*      = radius of body (km)
+
+  // universal constants
+  public static double G = 8.64960768*Math.pow(10, -13);
+  public static double au = 1.49597870700*Math.pow(10,8);
+
+
+  // values for common objects
+  public static String nameSol = "Sol";
+  public static double massSol = 1.989*Math.pow(10, 30);
+  public static double solDisSol = 0;
+  public static double vSol = 0;
+  public static double radSol = 695508;
+
+  public static String nameEarth = "Earth";
+  public static double massEarth = 5.972*Math.pow(10, 24);
+  public static double solDisEarth = au;
+  public static double vEarth = BodyMaths.circleVelocityG(massSol,solDisEarth);
+  public static double radEarth = 6371;
+
+  public static String nameLuna = "Luna";
+  public static double massLuna = 7.342*Math.pow(10, 22);
+  public static double earthDisLuna = 384402;
+  public static double solDisLuna = solDisEarth+earthDisLuna;
+  public static double vLuna = vEarth+BodyMaths.circleVelocityG(massEarth,earthDisLuna);
+  public static double radLuna = 1737;
+
+  public static String nameJupiter = "Jupiter";
+  public static double massJupiter = 1.898*Math.pow(10, 27);
+  public static double solDisJupiter = 5.2*au;
+  public static double vJupiter = BodyMaths.circleVelocityG(massSol,solDisJupiter);
+  public static double radJupiter = 69911;
+
+  public static String nameCallisto = "Callisto";
+  public static double massCallisto = 1.076*Math.pow(10, 23);
+  public static double jupDisCallisto = 1880000;
+  public static double solDisCallisto = solDisJupiter+jupDisCallisto;
+  public static double vCallisto = vJupiter+BodyMaths.circleVelocityG(massSol, solDisJupiter);
+  public static double radCallisto = 2410.3;
+
+
+  public String name;       // name of the body
+  public double mass;       // mass of the body (kg)            strictly positive
+  public double solDis;     // distance from Sol (km)           strictly positive
+  public double vInitial;   // initial velocity of body (km/h)  positive/negative
+  public double rad;        // radius of body (km)              strictly positive
+  public double theta;      // starting angle (rad)             positive/negative
+  //replace velocity location or theta location with string location in constructor be able to select one of them. keep at beginning if removing both
+  // all other variables allow for adaption when set to a negative value
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+  /**
+  * This method constructs a Solarbody object
+  * @param name String         name of the body
+  * @param mass double        mass of the body (kg)
+  * @param solDis double      distance from Sol (km)
+  * @param vInitial double    initial velocity of body (km/h)
+  * @param rad double         radius of body (km)
+  * @param theta double       starting angle (rad)
+  * @version 2018-05-16
+  **/
+  public SolarBody(String name, double mass, double solDis, double vInitial, double rad, double theta){
+    this.name=name;
+    this.mass=mass;
+    this.solDis=solDis;
+    this.vInitial=vInitial;
+    this.rad=rad;
+    this.theta=theta;
+  }//specific body constructor
+
+  /**
+  * This method constructs a Solarbody with only a name and input values on all other variables
+  * @param name String         name of the body
+  * @version 2018-05-16
+  **/
+  public SolarBody(String name){
+    this.name=name;
+    this.mass=-1;
+    this.solDis=-1;
+    setVelocity();
+    this.rad=-1;
+    setTheta();
+  }//input constructor
+  public SolarBody(double mass, double solDis, double vInitial, double rad, String name){
+    this.name=name;
+    this.mass=mass;
+    this.solDis=solDis;
+    this.vInitial=vInitial;
+    this.rad=rad;
+    setTheta();
+  }
+  public SolarBody(double mass, double solDis, String name, double rad, double theta){
+    this.name=name;
+    this.mass=mass;
+    this.solDis=solDis;
+    setVelocity();
+    this.rad=rad;
+    this.theta=theta;
+  }//select a velocity constructor
+  public SolarBody(String name, double mass, double solDis, double rad){
+    this.name=name;
+    this.mass=mass;
+    this.solDis=solDis;
+    setVelocity();
+    this.rad=rad;
+    setTheta();
+  }//select theta and velocity constructor
+
+
+
+// premade starting objects that can be chosen
+  public static SolarBody Sol = new SolarBody(nameSol, massSol, solDisSol, vSol, radSol, 0);
+  public static SolarBody Jupiter = new SolarBody(nameJupiter, massJupiter, solDisJupiter, vJupiter, radJupiter, 0);
+  public static SolarBody Callisto = new SolarBody(nameCallisto, massCallisto, solDisCallisto, vCallisto, radCallisto, 0);
+  public static SolarBody Earth = new SolarBody(nameEarth, massEarth, solDisEarth, vEarth, radEarth, 0);
+  public static SolarBody Luna = new SolarBody(nameLuna, massLuna, solDisLuna, vLuna, radLuna, 0);
+  public static SolarBody SE_L5 = new SolarBody("SE_L5", 100, solDisEarth, vEarth, 0, -Math.PI/3);
+  public static SolarBody PlanetX = new SolarBody("PlanetX", massEarth, solDisEarth, vEarth, radEarth, Math.PI);
+  public static SolarBody Greeks = new SolarBody("Greeks", -1, solDisJupiter, vJupiter, 0, Math.PI/3);
+  public static SolarBody Trojans = new SolarBody("Trojans", 1000, solDisJupiter, vJupiter, 0, -Math.PI/3);
+  public static SolarBody Horseshoe = new SolarBody("Horseshoe orbit", 10, SolarBody.solDisJupiter-BodyMaths.L1(SolarBody.solDisJupiter, SolarBody.massSol, SolarBody.massJupiter), BodyMaths.circleVelocityG(SolarBody.massSol,(SolarBody.solDisJupiter-BodyMaths.L1(SolarBody.solDisJupiter, SolarBody.massSol, SolarBody.massJupiter))), 0, -Math.PI/9);
+  public static SolarBody IrregularTadpole = new SolarBody("Irregular Tadpole", 100, solDisJupiter+Math.pow(10, 7), vJupiter, 0, -Math.PI/3);
+  public static SolarBody Tadpole = new SolarBody("Tadpole", 100, solDisJupiter+Math.pow(10, 7), vJupiter-600, 0, -Math.PI/3);
+
+
+  /**
+  * This method sets the mass to 0 to show the path the body would take without influencing any other bodies as well as changing the name to reflect the change
+  * @version 2018-05-18
+  **/
+  public void setPath(){
+    this.mass=0;
+    this.name=this.name+"'s path";
+  }//setPath()
+
+  /**
+  * This method sets the theta value for an object
+  * @version 2018-05-18
+  **/
+  public void setTheta(){
+    Scanner kb = new Scanner(System.in);
+    System.out.println("desired theta for "+this.name+" in pi radians");
+    this.theta=kb.nextDouble()*Math.PI;
+  }//setTheta()
+
+  /**
+  * This method sets the velocity to a desired power of 10 from user input
+  * @version 2018-05-18
+  **/
+  public void setVelocity(){
+    Scanner kb = new Scanner(System.in);
+    System.out.println("desired initial velocity for "+this.name+" in km/h");
+    double vInit = kb.nextDouble();
+    System.out.print("times 10^");
+    double power = Math.pow(10, kb.nextDouble());
+    this.vInitial=vInit*power;
+    System.out.println("initial velcity = "+this.vInitial);
+  }//setVelocity()
+
+  /**
+  * This method sets the starting distance to a desired power of 10 from user input
+  * @version 2018-05-18
+  **/
+  public void setDis(){
+    Scanner kb = new Scanner(System.in);
+    System.out.println("desired initial distance for "+this.name+" in km");
+    double dis = kb.nextDouble();
+    System.out.print("times 10^");
+    double power = Math.pow(10, kb.nextDouble());
+    this.solDis=dis*power;
+    System.out.println("initial distance = "+this.solDis);
+  }//setDis()
+  /**
+  * This method sets the starting number of AUs from user input
+  * @version 2018-05-18
+  **/
+  public void setDisAU(){
+    Scanner kb = new Scanner(System.in);
+    System.out.println("desired initial distance for "+this.name+" in AUs");
+    double dis = kb.nextDouble();
+    this.solDis=dis*au;
+    System.out.println("initial distance = "+this.solDis);
+  }//setDisAU()
+  /**
+  * This method sets the name from user input
+  * @version 2018-05-18
+  **/
+  public void setName(String name){
+    // Scanner kb = new Scanner(System.in);
+    // System.out.println("name for the body");
+    // String name = kb.nextString();
+    this.name=name;
+    System.out.println("new name:"+this.name);
+  }//setnane()
+
+  /**
+  * This method adds to the starting distance to a desired power of 10 from user input
+  * @version 2018-05-18
+  **/
+  public void addDis(){
+    Scanner kb = new Scanner(System.in);
+    System.out.println("desired additional distance for "+this.name+" in km");
+    double dis = kb.nextDouble();
+    System.out.print("times 10^");
+    double power = Math.pow(10, kb.nextDouble());
+    this.solDis+=dis*power;
+    System.out.println("initial distance = "+this.solDis);
+  }//setDis()
+
+  /**
+  * This method adds to the starting velocity to a desired power of 10 from user input
+  * @version 2018-05-18
+  **/
+  public void addVel(){
+    Scanner kb = new Scanner(System.in);
+    System.out.println("desired additional velcity for "+this.name+" in km/h");
+    double vel = kb.nextDouble();
+    System.out.print("times 10^");
+    double power = Math.pow(10, kb.nextDouble());
+    this.vInitial+=vel*power;
+    System.out.println("initial velocity = "+this.solDis);
+  }//setDis()
+
+}//class

From 0b356b8bc0c8cda7b2e1c17e51cb7d7937ba96bb Mon Sep 17 00:00:00 2001
From: watem <watem.main@gmail.com>
Date: Mon, 21 May 2018 18:47:02 -0400
Subject: [PATCH 2/4] Delete ThreeBody.java

---
 ThreeBody.java | 297 -------------------------------------------------
 1 file changed, 297 deletions(-)
 delete mode 100644 ThreeBody.java

diff --git a/ThreeBody.java b/ThreeBody.java
deleted file mode 100644
index 9d1a20f..0000000
--- a/ThreeBody.java
+++ /dev/null
@@ -1,297 +0,0 @@
-import java.io.*;
-import java.awt.*;
-import javax.swing.*;
-import java.util.Scanner;
-import org.math.plot.*;
-import org.math.plot.plotObjects.*;
-import java.util.Arrays;
-
-// TODO: javadocs
-
-public class ThreeBody {
-public static final double G = 8.64960768*Math.pow(10, -13);//gravitational constant (km^3/kg/h^2)
-public static final double dt = 0.1; //delta t in hours
-public static final double tmax = 2190; //number of hours to run
-public static double time = 0; //initial time
-// public static final double tmax; //number of hours to run {inputs}
-public static final int imax =(int) (tmax/dt); //number of time steps
-// public static final double imax; //number of time steps {inputs}
-public static final boolean graphing = true;
-public static final double au = 1.49597870700*Math.pow(10,8);//initial distance of earth from the sun in km
-// public static final double radEarth=; //km
-// public static final double radSun=; //km
-
-public static final double massEarth=5.972*Math.pow(10, 24); //kg
-public static final double massSun=1.989*Math.pow(10, 30);  //kg
-public static final double massSat=50*Math.pow(10, 50); //kg
-
-public static Scanner kb = new Scanner(System.in);
-
-
-
-public static void main(String[] args) {
-//TODO: variable declaration, arrays
-	
- System.out.print("Please enter the duration of the simulation: ");
-	  tmax = kb.nextDouble();
-	  
-System.out.print("Please enter the mass of the satellite: ");
-	  massSat = kb.nextDouble();
-	  
-double satX, satY, velInitialX, velInitialY;
-  // earthX[0][0]=1.495978*Math.pow(10,16);
-  // earthX[1][0]=0;
-  // earthY[1][0]=108000;
-  // earthY[0][0]=0;
-  // System.out.println("please enter the mass of the satellite: ");
-  // massSat = kb.nextDouble();
-	
-  System.out.print("Please enter the initial x position of the satellite: ");
-  satX = kb.nextDouble();
-  System.out.print("Please enter the initial y position of the satellite: ");
-  satY = kb.nextDouble();
-  System.out.print("Please enter the initial x velocity of the satellite: ");
-  velInitialX = kb.nextDouble();
-  System.out.print("Please enter the initial y velocity of the satellite: ");
-  velInitialY = kb.nextDouble();
-
-
-  // System.out.println("please enter the time of the simulation in hours "); //{inputs}
-  // tmax = kb.nextDouble(); //{inputs}
-  // imax = tmax/dt; //{inputs}
-	
-	 double [][][] object = new double [3][3][2];
-  
- // object[a] : a = 0(Earth), a=1(Sun), a=2(Sat)
-// object[][b] : b = 0(position), b=1(velocity), b=2(acceleration)
-//object[][][c] : c = 0(x position), c=1(y position)
-  
-  //Earth
-  object[0][0][0] = au; 
-  object[0][0][1] = 0; 
-  
-  object[0][1][0] = 0; 
-  object[0][1][1] = velocityEarth; 
-  
-  object[0][2][0] = 0; 
-  object[0][2][1] = 0; 
-  
-  //Sun 
-  object[1][0][0] = 0; 
-  object[1][0][1] = 0; 
-  
-  object[1][1][0] = 0; 
-  object[1][1][1] = 0; 
-  
-  object[1][2][0] = 0; 
-  object[1][2][1] = 0; 
-  
-  //Sat
-  object[2][0][0] = satX; 
-  object[2][0][1] = satY; 
-  
-  object[2][0][0] = velInitialX; 
-  object[2][0][1] = velInitialY; 
-  
-  object[2][2][0] = 0; 
-  object[2][2][1] = 0; 
-
-  
-
-
-  System.out.println(Arrays.toString(accelSunAnyObj(massSun,object[0][0],object[1][0])));
-  
-while (time<tmax) {
-  
-  time = time+dt;
-
-  object[0][2] = accelSunAnyObj(massSun,object[0][0],object[1][0]);
-  object[1][2] = accelSunAnyObj(massEarth,object[1][0],object[0][0]);
-  object[2][2] = accelSunAnyObj(massSun,object[2][0], object[1][0]);
-  object[1][2] = add(object[1][2], accelSunAnyObj(massSat,object[1][0], object[2][0]));
-}
-
-
-//   for (int i=1;i<satX[0].length;i++) {
-//     satX = euler(satX, earthX[0][i-1], sunX[0][i-1], massEarth, massSun, i);
-//     satY = euler(satY, earthY[0][i-1], sunY[0][i-1], massEarth, massSun, i);
-//     earthX = euler(earthX, satX[0][i-1], sunX[0][i-1], massSat, massSun, i);
-//     earthY = euler(earthY, satY[0][i-1], sunY[0][i-1], massSat, massSun, i);
-//     sunX = euler(sunX, satX[0][i-1], earthX[0][i-1], massSat, massEarth, i);
-//     sunY = euler(sunY, satY[0][i-1], earthY[0][i-1], massSat, massEarth, i);
-//     System.out.println("finished i = "+i);
-//   }//end loop
-  System.out.println("finished calculating...");
-  System.out.println("current position of earth: ("+earthX[0][imax-1]+","+earthY[0][imax-1]+")");
-  // findMaxAcc();
-  // findMinDis(); //earth
-  // findMinDis(); //sun
-  //
-  // if (graphing) {
-  //   graph();
-  // }
-}//main()
-
-public static double[][] euler(double obj[][], double p1, double p2, double m1, double m2, int i) {
-  obj[2][i] = accel(obj[0][i-1], p1, p2, m1, m2);
-  obj[1][i] = obj[2][i]*dt+obj[1][i-1];
-  obj[0][i] = obj[1][i]*dt+obj[0][i-1];
-  return obj;
-}
-
-	
-public static double [] add(double [] array1, double [] array2) {
-	
-	
-	double [] add = new double [array1.length];
-	
-	for(int i = 0; i < array1.length; i++)
-	{
-		add[i] = array1[i] + array2[i];
-		
-		
-	}
-	
-	return add;
-			
-}
-	
-// calculate accel();
-
-public static double [] getR(double [] objPos1, double [] objPos2) {
-	 
-	double [] rVector = new double [2];
-	
-	rVector[0]= objPos2[0] - objPos1[0];
-	rVector[1]= objPos2[1] - objPos1[1];
-	
-	return rVector;
-	}
-
-
-public static double getMag(double [] rVector) {
-	
-	double rMagnitude;
-	rMagnitude = Math.sqrt(Math.pow(rVector[0],2) + Math.pow(rVector[1], 2));
-	return rMagnitude;
-}
-
-
-public static double [] getUnit(double [] rVector, double rMagnitude ) {
-	
-	double [] unit = new double[2];
-	
-	unit[0] = rVector[0]/rMagnitude;
-	unit[1] = rVector[1]/rMagnitude;
-	
-return unit;
-}
-
-public static double [] accelSunAnyObj( double mPullObj,double [] objPos1, double [] objPos2) {
-
-double rMagnitude;	
-double [] rVector = new double [2];
-double [] unit = new double [2];
-double [] accelVector = new double [2];
-double accelMagnitude;
-
-rVector = getR(objPos1,objPos2);
-rMagnitude = getMag(rVector);
-unit = getUnit(rVector,rMagnitude);
-
-accelMagnitude= (G*mPullObj)/ Math.pow(rMagnitude, 2);
-accelVector[0] = accelMagnitude * unit[0];
-accelVector[1] = accelMagnitude * unit[1];
-  
-  return accelVector;
-}
-public static double [] compareAccel(double [] accelInitial, double [] accelFinal) {
-	
-	double accelMagIn = getMag(accelInitial);
-	double accelMagFin = getMag(accelFinal);
-	
-	
-	
-	if (accelMagIn < accelMagFin) {
-		
-		return accelFinal;
-		
-	}else {
-		
-		return accelInitial;
-	}
-	
-	
-}
-
-public static double [] updateVel(double [] velInitial, double [] accel) {
-	
-	
-	velInitial[0] = accel[0] *dt + velInitial[0];
-	velInitial[1] = accel[1] *dt + velInitial[1];
-	
-	
-	return velInitial;
-}
-
-
-
-public static double [] updatePos(double [] posInitial, double [] vel) {
-	
-	
-	posInitial[0] = vel[0] * dt + posInitial[0];
-	posInitial[1] = vel[1] * dt + posInitial[1];
-	
-	return posInitial;
-		
-}
-
-public static double comparePosition(double[] posInitial, double[] posFinal) {
-	
-	double magPosIn = getMag(posInitial);
-	double magPosFin = getMag(posFinal);
-	
-	
-	if (magPosIn < magPosFin ) {
-		
-		return magPosFin;
-		
-	}else {
-		
-		return magPosIn;
-	}
-	
-}
-
-
-
-public static double compareVelocity(double[] velInitial, double[] velFinal) {
-	
-	double magVelIn = getMag(velInitial);
-	double magVelFin = getMag(velFinal);
-	
-	
-	if (magVelIn < magVelFin ) {
-		
-		return magVelFin;
-		
-	}else {
-		
-		return magVelIn;
-	}
-	
-}
-
-
-
-
-
-//TODO: findMinDis method
-// public static
-// void 
-
-//TODO: graphing method()
-// public static void graph(double[][] satX,double[][] satY,double[][] sunX,double[][] sunY,double[][] earthX,double[][] earthY)
-
-
-}//end class ThreeBody

From 2c8b8222ba356a6611f74fb0e2624283f862726b Mon Sep 17 00:00:00 2001
From: watem <watem.main@gmail.com>
Date: Mon, 21 May 2018 18:47:09 -0400
Subject: [PATCH 3/4] Delete ThreeBodyInstantaneousSimulationVersion

---
 ThreeBodyInstantaneousSimulationVersion | 329 ------------------------
 1 file changed, 329 deletions(-)
 delete mode 100644 ThreeBodyInstantaneousSimulationVersion

diff --git a/ThreeBodyInstantaneousSimulationVersion b/ThreeBodyInstantaneousSimulationVersion
deleted file mode 100644
index 22ac7a1..0000000
--- a/ThreeBodyInstantaneousSimulationVersion
+++ /dev/null
@@ -1,329 +0,0 @@
-  import java.util.Scanner;
-  import java.util.Arrays;
-
-// TODO: javadocs
-
-
-  public class ThreeBody {
-  
-  //Final variables declaration
-  
-  public static final double G = 8.64960768*Math.pow(10, -13);//gravitational constant (km^3/kg/h^2)
-  public static final double dt = 0.1; //delta t in hours
-  public static double tmax ; //number of hours to run
-  public static double time = 0; //initial time
-  // public static final double tmax; //number of hours to run {inputs}
-  public static final int imax =(int) (tmax/dt); //number of time steps
-  // public static final double imax; //number of time steps {inputs}
-  public static final boolean graphing = true;
-  public static final double au = 1.49597870700*Math.pow(10,8);//initial distance of earth from the sun in km
-  // public static final double radEarth=; //km
-  // public static final double radSun=; //km
-
-  public static final double massEarth=5.972*Math.pow(10, 24); //kg
-  public static final double massSun=1.989*Math.pow(10, 30);  //kg
-  public static double massSat; //kg
-  public static final double velocityEarth = 1.08*Math.pow(10, 5);// initial velocity of Earth
-  public static Scanner kb = new Scanner(System.in);
-
-
-
-  public static void main(String[] args) {
-
-	
-  System.out.print("Please enter the duration of the simulation: ");
-	  tmax = kb.nextDouble();
-	  
-  System.out.print("Please enter the mass of the satellite: ");
-	  massSat = kb.nextDouble();
-	  
-  double satX, satY, velInitialX, velInitialY;
-
-  // earthX[0][0]=1.495978*Math.pow(10,16);
-  // earthX[1][0]=0;
-  // earthY[1][0]=108000;
-  // earthY[0][0]=0;
-  // System.out.println("please enter the mass of the satellite: ");
-  // massSat = kb.nextDouble();
-  System.out.print("Please enter the initial x position of the satellite: ");
-  satX = kb.nextDouble();
-  System.out.print("Please enter the initial y position of the satellite: ");
-  satY = kb.nextDouble();
-  System.out.print("Please enter the initial x velocity of the satellite: ");
-  velInitialX = kb.nextDouble();
-  System.out.print("Please enter the initial y velocity of the satellite: ");
-  velInitialY = kb.nextDouble();
-
-  
-  
-
-	
-	
-  double [][][] object = new double [3][3][2];
-  
- // object[a] : a = 0(Earth), a=1(Sun), a=2(Sat)
-// object[][b] : b = 0(position), b=1(velocity), b=2(acceleration)
-//object[][][c] : c = 0(x position), c=1(y position)
-  
-  //Earth
-  object[0][0][0] = au; 
-  object[0][0][1] = 0; 
-  
-  object[0][1][0] = 0; 
-  object[0][1][1] = velocityEarth; 
-  
-  object[0][2][0] = 0; 
-  object[0][2][1] = 0; 
-  
-  //Sun 
-  object[1][0][0] = 0; 
-  object[1][0][1] = 0; 
-  
-  object[1][1][0] = 0; 
-  object[1][1][1] = 0; 
-  
-  object[1][2][0] = 0; 
-  object[1][2][1] = 0; 
-  
-  //Sat
-  object[2][0][0] = satX; 
-  object[2][0][1] = satY; 
-  
-  object[2][0][0] = velInitialX; 
-  object[2][0][1] = velInitialY; 
-  
-  object[2][2][0] = 0; 
-  object[2][2][1] = 0; 
-
-  
-
-
-  System.out.println(Arrays.toString(accelSunAnyObj(massSun,object[0][0],object[1][0])));
-  
-  double [] maxAccel, minPosSun, minPosEarth;
-  maxAccel = object[2][2];
-  
-  minPosSun = differencePos(object[2][0],object[1][0]);
-  minPosEarth = differencePos(object[2][0],object[0][0]);
-
-  while (time<tmax) {
-  
-  time = time+dt;
-//get the instantaneous acceleration of each object
-  object[0][2] = accelSunAnyObj(massSun,object[0][0],object[1][0]);
-  object[1][2] = accelSunAnyObj(massEarth,object[1][0],object[0][0]);
-  object[2][2] = accelSunAnyObj(massSun,object[2][0], object[1][0]);
-  object[1][2] = add(object[1][2], accelSunAnyObj(massSat,object[1][0], object[2][0]));
-  object[0][2] = add(object[0][2], accelSunAnyObj(massSat,object[0][0],object[2][0]));
-  object[2][2] = add(object[2][2], accelSunAnyObj(massEarth, object[2][0],object[0][0]));
-  
-  //get the instantaneous velocity of each object
-  object[0][1] = add((mult(object[0][2])), object[0][1]);
-  object[1][1] = add((mult(object[1][2])), object[1][1]);
-  object[2][1] = add((mult(object[2][2])), object[2][1]);
-  
-  //get the instantaneous position of each object
-  object[0][0] = add((mult(object[0][1])), object[0][0]);
-  object[1][0] = add((mult(object[1][1])), object[1][0]);
-  object[2][0] = add((mult(object[2][1])), object[2][0]);
-  
-  maxAccel = compareAccel(maxAccel,object[2][2]);
-  // findMinDis(); //sun
-  minPosSun = comparePosition(minPosSun, differencePos(object[2][0],object[1][0]));
-
-// findMinDis(); //earth
-  minPosEarth = comparePosition(minPosEarth, differencePos(object[2][0],object[0][0]));
-
-  }
-
-  System.out.println("The maximum acceleration is : " + getMag(maxAccel));
-  System.out.println("The minimum distance to Earth is : " + getMag(minPosEarth));
-  System.out.println("The minimum distance to Sun is : " + getMag(minPosSun)); 
-  
-
-  
-  // if (graphing) {
-  //   graph();
-  // }
-}//main()
-
-
-
-
-  public static double [] mult(double [] array) {
-	
-	for(int i =0; i<array.length;i++) {
-		
-	array[i] = array[i]*dt;	
-	}
-	
-	
-	return array;
-	
-	
-}
-
-
-  public static double [] add(double [] array1, double [] array2) {
-	
-	
-	double [] add = new double [array1.length];
-	
-	for(int i = 0; i < array1.length; i++)
-	{
-	add[i] = array1[i] + array2[i];
-		
-		
-	}
-	
-	return add;
-			
-}
-		
-		
-	public static double [] differencePos(double[] pos1, double [] pos2){
-			
-	double [] result = new double[2];
-	for(int i =0; i<pos1.length;i++) {
-				
-	result[i] = pos1[i]-pos2[i];
-				
-				
-			}
-	return result;
-			
-		}
-		
-  public static double [] getR(double [] objPos1, double [] objPos2) {
-	 
-	double [] rVector = new double [2];
-	
-	rVector[0]= objPos2[0] - objPos1[0];
-	rVector[1]= objPos2[1] - objPos1[1];
-	
-	return rVector;
-	}
-
-
-  public static double getMag(double [] rVector) {
-	
-	double rMagnitude;
-	rMagnitude = Math.sqrt(Math.pow(rVector[0],2) + Math.pow(rVector[1], 2));
-	return rMagnitude;
-}
-
-
-  public static double [] getUnit(double [] rVector, double rMagnitude ) {
-	
-  double [] unit = new double[2];
-
-  unit[0] = rVector[0]/rMagnitude;
-  unit[1] = rVector[1]/rMagnitude;
-
-  return unit;
-  }
-
-  public static double [] accelSunAnyObj( double mPullObj,double [] objPos1, double [] objPos2) {
-
-  double rMagnitude;	
-  double [] rVector = new double [2];
-  double [] unit = new double [2];
-  double [] accelVector = new double [2];
-  double accelMagnitude;
-
-  rVector = getR(objPos1,objPos2);
-  rMagnitude = getMag(rVector);
-  unit = getUnit(rVector,rMagnitude);
-
-  accelMagnitude= (G*mPullObj)/ Math.pow(rMagnitude, 2);
-  accelVector[0] = accelMagnitude * unit[0];
-  accelVector[1] = accelMagnitude * unit[1];
-  
-  return accelVector;
-}
-
-  public static double [] compareAccel(double [] accelInitial, double [] accelFinal) {
-	
-	double accelMagIn = getMag(accelInitial);
-	double accelMagFin = getMag(accelFinal);
-	
-	
-	
-	if (accelMagIn < accelMagFin) {
-		
-	return accelFinal;
-		
-	}else {
-		
-	return accelInitial;
-	}
-	
-	
-}
-
-  public static double [] updateVel(double [] velInitial, double [] accel) {
-	
-	
-	velInitial[0] = accel[0] *dt + velInitial[0];
-	velInitial[1] = accel[1] *dt + velInitial[1];
-	
-	
-	return velInitial;
-}
-
-
-
-  public static double [] updatePos(double [] posInitial, double [] vel) {
-	
-	
-	posInitial[0] = vel[0] * dt + posInitial[0];
-	posInitial[1] = vel[1] * dt + posInitial[1];
-	
-	return posInitial;
-		
-}
-
-  public static double[] comparePosition(double[] posInitial, double[] posFinal) {
-	
-	double magPosIn = getMag(posInitial);
-	double magPosFin = getMag(posFinal);
-	
-	
-	if (magPosIn > magPosFin ) {
-		
-	return posFinal;
-		
-	}else {
-		
-	return posInitial;
-	}
-	
-}
-
-
-
-  public static double compareVelocity(double[] velInitial, double[] velFinal) {
-	
-	double magVelIn = getMag(velInitial);
-	double magVelFin = getMag(velFinal);
-	
-	
-	if (magVelIn < magVelFin ) {
-		
-	return magVelFin;
-		
-	}else {
-		
-	return magVelIn;
-	}
-	
-}
-
-
-//TODO: graphing method()
-// public static void graph(double[][] satX,double[][] satY,double[][] sunX,double[][] sunY,double[][] earthX,double[][] earthY)
-
-
-
-
-}//end class ThreeBody

From a1c145c36f65321227cae262bcf68e3279337699 Mon Sep 17 00:00:00 2001
From: watem <watem.main@gmail.com>
Date: Mon, 21 May 2018 22:25:10 -0400
Subject: [PATCH 4/4] Add files via upload

---
 ElectrostaticMaths.java |  5 ++--
 MainPanel.java          | 57 ++++++++++++++++++++++++++++++++++++-----
 2 files changed, 53 insertions(+), 9 deletions(-)

diff --git a/ElectrostaticMaths.java b/ElectrostaticMaths.java
index d0a753f..2e03891 100644
--- a/ElectrostaticMaths.java
+++ b/ElectrostaticMaths.java
@@ -4,7 +4,7 @@
 * @author Matthew Williams, Yulia Kosharych
 * @version 2018-05-16
 **/
-public class BodyMaths {
+public class ElectrostaticMaths {
 
   // import constants
   public static final double Ke = Electrostatics.Ke;
@@ -23,8 +23,7 @@ public class BodyMaths {
   **/
   public static double electrostaticAccel(double obj[][], double body[][], double qObj, double qBody, double massObj, int i, int axis){
     double acceleration;
-    acceleration = Ke*qObj*qBody*(obj[axis][i]-body[axis][i])/Math.pow(Bodymaths.radius(obj, body, i), 3)/massObj;
+    acceleration = Ke*qObj*qBody*(obj[axis][i]-body[axis][i])/Math.pow(BodyMaths.radius(obj, body, i), 3)/massObj;
     return acceleration;
   }//electrostaticAccel()
 }
-   
diff --git a/MainPanel.java b/MainPanel.java
index 5ad2a02..61b8a86 100644
--- a/MainPanel.java
+++ b/MainPanel.java
@@ -41,6 +41,9 @@ public class MainPanel extends JPanel{
 	public static final double au = SolarBody.au;//initial distance of earth from the sun in km
 
 
+	// public static final double massEarth=SolarBody.massEarth; //kg
+	// public static final double velocityEarth = SolarBody.vEarth;// initial velocity of Earth
+
 	public static final double massEarth=SolarBody.massEarth; //kg
 	public static final double velocityEarth = SolarBody.vEarth;// initial velocity of Earth
 
@@ -48,9 +51,9 @@ public class MainPanel extends JPanel{
 	public static final double velocityJupiter = SolarBody.vJupiter;//velocity jupiter
 
 
-	public static final double massL5 = SolarBody.SE_L5; //kg
+	public static final double massL5 = SolarBody.SE_L5.mass; //kg
 
-	public static final double massSun=SolarBody.massSun;  //kg
+	public static final double massSun=SolarBody.massSol;  //kg
 	public static double massSat; //kg
 
 	public static Scanner kb = new Scanner(System.in);
@@ -69,6 +72,7 @@ public class MainPanel extends JPanel{
 	public void initSunEarthLuna()
 	{
 		 scaling = 350;
+
 			//Sat Conditions
 		  massSat = SolarBody.massLuna;
 		  satX = SolarBody.solDisLuna;
@@ -84,17 +88,36 @@ public void initSunEarthLuna()
 			velInitialPlanetY = velocityEarth;
 
 	}
+	public void initSunJupiterCallisto()
+	{
+		 scaling = 75;
+			//Sat Conditions
+			massSat = SolarBody.massCallisto;
+			satX = SolarBody.solDisCallisto+9*SolarBody.jupDisCallisto;
+			satY = 0;
+			velInitialX = 0;
+			velInitialY = SolarBody.vJupiter+BodyMaths.circleVelocityG(massEarth, 10*SolarBody.jupDisCallisto);
+
+				//Jupiter Condition
+			massPlanet = massJupiter;
+			planetX = SolarBody.solDisJupiter;
+			planetY = 0;
+			velInitialPlanetX = 0;
+			velInitialPlanetY = velocityJupiter;
+
+	}
 
 
 	public void initSunEarthL5()
 	{
 		 scaling = 350;
 			//Sat Conditions
+			double theta = -Math.PI/3;
 		  massSat = massL5;
-		  satX = au*Math.cos(-Math.PI/3);
-		  satY = au*Math.sin(-Math.PI/3);
-		  velInitialX = -velocityEarth*Math.sin(theta[0]);
-		  velInitialY = velocityEarth*Math.cos(theta[0]);
+		  satX = au*Math.cos(theta);
+		  satY = au*Math.sin(theta);
+		  velInitialX = -velocityEarth*Math.sin(theta);
+		  velInitialY = velocityEarth*Math.cos(theta);
 
 		  	//Planet Condition
 		  massPlanet = massEarth;
@@ -131,6 +154,26 @@ public void initSunJupiterProbe()
 
 	}
 
+	public void initHorseshoe()
+	{
+		 scaling = 75;
+			//Sat Conditions
+			double theta = SolarBody.Horseshoe.theta;
+		  massSat = SolarBody.Horseshoe.mass;
+		  satX = SolarBody.Horseshoe.solDis*Math.cos(theta);
+		  satY = SolarBody.Horseshoe.solDis*Math.sin(theta);
+		  velInitialX = -SolarBody.Horseshoe.vInitial*Math.sin(theta);
+		  velInitialY = SolarBody.Horseshoe.vInitial*Math.cos(theta);
+
+		  	//Planet Condition
+		  massPlanet = massJupiter;
+		  planetX = SolarBody.solDisJupiter;
+		  planetY = 0;
+		  velInitialPlanetX = 0;
+		  velInitialPlanetY =velocityJupiter;
+
+	}
+
 
 	public void Algorithm()
 	{
@@ -182,7 +225,9 @@ public MainPanel()
 
 		if (sim == 3) initSunJupiterProbe();
 
+		if (sim == 4) initSunJupiterCallisto();
 
+		if (sim == 5) initHorseshoe();
 
 		Algorithm();