Recent Releases of celest

celest - 1.0.0

Celest 1.0.0 Release Notes - 26-09-2022

The 1.0.0 release had three key emphases: the addition of a satellite operations scheduler, unit compatibility, and an overhauled design for the fixed API release.

Satellite Operations Scheduler

The goal of the Celest library is mission planning for hyperspectral imaging satellite missions. One of the key problems in such mission profiles is not only determining when a satellite can image or transmit data to certain locations but also to schedule such tasks. The agile satellite scheduling problem for near optimal results is a difficult one.

In this release, an adaptive large neighborhood search metaheuristic algorithm with a simulated annealing acceptance criterion was used as the scheduling algorithm. Such an algorithm aims at finding the most optimal set of possible encounter times to maximize a cost score. This algorithm can be used via the Scheduler class in the schedule module (e.g. imported via from celest.schedule import Scheduler). More details about the scheduler and example usage can be found in the documentation here.

Unit Compatibility

Previously, Celest required input data to be of a specific unit and, similarly, only returned data in a specific unit. This behavior is undesirable and increases the potential for user error. The 1.0.0 release includes an overhaul of all main classes to be unit compatible with the introduction of the Unit, CompoundUnit, and Quantity classes. These classes allow users to specify the units of input data and convert data between units, thereby, providing more versatility and improved usability.

Overhauled Design

The previous structure of Celest had a poor design which made the program less modular and scalable. This posed significant issues for more advanced functionality to come. With the extensive effort to make the program unit compatible, it was seen worthwhile to simultaneously improve the programs structure. The structure change saw the addition of better abstraction layers, more specific classes, and reduced coupling between different functionality. Confident in the new design, the release has been made 1.0.0 instead of the intended 0.4.0 to demonstrate to users a fixed API.

- Python
Published by JaiWillems over 3 years ago

celest - 0.3.0

Celest 0.3.0 Release Notes - 29-04-2022

The 0.3.0 release had three key emphases: increased conversion fidelity, more accurate window finding, and a user-friendly interface. We should note that most of the changes are background changes; although, the instantiation of the Coordinate and Satellite classes are affected.

Increased Conversion Fidelity

The GCRS and ITRS conversions only accounted for Earth rotation for previous releases, and this provided conversions accurate to within 15km of the actual values. Such an error may prove insignificant or significant depending on the applications. Nutation and precession effects were accounted for to improve the GCRS and ITRS conversion, familiar to most Celest workflows, and reduced the error to below 500m. We note that polar motion effects were not accounted for due to their poor predictability.

More Accurate Window Finding

Previous window finding used a two-step technique; the initial step was an interpolation phase of the decision variable (e.g. altitude or off-nadir data) to isolate areas where encounters are likely. A refined interpolation would then occur to determine the window start and end times. Issues with the method above are twofold. First, the decision variables, particularly the altitude data, are vastly irregular making interpolation unreliable. Secondly, the error was lower bounded by the interpolation step.

An entire overhaul of the window generation process was done with the integration of the Polare library. The first shortfall of the previous method was addressed by performing the decision variable conversions using Polare's Stroke objects, which are incredibly robust to interpolating irregular data transforms. Additionally, the Stroke's "interpolant" behaviour allowed a root-finding technique to determine the exact crossover of the decision variable from the non-viable to viable encounter region within a user-defined tolerance.

Improved User Interface

A significant improvement to the user experience was made by inheriting the Time class in the Coordinate class and by inheriting the Coordinate class into the Satellite class. This change allows the latter two classes to be instantiated directly without the need to first instantiate the Time and Coordinate classes. For example, the Time and Coordinate classes had to be instantiated before the Satellite class; now, we can instantiate the Satellite class directly.

