christiaangoossens/Planetary-Orbit-Simulator
1
0
Fork 0
mirror of https://github.com/christiaangoossens/Planetary-Orbit-Simulator synced 2025-07-02 01:40:47 +00:00
Code Releases Activity

Created Matrix Logic

Browse Source
This commit is contained in:
Christiaan Goossens
2016-07-06 20:33:02 +02:00
parent 0deca8ffbe
commit 21b1b02854
20 changed files with 546 additions and 110 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
simulator/src/META-INF/MANIFEST.MF Normal file
View File

@ -0,0 +1,3 @@
Manifest-Version: 1.0
Main-Class: com.verictas.pos.simulator.Main

15
simulator/src/com/verictas/pos/simulator/Main.java
View File

@ -1,16 +1,19 @@
package com.verictas.pos.simulator;
import javax.vecmath.*;
public class Main {
public static void main(String[] args) {
System.out.println("Hello World!");
Object object1 = new Object(1000, new Vector3f(1,2,3), new Vector3f(0,4,3));
Object object2 = new Object(200, new Vector3f(2,38,2), new Vector3f(3,4,5));
Object object3 = new Object(200, new Vector3f(2,-20,2), new Vector3f(3,4,5));
Object object4 = new Object(200, new Vector3f(2,4,2), new Vector3f(3,4,5));
Object object1 = new Object(10E8, new Vector3f(1,2,3), new Vector3f(0,4,3));
Object object2 = new Object(20E4, new Vector3f(2,38,2), new Vector3f(3,4,5));
// Make a list of all the objects
Object[] objects = {object1, object2, object3, object4};
System.out.println(object1.toString());
System.out.println(object2.toString());
System.out.println(object1.getForceOnObject(object2));
// Start the simulation
Simulator.run(2, objects);
}
}

28
simulator/src/com/verictas/pos/simulator/Object.java
View File

