In 2017 Google summer of code I was involved in the project by AerospaceResearch.net called „Orbit position data analysis and interpolation“. Mainly, the project focused on methods and techniques that are used to preliminary determine a satellite orbit. More specifically, we initially had positional data sets in the format of (time, x, y, z) and we applied to them some smoothing – filtering techniques (Savintzky – Golay, Triple moving average) and then some methods for preliminary orbit determination (Lambert’s solution, Spline Interpolation). This project was created from scratch, meaning no prior work has been done. It was also applied not only to me, but also to another GSOC student Nilesh Chaturvedi, with whom we had great communication and cooperation leading to some good and interesting working results. The mentor of the project was Andreas Hornig and his insights and guidance provided us lots of help. Before I continue describing some more technical aspects of the project I would like to point out the github repository, which includes all the coding we did as part of the program and the documentation link for the project.
The programming language used for the project was Python 3.4 / 3.5 and libraries that are a core part of the project are Numpy, Matplotlib, Scipy, Pykep and Pytest. The very first coding I did as part of the program was, to get familiar with the data sets we are dealing with and try to perform some basic statistical filtering and create some graphs with matplotlib. Then, I dived deep into smoothing techniques and tried a lot of methods like median filters, FIR filters and Kalman but after many tests, I decided to use the Savintzky – Golay filter which was giving the best results for this kind of data I had. After applying the filter to my data set I quickly moved into creating some code for finding the keplerian elements (keplerian elements = orbit of the satellite) for all these data points I have. I researched a bit about methods for preliminary orbit determination and decided to go for Lambert’s solution and more specifically I decided to use Pykep library which has the method already implemented. So for every 2 points of the 8000 points data (leading to 7999 solutions) set I had, I solved the orbit determination problem and found lots of orbits. Now from all those 7999 different orbits described by 6 keplerian elements, I wanted to find the best approximation and I used Kalman filters to do that exactly. The results at first were not that good but combining my filter with Nilesh’s Triple moving average I managed to get some good approximations. After that, I created code for one more method for preliminary orbit determination called Gibb’s method. That algorithm though was really slow and it was not included in the final version of the program. One future plan I have for the program is to make this algorithm more „light“ so I can include it. Finally, lots of results are printed and graphs about the initial data, filtered data and final orbit are made to ensure the good presentation of the final computations. Into the whole process, lots of sub – functions and calculations needed to take place and they are located in the util directory. Into that directory a user can find algorithms that can transform cartesian to spherical coordinates, two algorithms to transform state vectors to keplerian elements and vice versa, one algorithm with a numerical integration method so that we make the final graph and one for finding the window for the Savintzky – Golay filter.
After finishing the core structure of the program the part of testing arrived, which was divided into two aspects. First was the unit testing with pytest and then massive testing with lots of satellite position data to find what combinations of algorithms function best or what windows and parameters I need to apply to the filters. For the first part, I created 15 general tests that achieved a pretty good coverage.