With the backend code depending entirely on Stroke's for conversions, continuous representations of position variables can now be returned to users as ' Stroke` objects. This change provides exciting flexibility, such as interpolating a position variable at the times of an encounter to determine satellite attitude during an imaging encounter.

Lastly, we incorporated error handling into many classes to provide error messages to inappropriate inputs. Additionally, the inputs have become more flexible to allow vectorized inputs to be passed in as lists, arrays, and tuples instead of purely as NumPy arrays.

- Python
Published by JaiWillems almost 4 years ago

celest - 0.2.0

Celest 0.2.0 Release Notes - 13-11-2021

This release has been in development for the last six months as a program overhaul to produce a scalable framework to move towards a stable user-program interface. With the overhaul came a framework remodel, process changes, and many feature additions.

Framework Remodel

The program structure of prior releases was constrained by the lack of proper abstractions and strict interdependency between various classes such as the Satellite and Encounter classes. Additionally, there existed confusing entity relationships, most predominantly seen with encounter generation which required Satellite, GroundPosition, EncounterSpec, and Encounter class initializations. Much of this functionality was redundant and provided user functionality that was not practical or useful.

The 0.2.0 release experienced an increase in the program abstractions through the following changes:

The Satellite class was remodelled to incorporate only high-level satellite-related calculations. As of now these satellite-dependent calculations are minimal but will be expanded in future releases through the incorporation of solar energy and solar radiation pressure calculations.
The Time and Coordinate classes were produced to strip the time and position conversion details from the Satellite class and perform only their respective conversions. This change allows for scalability in future releases. This change also induces clarity in the entities' purposes making user interactions more clear.
The Encounter class was reduced to a function to generate windows. The previous construction of the encounter workflow required an confusing interdependency with other classes which was clunky to use. Additionally, the Encounter class only contained one piece of useful functionality being window generation. Reducing down to one function made all the additional methods go private as they provided no use to users in the scope of the program. In this reconstruction, we were able to remove the need for the EncounterSpec class which unfortunately limits the encounters options available to user. We intend to increase the customizability of selected encounters in future releases.
The addition of the Windows and Window classes introduced more implementation-specific data structures that provide more meaning to users than do the previous NumPy arrays. They are also expandable to future additions of a scheduler program that will take in a Windows object and return the scheduled Windows object.

Process Changes

The development of Celest is taking on a more professional workflow through employing proper testing and validation procedures to ensure the presented library provides value to those who use it. Some specific development goals that have been learned over this past release are as follows:

Always produce production-ready code. This means we endeavour to create a program that is ALWAYS properly documented, formatted, tested, and validated before adding to the program. As such, the goal is for the library development to always be ready for a release when the time comes. This workflow will allow for better user documentation while the content is still fresh, as well as quick turnaround times.
Test-driven development and continuous integration. A new testing paradigm will be taken on to ensure code is mindfully developed by paying attention to inter-entity interactions and developing for future extensions.

Feature Additions

Time Class

The Time class was added to segregate Satellite class functionality. With the creation of the time class, the following time conversions were added:

True and mean solar time,
True and mean hour angle,
UT1,
datetime,
Greenwich mean and apparent sidereal times, and
Local mean and apparent sidereal times.

The incorporation of a sexagesimal function allows many of the Time class' angular returns to be displayed in a sexagesimal format.

Coordinate Class

Much like the Time class, the Coordinate class was added to remove the conversion methods from the Satellite class' scope. New conversions that have become available since the prior release include:

Geographical coordinate conversions,
Altitude calculations, and
Distance-to-location calculations.

With the Coordinate class, the ECI and ECEF terminology was switched to the GCRS and ITRS terminology as we are moving towards higher fidelity conversions that will be rigorously defined using IAU coordinate frame definitions.

The incorporation of a sexagesimal function allows the altitude and azimuthal coordinate returns to be displayed in a sexagesimal output. Additionally, functionality to allow geographical data to be returned in the ISO6709 format was added.

Private Coordinate and Time Dependencies

Many dependencies were required and will be required for coordinate and time conversions. These functions have been made private but we debate making them public in the scope of the project. Such functionality includes:

Nutation angles,
Nutation components,
Mean and apparent obliquity,
Julian to day-month-year conversions,
Julian to day-of-year conversions,
Equation of time,
Equation of equinoxes, and
Sun right ascension calculations.

Private Encounter Dependencies

The Encounter class was overhauled by making private many of the uninteresting methods. But most prominently, this release incorporates a new method of generating raw encounter opportunities using an analytical mathematical basis for encounter planning. Such a change makes encounter generation more efficient and is scalable to future "algorithmic" changes to improve runtime.

Private Satellite Attitude Calculations

Satellite attitude calculations necessary for ground tracking were added but not made public in the documentation due to residual issues. The code issues will be resolved and the process improved for future releases.

- Python
Published by JaiWillems over 4 years ago

celest - Version 0.1.9

Release 0.1.9 included the following changes: * Julian date and Julian offset method parameters, * Class and method type annotations, * Numpy style documentation strings, * Read the Docs documentation, * Satellite class .distance() and .altitude() methods, * Finalized API following PEP8 style guide, and * Encounter special interpolation functionality.

The Celest library is designed to provide a simple interface for satellite positional representations and encounter planning. * Documentation: https://celest.readthedocs.io/en/latest/ * Source Code: https://github.com/JaiWillems/Celest * PyPI: https://pypi.org/project/Celest/ * Bug Report or Feature Request: https://github.com/JaiWillems/Celest/issues

Refer to the repository's README file for further information and upcoming release details.

- Python
Published by JaiWillems almost 5 years ago

celest - Version 0.1.6

This is the initial re-release of the Celest python library designed to provide a simple interface for satellite positional representations and encounter planning.

Documentation: https://jaiwillems.github.io/Celest/
Source Code: https://github.com/JaiWillems/Celest/tree/main/celest
PyPI: https://pypi.org/project/Celest/