@ -8,24 +8,47 @@ public class Object {
public Vector3f speed;
private double gravitationalConstant = 6.67384E-11;
/**
* Constructs an object
* @param mass The mass of the object
* @param position The position vector of the object
* @param speed The speed vector of the object
*/
public Object(double mass, Vector3f position, Vector3f speed) {
this.mass = mass;
this.position = position;
this.speed = speed;
}
/**
* Sets the speed vector of an object
* @param speed Current speed vector
*/
public void setSpeed(Vector3f speed) {
this.speed = speed;
}
/**
* Sets the position vector of an object.
* @param position Current position vector
*/
public void setPosition(Vector3f position) {
this.position = position;
}
/**
* Changes an object into readable form
* @return String
*/
public String toString() {
return "Mass: " + this.mass + " & Position: " + this.position + " & Speed: " + this.speed;
}
/**
* Calculates the force of the passed object on the current object.
* @param secondObject The passed object
* @return Vector3f The gravitational force
*/
public Vector3f getForceOnObject(Object secondObject) {
double scale = gravitationalConstant * ((this.mass * secondObject.mass) / Math.pow(getDistance(secondObject).length(), 3.0));
Vector3f force = getDistance(secondObject);
@ -33,6 +56,11 @@ public class Object {
return force;
}
/**
* Get the vector distance between the current position vector and the position vector of the passed object.
* @param secondObject The passed object.
* @return Vector3f The distance vector
*/
private Vector3f getDistance(Object secondObject) {
Vector3f distance = new Vector3f(0,0,0); // Empty
distance.sub(this.position, secondObject.position);

64
simulator/src/com/verictas/pos/simulator/Simulator.java Normal file
View File

@ -0,0 +1,64 @@
package com.verictas.pos.simulator;
import javax.vecmath.*;
import com.verictas.pos.simulator.mathUtils.Vector3fMatrix;
public class Simulator {
public static void run(int rounds, Object[] objects) {
/**
* Log a debug message to the console to signal the simulation has started
*/
System.out.println("========== Simulation Started ==========\n");
/**
* Start the rounds loop
*/
for(int t = 0; t < rounds; t++) {
/**
* The round has started
*/
System.out.println("Round " + (t + 1) + " started!");
/**
* Define the forces matrix for this round
*/
Vector3fMatrix matrix = new Vector3fMatrix(objects.length,objects.length);
for(int i = 0; i < objects.length; i++) {
/**
* For every object: calculate the force upon it.
*/
for (int o = 0; o < objects.length; o++) {
/**
* Loop through all other objects
*/
if (o == i) {
break;
}
Vector3f force = objects[i].getForceOnObject(objects[o]);
matrix.setPosition(force, i, o);
System.out.println("Force " + (i + 1) + " on " + (o + 1) + " - " + force);
/**
* Also put in the opposite force
*/
force.scale(-1);
matrix.setPosition(force, o, i);
System.out.println("Force " + (o + 1) + " on " + (i + 1) + " - " + force);
}
}
/**
* Print the matrix for this round
*/
System.out.println("\n");
System.out.println(matrix);
}
/**
* Log that the simulation has finished
*/
System.out.println("========== Simulation Finished ==========");
}
}

95
simulator/src/com/verictas/pos/simulator/mathUtils/Vector3fMatrix.java Normal file
View File

@ -0,0 +1,95 @@
package com.verictas.pos.simulator.mathUtils;
import javax.vecmath.GMatrix;
import javax.vecmath.Vector3f;
public class Vector3fMatrix extends GMatrix {
/**
* Creates a new matrix with some helper functions for use with Vector3f. The created matrix will be empty.
* @param n The number of rows.
* @param m The number of columns.
*/
public Vector3fMatrix(int n, int m) {
// Change the size to suit Vector3f
super(n, m * 3);
this.setZero();
}
/**
* Set the size of the matrix in the amount of vectors (e.g. a 1 x 3 vector matrix gets converted to a 1 x 9 storage matrix).
* @param n The amount of rows
* @param m The amount of columns expressed in vectors (1 vector = 3 values).
*/
public void setSizeInVectors(int n, int m) {
this.setSize(n, m * 3);
}
/**
* Provides a function for putting the matrix into String form for visualisation.
* @return String
*/
public String toString() {
StringBuffer buffer = new StringBuffer(this.getNumRow() * this.getNumCol() * 8);
for(int n = 0; n < this.getNumRow(); ++n) {
for(int m = 0; m < this.getNumCol(); ++m) {
if ((m + 1) == 1 || m % 3 == 0) {
// If m is 1 or a multiple of 4, begin the bracket.
buffer.append("(").append(this.getElement(n, m)).append(", ");
} else if ((m + 1) % 3 == 0) {
// If m is a multiple of 3, close the bracket
buffer.append(this.getElement(n, m)).append(")\t\t");
} else {
buffer.append(this.getElement(n, m)).append(", ");
}
}
buffer.append("\n");
}
return buffer.toString();
}
/**
* Provides a translator from the vector positions (e.g. the second vector starts at position 1) to the matrix positions (the second vector starts at position 3).
* @param n The vector positions row
* @param m The vector positions column
* @return void
*/
private int[] translatePosition(int n, int m) {
return new int[]{n, m * 3};
}
/**
* Provides a way to set a vector into a certain position in the matrix
* @param settable The vector you want to put in the matrix
* @param n The row to insert into
* @param m The column to insert into
*/
public void setPosition(Vector3f settable, int n, int m) {
int[] position = translatePosition(n, m);
n = position[0];
m = position[1];
this.setElement(n, m, settable.x);
this.setElement(n, m + 1, settable.y);
this.setElement(n, m + 2, settable.z);
}
/**
* Provides a way to get a vector from a certain position in the matrix
* @param n The row to get from
* @param m The column to get from
* @return Vector3f The vector in that position
*/
public Vector3f getPosition(int n, int m) {
int[] position = translatePosition(n, m);
n = position[0];
m = position[1];
float x = (float) this.getElement(n, m);
float y = (float) this.getElement(n, m + 1);
float z = (float) this.getElement(n, m + 2);
return new Vector3f(x, y, z);
}
}