From 1b1e0bfd1a5e9d88886b58b0d4db05cafbb36365 Mon Sep 17 00:00:00 2001 From: hanemile Date: Fri, 9 Feb 2018 13:42:24 +0100 Subject: added the spiral folder --- src/python/spiral/galaxytools.py | 286 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 286 insertions(+) create mode 100644 src/python/spiral/galaxytools.py (limited to 'src/python/spiral/galaxytools.py') diff --git a/src/python/spiral/galaxytools.py b/src/python/spiral/galaxytools.py new file mode 100644 index 0000000..1a9336c --- /dev/null +++ b/src/python/spiral/galaxytools.py @@ -0,0 +1,286 @@ +# Import libraries +import math as math # general math +import numpy as np # advanced math + +# import matplotlib.pyplot as plt # plotting things + + +# class used to create galaxies +class new_galaxy(object): + + # Initialisation + def __init__(self, galaxy_range): + print( + """>>> Initialising the list storing coordinates, forces and other + values""" + ) + + # list used for storing the coordinates os the stars + self.list_coords = [] + + # list storing the overall force acting on one star + self.list_force_star = [] + + # list storing the coordinates of the midpoints of the spheres dividing + # the galaxy into equaly big sized cells + self.list_sphere_coords = [] + + # self.list_sphere_stars = np.array(3, ) + + print("\tDone\n") + print(">>> Initialising variables and constants") + + # variable storing the number of stars generated + self.num_of_stars = 0 + + self.galaxy_range = int(galaxy_range) + + # define the universal gravitational constant + self.G = 6.67408 * 10e11 + + print("\tDone\n") + + # generate n new stars and store the coordinates in list_coords + # n = number of stars to be generated + # galaxy_range = size of the galaxy + def gen_new_stars(self, n): + print(">>> Generating Stars...") + + # for a given number of stars + for i in range(0, n): + + # generate a temporary random coordinate inside a given range using + # numpy + self.temp_coord = np.random.uniform( + low=0, high=self.galaxy_range, size=(4, )) + + # append the random coordinate to the list storing the coordinates + self.list_coords.append(self.temp_coord) + + # increment the generated star counter + self.num_of_stars += n + print("\tDone") + print("\tGenerated " + str(n) + " Stars\n") + + # print out all the coordinates in list_coords + def print_stars(self): + print(">>> Listing the coordinates of all stars:") + # print the coordinates of every star + for value in self.list_coords: + print(value) + + print("\tDone\n") + + # calculate the forces acting between two stars on a specified axis + # star1 = coordinates of the first star + # star2 = coordinates of the second star + # axes = "x", "y" or "z" (CASE SENSITIVE!) + def calc_forces(self, star1, star2, axes): + if axes == "x": + mass = star1[3] * star2[3] + distance = math.sqrt(math.pow(star1[0] - star2[0], 2)) + elif axes == "y": + mass = star1[3] * star2[3] + distance = math.sqrt(math.pow(star1[1] - star2[1], 2)) + elif axes == "z": + mass = star1[3] * star2[3] + distance = math.sqrt(math.pow(star1[2] - star2[2], 2)) + + # stop division by zero + if distance == 0: + pass + else: + # return the acting force + return self.G * mass / math.pow(distance, 2) + + # calculate all the forces acting in the current galaxy + def calc_all_forces(self): + print(">>> Calculating all the forces acting inbetween the stars:") + + if (self.num_of_stars <= 5): + # print some information above the columns + print(">>> Printing the forces acting inbetween every star") + print("{:-<60}".format("")) + print("\t| {:<3}| {:<3}| ".format("a", "b")) + print("\t+{:-<4}+{:-<4}+{:-<60} ".format("", "", "")) + + else: + print("\t[W] Too many stars to print out!") + print("{:-<60}".format("")) + + # for every star + for i in range(0, self.num_of_stars): + + # initialize + self.force = 0 + + # every other star: + for j in range(0, self.num_of_stars): + + # don't calculate the force between a star and and itself + if i != j and i < j: + self.arr_force = np.array((0, 0, 0)) + + # calculate the force between the two stars + force_x = self.calc_forces(self.list_coords[i], + self.list_coords[j], "x") + force_y = self.calc_forces(self.list_coords[i], + self.list_coords[j], "y") + force_z = self.calc_forces(self.list_coords[i], + self.list_coords[j], "z") + + # print("overall force: ", end="") + self.arr_force = np.array((force_x, force_y, force_z)) + + if (self.num_of_stars <= 5): + print("\t| {:<3}| {:<3}| {:<60}".format( + str(i), str(j), str(self.arr_force))) + """ + force_x = 42 + force_y = 36 + force_z = 24 + + (0, 0, 0) --> (42, 36, 24) + """ + + # append the variable to the list storing all the forces + self.list_force_star.append(self.arr_force) + + print("{:-<60}".format("")) + print("\tDone\n") + + # print the individual forces acting on a star + def print_individual_forces(self, n=None, print_confirm=False): + print(">>> Printing the individual forces acting on every star") + + if self.num_of_stars > 10: + print("\t[W] Too many stars to print out!") + print("{:-<60}".format("")) + + for i in range(0, 3): + print("\t" + str(i) + " " + str(self.list_force_star[i])) + + print("\n\t...\n") + + for i in range( + int(len(self.list_force_star) - 3), + len(self.list_force_star)): + print("\t" + str(i) + " " + str(self.list_force_star[i])) + print("{:-<60}".format("")) + + else: + print("{:-<60}".format("")) + if n is None: + # for value in self.list_force_star: + for i in range(0, len(self.list_force_star)): + print("\t" + str(i) + " " + str(self.list_force_star[i])) + else: + print(self.list_force_star[n]) + + print("{:-<60}".format("")) + print("\tDone\n") + + # star [x, y, z, m] + # sphere [x, y, z, r] + def is_star_in_sphere(self, star, sphere): + + # define the sphere values + self.sphere_x = sphere[0] + self.sphere_y = sphere[1] + self.sphere_z = sphere[2] + self.sphere_r = sphere[3] + + # define the star coordinates + self.star_x = star[0] + self.star_y = star[1] + self.star_z = star[2] + + self.sphere_x_neg = self.sphere_x - self.sphere_r + self.sphere_x_pos = self.sphere_x + self.sphere_r + + self.sphere_y_neg = self.sphere_y - self.sphere_r + self.sphere_y_pos = self.sphere_y + self.sphere_r + + self.sphere_z_neg = self.sphere_z - self.sphere_r + self.sphere_z_pos = self.sphere_z + self.sphere_r + + # find out if the star is inside the sphere + if self.sphere_x_neg < self.star_x < self.sphere_x_pos: + if self.sphere_y_neg < self.star_y < self.sphere_y_pos: + if self.sphere_z_neg < self.star_z < self.sphere_z_pos: + return True + else: + return False + else: + return False + else: + return False + + # find out which stars in in which spheres + def is_star_in_sphere_all(self): + + # define a counter for indexing the spheres + tmp_counter = 0 + + # cycle through all the stars + for star in self.list_coords: + + # cycle through all the spheres + for value in self.list_sphere_coords: + + # parse the needed values from the sphere list + sphere = np.array((value[0:4])) + + # if the star is inside the sphere + if (self.is_star_in_sphere(star, sphere) is True): + + # print stuff + print(tmp_counter, end=" ") + print(star, end=" ") + print(sphere) + + # increment the counter + tmp_counter += 1 + + # break the loop to stop possible multiple assignments + break + + # function generating the positions of the sphere cells + def gen_sphere_positions(self, sampling_rate): + + # calculate the distance between the midpoints of the spheres + sphere_distance = int(round(self.galaxy_range / sampling_rate, 0)) + + # define the sphere_radius + tmp_var = math.pow(sphere_distance, 2) + sphere_radius = math.sqrt(tmp_var + tmp_var + tmp_var) + + # define a sphere counter for "labeling" the spheres + tmp_counter = 0 + + # cycle through all potential points + for i in range(-self.galaxy_range, self.galaxy_range, sphere_distance): + for j in range(-self.galaxy_range, self.galaxy_range, + sphere_distance): + for k in range(-self.galaxy_range, self.galaxy_range, + sphere_distance): + + # generate a temporary array combining all values + temp_arr = np.array((i, j, k, sphere_radius, tmp_counter)) + + # append the array to the list storing the sphere infos + self.list_sphere_coords.append(temp_arr) + + # increment the sphere counter + tmp_counter += 1 + + def calc_forces_sphere(): + pass + + def calc_forces_sphere_all(): + pass + + def gen_print_forces_after_t(t): + pass + + # def all_stars_in_sphere(self, star, se) -- cgit 1.4.1