About the author: Hello everyone, I am Aakash Deep, I am a 4th year undergraduate student pursuing my degree in Bachelor's of Technology (B.Tech) in Computer Science and Engineering (CSE) from Indraprastha Institure of Information Technology, Delhi (IIIT-D) in India. I am a space enthusiast and I like travelling. My major hobby is speed-cubing.
About the organization
The organization for which I am working is AerospaceResearch.net. It has many interesting projects not only for the under-graduate beginners but for the masters‘ degree students too. We are a small group of enthusiasts who love to solve problems related to space. The benefit of being a part of a small group is that you get to know each other in a very short duration of time. We have regular meetings with our project mentors. The best part is that we can contact our mentors anytime. My mentor is Nilesh Chaturvedi who has guided me throughout the project and is still doing so. Alexandros Kazantzidis is also one of the mentors in the organization who cleared my doubts while building the propagation model.
Link to the organization repo.
The title of the project is Implementing Two-Line Element (TLE) Input / Output and using it for evaluation.
What is TLE?
Two-Line Element (TLE) is a data format or a way of encoding various parameters of an object orbiting Earth at any particular time point, an epoch. TLEs can describe the trajectories only of Earth-orbiting objects. It is widely used as an input for projecting the future orbital tracks of space objects. A TLE set may include a title line preceding the element data, so each listing may take up three lines in the file. The title is not required, as each data line includes a unique object identifier code. The two lines contain a lot of information about the object and have a length of 69 characters each.
The scripts that were added to the module are database initialization, scraper, parser, Gibb’s method, and propagation model. More details about each element are as follows:
Database contributes a major role in testing and generating the result of a module. In the beginning, we did not have TLE data. So, we decided that we will store TLEs from the celestrak website in the database. Now, it is time to choose which database we are going to use: SQL or NoSQL? Both the databases have their own advantages and disadvantages. After taking care of the needs and the data which we are going to store, we chose SQL based data. The reason behind this choice is that the input is well defined and structured. We only want to store 2 strings (that is, line 1 and line 2 of the TLE) at a particular time epoch. MySQL is used to store the data. The format of the data stored in the database is – timestamp, line 1 of TLE, line 2 of TLE. „[GSoC’18|Orbit-Determinator|Aakash] Implementing Two-Line Element (TLE) Input / Output and using it for evaluation“ weiterlesen
About the Author: Hello guys, I am Aakash Deep. I am an undergraduate student from Indraprastha Institute of Information Technology, Delhi (IIIT-D) in Computer Science and Engineering (CSE). I am a speed-cuber and, my hobby is solving Rubik's Cube. I am also founder of Rubik's Cube Club at IIIT-D.
The post is in the continuation of the series of posts from the past. To read those blogs use these links for blog1, blog2 and blog3.
- The database module was added earlier to create and maintain/update the database. For the database, we used MySQL.
- The Gibb’s Method was implemented and OOP concepts were used for the ease of use and better maintenance.
- Propagation Model was implemented and the output was making some sense.
„[GSoC’18|OrbitDeterminator|Aakash] Week #7-8 : Propagation Model“ weiterlesen
About the Author: Hello guys, I am Aakash Deep. I am an undergraduate student from Indraprastha Institute of Information Technology, Delhi (IIIT-D) in Computer Science and Engineering (CSE). I am a speed-cuber and, my hobby is solving Rubik's Cube.
The post is in the continuation of the series of posts from the past. You can access those post in the following links, blog1 and blog2.
- The database was created for this, a code was written initDatabase.py. The code is responsible for creating a database with all the necessary tables in the database.
- The database is maintained by the script scraper.py. The script updates tables of the database.
- The propagation model is implemented. For this, the SGP4 algorithm is used. The algorithm is computing state vectors (a pair of position vector and velocity vector) from the TLE.
Week 5 and 6
The Gibb’s method is implemented. It takes three position vectors as input and after computation gives one position vector and one velocity vector (both as combined also known as a state vector) as output. The OOP concepts are used in the implementation of Gibb’s method. The code is in gibbsMethod.py. By using OOP concepts it supports data abstraction and data encapsulation.
For input, a file is used from /example_data. It contains four attributes which are time, x coordinate, y coordinate and z coordinate. These are the position coordinates at that particular time epoch. As the file contains a lot of position vectors (8000 to be precise), a set of consecutive 3 vectors are used at a time for gibb’s method. Then for the next iteration, the first vector is removed and a new third vector is added to the set. As we are computing state vectors from a set of three vectors, it is obvious that the number of output state vectors is two less than the input position vectors. So, a vector is created by taking the previous length into consideration which holds all the output state vectors. The class also contains a function orbital_elements which converts these state vectors into the orbital elements.
The propagation model, SGP4 is also improved. Previously, the output is not making much sense but after revising it now the velocity vector is making sense. The output of the position vector is coming out to be constant for all the output state vector. Working on position vector in order to get a good output.
Work in Progress
About the Author: Hello guys, I am Aakash Deep. I am a B.Tech. student from Indraprastha Institute of Information Technology, Delhi (IIIT-D) in Computer Science and Engineering (CSE). I am a speed-cuber and obviously, my hobby is solving Rubik's Cube.
This post is in the continuation of my last post, as the last post contains the information about the first two weeks as being a GSoC student and the work done in that time frame. Those who missed it can access that post here.
Week 3 and 4
As the database was created earlier and now it is updating every day as the new TLEs are getting store into it. Now, the work left is implementing propagation model.
For the propagation algorithm, the SGP4 algorithm is used. The algorithm takes the TLE as input and computes position and velocity vectors. Now, we will come to the workflow of the code, that how the code is behaving. A sample test file is added to my github (can be found here). The file contains the multiple TLEs of a single satellite which is taken from the database. The code takes this as input and passes it to the propagation model. Then propagation model computes the position and velocity vectors of each TLE. After that, the averaging occurs and in the end, we get a single position and velocity vector. These vectors are then used to find the orbital elements of the satellite.
Phase 1 evaluation of the GSoC is nearby. The dates of the deadline are from June 11 to June 15. Following checkpoints are met before the deadline:
- Creating database
Creating the database and a table for mapping satellite’s name to its corresponding md5 hexadecimal hash and initializing tables in the database for each satellite.
- Scraping data from web
Scrape data from the celestrak site and populated it into the database into their respective tables.
- Maintaining database
Updating database whenever new TLE comes on the website.
- Implement Propagation Model
Converting TLE into position and velocity vector and then computing orbital elements. Now, there can be two ways to do it. We have a file containing multiple TLE of the same satellite at different time points.
The first way is, feeding this file as input. Compute position and velocity vector of every TLE and average these vectors to get a single vector. Use this averaged vector to calculate orbital elements.
The second way is, feeding the file as input. Compute position and velocity vector of each TLE and from these TLE calculate position and velocity vector for each pair of vector and then average the orbital elements. After this, we will get the averaged orbital elements.
Right now, I don’t know which way is better but we as a team trying to figure it out.
- Compute orbital elements
Calculates orbital elements from the given pair of position and velocity vector.
Work on Progress
About the author: Hello everyone, I am Aakash Deep, B.Tech student in Computer Science and Engineering (CSE) from Indraprastha Institute of Information Technology, Delhi (IIIT-D). Currently completed my 3rd year in it. I am a space enthusiast and always keep searching about the space.
Orbit Determinator, I think the project is self-explanatory. Yes, you are right the project is tracking the orbit of the satellites using their TLEs at different time points.
TLE short for Two-Line Element. It is a data format encoding a list of orbital elements of the Earth-orbiting object for a given point in time. It consists of two line with each having character length 70. Orbital elements play a major role in plotting the orbit of the satellite. Line2 of the TLE contains all the orbital elements. „[GSoC2018|OrbitDeterminator|Aakash] Implementing Two-Line Element (TLE) Input / Output and using it for evaluation“ weiterlesen