A Cython Bound Tracklet- Tracklet Correlation for Resident Space Objects

Almost all humankind depends on satellite technology orbiting the Earth. However, space operations are increasingly endangered by the rapidly growing number of orbiting objects and debris. To avoid collisions with debris particles and to keep the space infrastructure alive, it is mandatory to monitor cooperative and uncooperative resident space objects. For this purpose, we are developing a software system called Backbone Catalogue of Relational Debris Information (BACARDI). It provides a database with orbit information of resident space objects and related products like ephemerides, which enables us to derive close approaches and provide collision warnings. The challenge is to detect, identify and track new resident space objects that were recently launched, created by fragmentations and collisions or recently observed due to improved sensor tech-nologies. Typically, passive optical telescopes observe objects for a relatively short time. A short time series of observation is called a tracklet. To derive the full orbit of an object, at least a pair of tracklets is needed. In case the tracklets cannot be associated to an already known object, it should therefore be identified which tracklets belong to the same object. The algorithm performing this task is called the Tracklet- Tracklet Correlation (TTC). Our aim is to integrate the TTC into BACARDI. Therefore, we have to consider that the individual algorithm meets different requirements than the overall software. On the one hand, BAC- ARDI is a software system that needs to be easily maintainable, extendable and usable and is thus written in Python. On the other hand, the TTC has to be computationally fast, which is why it is written in C++. To fulfil these opposing requirements, we present a successful linkage of a fast C++ based TTC to a Python-based BACARDI. To perform this task, we used the pro-gramming language Cython. The Cython syntax is a superset of the Python syntax and provides additional rules to address C-like performance. This allows us to introduce wrapper code with C++ performance and a Python interface. In this paper we show our course of action to re-engineer a prototype C++ code into a high-quality stand-alone Python- package. To ensure high quality, sustainability and long-term maintainability, our steps include the transformation to an object-oriented C++ code, the utilization of well-known C++ libraries and introducing a software engineering process. Our software engineering process includes, but is not limited to, a predetermined communication and management structure, change management process and automated quality control. This is mostly implemented by GitLab functionality, which is also used to analyze and demonstrate advantages of the software engineering process. Moreover, we prove that it is highly useful to combine C++ code with Python by comparing the performance of a Cython-wrapped implementation and a pure Python implementation of the same algorithm, both in serial and in parallel. All of this is demonstrated on a large data set of real observations provided by SMARTnet. Our procedure can serve as a template for everyone who faces a similar challenge.