From 28df32bb9190aa6c8f18b27b68aea81eaf6b0bbd Mon Sep 17 00:00:00 2001 From: yeager7 Date: Wed, 6 May 2026 10:59:48 -0700 Subject: [PATCH 1/7] removing visualization dependencies, and some computations that are in the toolkit --- .docker/Dockerfile | 1 - README.rst | 187 ++-- devel/.gitignore | 2 - devel/angles_to_orbits.ipynb | 176 --- devel/catalog_to_apparent.c | 75 -- devel/export_cache.py | 15 - devel/import_cache.py | 13 - docs/README.rst | 31 +- docs/source/contribution_guide.rst | 424 ++------ pyproject.toml | 70 +- requirements.txt | 7 - ssapy/compute.py | 798 +------------- ssapy/io.py | 1146 +------------------- ssapy/plotUtils.py | 1305 +---------------------- ssapy/simple.py | 286 ----- ssapy/utils.py | 755 +------------ tests/devel/resolve_state_methods.ipynb | 555 ---------- tests/test_collision_event.py | 66 -- tests/test_plots.py | 196 ---- tests/test_plotutils.py | 137 --- tests/test_sampler.py | 16 +- 21 files changed, 290 insertions(+), 5971 deletions(-) delete mode 100644 devel/.gitignore delete mode 100644 devel/angles_to_orbits.ipynb delete mode 100644 devel/catalog_to_apparent.c delete mode 100644 devel/export_cache.py delete mode 100644 devel/import_cache.py delete mode 100644 ssapy/simple.py delete mode 100644 tests/devel/resolve_state_methods.ipynb delete mode 100644 tests/test_collision_event.py delete mode 100644 tests/test_plots.py delete mode 100644 tests/test_plotutils.py diff --git a/.docker/Dockerfile b/.docker/Dockerfile index bf5dc434..81e14674 100644 --- a/.docker/Dockerfile +++ b/.docker/Dockerfile @@ -29,7 +29,6 @@ RUN echo "sslverify=False" >> /etc/dnf/dnf.conf && \ # Install Python and some requirement dependencies RUN echo "sslverify=False" >> /etc/dnf/dnf.conf && \ dnf install -y epel-release && \ - dnf install -y hdf5 hdf5-devel && \ dnf install -y python3.12 python3.12-devel python3.12-pip && \ dnf -y clean all && \ sed -i '$ d' /etc/dnf/dnf.conf && \ diff --git a/README.rst b/README.rst index 4d612db2..51dbe9b3 100644 --- a/README.rst +++ b/README.rst @@ -1,149 +1,199 @@ +============================================== SSAPy - Space Situational Awareness for Python ============================================== -|ci_badge| |docs_badge| |codecov_badge| |joss_badge| |pypi-badge| +|ci_badge| |docs_badge| |codecov_badge| |joss_badge| |pypi_badge| .. |ci_badge| image:: https://github.com/LLNL/SSAPy/actions/workflows/ci.yml/badge.svg - :target: https://github.com/LLNL/SSAPy/actions/workflows/ci.yml + :target: https://github.com/LLNL/SSAPy/actions/workflows/ci.yml .. |docs_badge| image:: https://github.com/LLNL/SSAPy/actions/workflows/pages/pages-build-deployment/badge.svg - :target: https://LLNL.github.io/SSAPy + :target: https://LLNL.github.io/SSAPy .. |codecov_badge| image:: https://codecov.io/gh/LLNL/SSAPy/branch/main/graph/badge.svg - :target: https://codecov.io/gh/LLNL/SSAPy + :target: https://codecov.io/gh/LLNL/SSAPy .. |joss_badge| image:: https://joss.theoj.org/papers/a629353cbdd8d64a861bb807e12c5d06/status.svg :target: https://joss.theoj.org/papers/a629353cbdd8d64a861bb807e12c5d06 -.. |pypi-badge| image:: https://badge.fury.io/py/llnl-ssapy.svg - :target: https://badge.fury.io/py/llnl-ssapy +.. |pypi_badge| image:: https://badge.fury.io/py/llnl-ssapy.svg + :target: https://badge.fury.io/py/llnl-ssapy + +`SSAPy `_ is a fast, flexible, high-fidelity +orbital modeling and analysis tool for orbits spanning from low-Earth orbit +into the cislunar regime. -`SSAPy `_ is a fast, flexible, high-fidelity orbital modeling and analysis tool for orbits spanning from low-Earth orbit into the cislunar regime, and includes the following: +For higher-level utilities, convenience workflows, plotting tools, GCRF-to-ITRF +coordinate conversion helpers, Lambertian magnitude / brightness calculations, +and related extensions, see the companion project +`SSAPy-Toolkit `_. + +SSAPy includes: - Ability to define satellite parameters (area, mass, radiation and drag coefficients, etc.) -- Support for multiple data types (e.g., read in orbit from TLE file, define a set of Keplerian, Equinoctial, or Kozai Mean Keplerian elements, etc.) -- Define a fully customizable analytic force propagation model including the following: - - Earth gravity models (WGS84, EGM84, EGM96, EGM2008) - - Lunar gravity model (point source & harmonic) - - Radiation pressure (Earth & solar) - - Forces for all planets out to Neptune - - Atmospheric drag models - - Maneuvering (takes a user defined burn profile) -- Various community used integrators: SGP4, Runge-Kutta (4, 8, and 7/8), SciPy, Keplerian, Taylor Series -- User definable timesteps with the ability to return various parameters for any orbit and at any desired timestep (e.g., magnitude, state vector, TLE, Keplerian elements, periapsis, apoapsis, specific angular momentum, and many more.) -- Ground and space-based observer models -- Location and time of various lighting conditions of interest +- Support for multiple orbit representations and input types, including TLE-based + initialization and Keplerian, equinoctial, and Kozai mean Keplerian elements +- Fully customizable analytic force propagation models, including: + + - Earth gravity models (WGS84, EGM84, EGM96, EGM2008) + - Lunar gravity models (point source and harmonic) + - Radiation pressure (Earth and solar) + - Forces for planets out to Neptune + - Atmospheric drag models + - Maneuvering with user-defined burn profiles + +- Multiple integrators, including SGP4, Runge-Kutta (4, 8, and 7/8), SciPy, + Keplerian, and Taylor series methods +- User-definable timesteps and orbit information retrieval times, allowing + queries for quantities of interest such as magnitude, state vectors, TLEs, + Keplerian elements, periapsis, apoapsis, specific angular momentum, and more +- Ground- and space-based observer models +- Lighting and visibility condition analysis - Multiple-hypothesis tracking (MHT) UCT linker -- Vectorized computations (use of array broadcasting for fast computation, easily parallelizable and deployable on HPC machines) -- Short arc probabilistic orbit determination methods +- Vectorized computations using array broadcasting for efficient execution and + easy deployment on HPC systems +- Short-arc probabilistic orbit determination methods - Conjunction probability estimation - Built-in uncertainty quantification - Support for Monte Carlo runs and data fusion -- Support for multiple coordinate frames and coordinate frame conversions (GCRF, IERS, GCRS Cartesian, TEME Cartesian, ra/dec, NTW, zenith/azimuth, apparent positions, orthoginal tangent plane, and many more.) -- Various plotting capabilities (ground tracks, 3D orbit plotting, cislunar trajectory visualization, etc.) -- User definable timesteps and orbit information retrieval times, in which the user can query parameters of interest for that orbit and time. +- Support for multiple coordinate frames and coordinate transformations, + including GCRF, IERS, GCRS Cartesian, TEME Cartesian, RA/Dec, NTW, + zenith/azimuth, apparent positions, and orthogonal tangent plane coordinates Installation ------------ -For installation details, see the `Installing SSAPy `_ section of the documentation. +For installation details, see the +`Installing SSAPy `_ +section of the documentation. + +If you are looking for higher-level utilities or plotting-oriented workflows, +you may also want to install or explore +`SSAPy-Toolkit `_. Strict dependencies ------------------- - `Python `_ (3.8+) -The following are installed automatically when you install SSAPy: +The following Python packages are installed automatically when you install SSAPy: -- `numpy `_; -- `scipy `_ for many statistical functions; -- `astropy `_ for astronomy related functions; -- `pyerfa `_ a Python wrapper for the ERFA library; -- `emcee `_ an affine-invariant ensemble sampler for Markov chain Monte Carlo; -- `lmfit `_ a package for non-linear least-squares minimization and curve fitting; -- `sgp4 `_ contains functions to compute the positions of satellites in Earth orbit; -- `matplotlib `_ as a plotting backend; -- and other utility packages, as enumerated in `setup.py`. +- `numpy `_ +- `scipy `_ +- `astropy `_ +- `pyerfa `_ +- `emcee `_ +- `lmfit `_ +- `sgp4 `_ +- `jplephem `_ +- `ipyvolume `_ +- `tqdm `_ Documentation ------------- -All documentation is hosted at `https://LLNL.github.io/SSAPy/ `_. +The documentation is hosted at: -The API documentation may also be seen by doing: +`https://LLNL.github.io/SSAPy/ `_ + +The API documentation may also be explored interactively: .. code-block:: bash - python3 - >>> import ssapy - >>> help(ssapy) + python3 + +.. code-block:: python + + import ssapy + help(ssapy) Contributing ------------ -Contributing to SSAPy is relatively easy. Just send us a `pull request `_. When you send your request, make `main` the destination branch on the `SSAPy repository `_. +Contributing to SSAPy is straightforward. Please open a +`pull request `_ +targeting the ``main`` branch of the +`SSAPy repository `_. + +For work that primarily concerns plotting, dashboards, convenience utilities, +or higher-level workflows, please also consider whether the contribution belongs +in the companion repository +`SSAPy-Toolkit `_. -Your PR must pass SSAPy's unit tests and documentation tests, and must be `PEP 8 `_ compliant. We enforce these guidelines with our CI process. To run these tests locally, and for helpful tips on git, see our `Contribution Guide `_. +Your PR must pass SSAPy's required CI checks. For local testing guidance, +documentation builds, and Git workflow tips, see the +`Contribution Guide `_. -SSAPy's `main` branch has the latest contributions. Pull requests should target `main`, and users who want the latest package versions, features, etc. can use `main`. +SSAPy's ``main`` branch contains the latest development work. Releases -------- -For multi-user site deployments or other use cases that need very stable software installations, we recommend using SSAPy's `stable releases `_. +For stable installations, we recommend using one of SSAPy's tagged +`releases `_. -Each SSAPy release series also has a corresponding branch, e.g. `releases/v0.14` has `0.14.x` versions of SSAPy, and `releases/v0.13` has `0.13.x` versions. We backport important bug fixes to these branches but we do not advance the package versions or make other changes that would change the way SSAPy concretizes dependencies within a release branch. So, you can base your SSAPy deployment on a release branch and `git pull` to get fixes, without the package churn that comes with `main`. - -The latest release is always available with the `releases/latest` tag. - -See the `docs on releases `_ for more details. +The latest release is always available from the ``releases/latest`` tag. Code of Conduct --------------- -Please note that SSAPy has a `Code of Conduct `_. By participating in the SSAPy community, you agree to abide by its rules. +Please note that SSAPy has a +`Code of Conduct `_. +By participating in the SSAPy community, you agree to abide by its rules. Authors ------- -SSAPy was developed with support from Lawrence Livermore National Laboratory's (LLNL) Laboratory Directed Research and Development (LDRD) Program under projects -`19-SI-004 `_ and -`22-ERD-054 `_, by the following individuals (in alphabetical order): +SSAPy was developed with support from Lawrence Livermore National Laboratory's +(LLNL) Laboratory Directed Research and Development (LDRD) Program under projects +`19-SI-004 `_ +and +`22-ERD-054 `_, +by the following individuals (in alphabetical order): - `Robert Armstrong `_ (`LLNL `_) -- `Nathan Golovich `_ (`LLNL `_) - `Julia Ebert `_ (formerly `LLNL `_, now at Fleet Robotics) +- `Nathan Golovich `_ (`LLNL `_) - `Noah Lifset `_ (formerly `LLNL `_, now PhD student at `UT Austin `_) - `Dan Merl `_ (`LLNL `_) - Developer - `Joshua Meyers `_ (formerly `LLNL `_, now at `KIPAC `_) - Former Lead Developer - `Caleb Miller `_ (`LLNL `_) - `Alexx Perloff `_ (`LLNL `_) - `Kerianne Pruett `_ (formerly `LLNL `_) -- `Edward Schlafly `_ (formerly `LLNL `_, now `STScI `_) - Former Lead Developer +- `Edward Schlafly `_ (formerly `LLNL `_, now at `STScI `_) - Former Lead Developer - `Michael Schneider `_ (`LLNL `_) - Creator, Former Lead Developer - `Travis Yeager `_ (`LLNL `_) - Current Lead Developer -Many thanks go to SSAPy's other `contributors `_. - +Many thanks go to SSAPy's other +`contributors `_. Citing SSAPy -^^^^^^^^^^^^ +------------ -On GitHub, you can copy this citation in APA or BibTeX format via the "Cite this repository" button. -If you prefer MLA or Chicago style citations, see the comments in `CITATION.cff `_. +On GitHub, you can copy a citation in APA or BibTeX format via the +"Cite this repository" button. If you prefer MLA or Chicago style citations, +see the comments in +`CITATION.cff `_. -You may also cite the following publications (click `here `_ for list of BibTeX citations): +You may also cite the following publications (click +`here `_ +for BibTeX entries): - - Yeager, T., Pruett, K., & Schneider, M. (2022). *Unaided Dynamical Orbit Stability in the Cislunar Regime.* [Poster presentation]. Cislunar Security Conference, USA. - - Yeager, T., Pruett, K., & Schneider, M. (2023). *Long-term N-body Stability in Cislunar Space.* [Poster presentation]. Advanced Maui Optical and Space Surveillance (AMOS) Technologies Conference, USA. - - Yeager, T., Pruett, K., & Schneider, M. (2023, September). Long-term N-body Stability in Cislunar Space. In S. Ryan (Ed.), *Proceedings of the Advanced Maui Optical and Space Surveillance (AMOS) Technologies Conference* (p. 208). Retrieved from `https://amostech.com/TechnicalPapers/2023/Poster/Yeager.pdf `_ +- Yeager, T., Pruett, K., & Schneider, M. (2022). *Unaided Dynamical Orbit Stability in the Cislunar Regime.* Poster presentation, Cislunar Security Conference, USA. +- Yeager, T., Pruett, K., & Schneider, M. (2023). *Long-term N-body Stability in Cislunar Space.* Poster presentation, Advanced Maui Optical and Space Surveillance (AMOS) Technologies Conference, USA. +- Yeager, T., Pruett, K., & Schneider, M. (2023, September). Long-term N-body Stability in Cislunar Space. In S. Ryan (Ed.), *Proceedings of the Advanced Maui Optical and Space Surveillance (AMOS) Technologies Conference* (p. 208). Retrieved from `https://amostech.com/TechnicalPapers/2023/Poster/Yeager.pdf `_ License ------- -SSAPy is distributed under the terms of the MIT license. All new contributions must be made under the MIT license. +SSAPy is distributed under the terms of the MIT license. All new contributions +must be made under the MIT license. -See `Link to license `_ and `NOTICE `_ for details. +See the +`LICENSE `_ +and +`NOTICE `_ +files for details. SPDX-License-Identifier: MIT @@ -151,4 +201,7 @@ LLNL-CODE-862420 Documentation Inspiration ------------------------- -The structure and organization of this repository's documentation were inspired by the excellent design and layout of the `Coffea `_ project. + +The structure and organization of this repository's documentation were inspired +by the excellent design and layout of the +`Coffea `_ project. \ No newline at end of file diff --git a/devel/.gitignore b/devel/.gitignore deleted file mode 100644 index b8b472b6..00000000 --- a/devel/.gitignore +++ /dev/null @@ -1,2 +0,0 @@ -cache.zip -old_cache.zip diff --git a/devel/angles_to_orbits.ipynb b/devel/angles_to_orbits.ipynb deleted file mode 100644 index dbb0fc3d..00000000 --- a/devel/angles_to_orbits.ipynb +++ /dev/null @@ -1,176 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Angles to Orbits\n", - "\n", - "Explore the computations to convert angles-only measurements to orbit determinations as used in Stooker." - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "import astropy.units as u\n", - "\n", - "import ssa.planter.planter\n", - "import ssa.planter.streaksim as streaksim" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "start time (sec): 212129064000.0 s\n", - "exposure time (sec): 10.0 s\n", - "RA (deg.): 0.0 deg\n", - "DEC (deg.): 0.0 deg\n", - "RA (deg.): 0.0426272094227916 deg\n", - "DEC (deg.): 0.0 deg\n", - "x0: 76.729, y0: 0.000, L: 153 (arcsec), phi0: 0.000 (deg.)\n", - "x0: 0.021313604711395796 deg , y0: 0.0 deg\n" - ] - } - ], - "source": [ - "gsm = ssa.planter.planter.simulate_streak_from_orbit()" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - " 76.72897696102487 pix 0.0 pix 0.0 rad 100.0 adu / pix2 153.45795392204974 pix 2.52 pix" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "gsm" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "76.72897696102487 pix 0.0 pix\n", - "76.72897696102487 pix\n", - "153.45795392204974 pix 0.0 pix\n" - ] - } - ], - "source": [ - "dra = (gsm.L * np.cos(gsm.phi0) / 2.).to(u.pix)\n", - "ddec = (gsm.L * np.sin(gsm.phi0) / 2.).to(u.pix)\n", - "print(dra, ddec)\n", - "print(gsm.x0)\n", - "print(gsm.x0+dra, gsm.x0-dra)" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[[153.45795392 0. ]\n", - " [ 0. 0. ]] pix\n", - "[[76.72897696 0. ]\n", - " [ 0. 0. ]] arcsec\n" - ] - } - ], - "source": [ - "endpoints = gsm.endpoints_ang_pos()\n", - "print(endpoints)\n", - "\n", - "pixel_scale = 0.5 * u.arcsec / u.pix\n", - "endpoints *= pixel_scale\n", - "print(endpoints)" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [], - "source": [ - "x0_arcsec, y0_arcsec, L_arcsec, phi0 = streaksim.gaussian_streak_params_from_endpoints(\n", - " endpoints[0,0], endpoints[0,1],\n", - " endpoints[1,0], endpoints[1,1])\n", - "phi0 = (phi0.value % np.pi) * u.rad" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "38.364488480512435 arcsec 0.0 arcsec 76.72897696102487 arcsec 0.0 rad\n" - ] - } - ], - "source": [ - "print(x0_arcsec, y0_arcsec, L_arcsec, phi0)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.7.0" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/devel/catalog_to_apparent.c b/devel/catalog_to_apparent.c deleted file mode 100644 index 2c93989a..00000000 --- a/devel/catalog_to_apparent.c +++ /dev/null @@ -1,75 +0,0 @@ -// Script used to unit test proper motion, parallax, and aberration corrections in SSA library. - -#include -#include "sofa.h" - -void reprd ( char*, double, double ); - -int main () { - iauASTROM astrom; - double utc1, utc2, tai1, tai2, tt1, tt2, - rc, dc, pr, pd, px, rv, - eo, ri, di, rca, dca; -/* UTC date. */ - if ( iauDtf2d ( "UTC", 2013, 4, 2, 23, 15, 43.55, - &utc1, &utc2 ) ) return -1; -/* TT date. */ - if ( iauUtctai ( utc1, utc2, &tai1, &tai2 ) ) return -1; - if ( iauTaitt ( tai1, tai2, &tt1, &tt2 ) ) return -1; -/* Star ICRS RA,Dec (radians). */ - if ( iauTf2a ( ' ', 14, 34, 16.81183, &rc ) ) return -1; - if ( iauAf2a ( '-', 12, 31, 10.3965, &dc ) ) return -1; - reprd ( "ICRS, epoch J2000.0:", rc, dc ); -/* Proper motion */ - pr = atan2 ( -354.45e-3 * DAS2R, cos(dc) ); - pd = 595.35e-3 * DAS2R; - px = 0.0; - rv = 0.0; - iauAtci13 ( rc, dc, pr, pd, px, rv, tt1, tt2, &ri, &di, &eo ); - iauAtic13 ( ri, di, tt1, tt2, &rca, &dca, &eo ); - reprd ( "Try proper motion:", rca, dca ); -/* Parallax */ - pr = 0.0; - pd = 0.0; - px = 0.16499; - rv = 0.0; - iauAtci13 ( rc, dc, pr, pd, px, rv, tt1, tt2, &ri, &di, &eo ); - iauAtic13 ( ri, di, tt1, tt2, &rca, &dca, &eo ); - reprd ( "Try parallax:", rca, dca ); -/* aberration */ - pr = 0.0; - pd = 0.0; - px = 0.0; - rv = 0.0; - double pco[3], ppr[3], rg, dg, w; - iauApcg13(tt1, tt2, &astrom); - iauPmpx(rc, dc, pr, pd, px, rv, astrom.pmt, astrom.eb, pco); - iauAb(pco, astrom.v, astrom.em, astrom.bm1, ppr); - iauC2s(ppr, &w, &dg); - rg = iauAnp(w); - reprd ( "aberration:", rg, dg); -/* all of above */ - pr = atan2 ( -354.45e-3 * DAS2R, cos(dc) ); - pd = 595.35e-3 * DAS2R; - px = 0.16499; - rv = 0.0; - iauApcg13(tt1, tt2, &astrom); - iauPmpx(rc, dc, pr, pd, px, rv, astrom.pmt, astrom.eb, pco); - iauAb(pco, astrom.v, astrom.em, astrom.bm1, ppr); - iauC2s(ppr, &w, &dg); - rg = iauAnp(w); - reprd ( "all above:", rg, dg); - - return 0; -} - -void reprd ( char* s, double ra, double dc ) -{ - char pm; - int i[4]; - printf ( "%25s", s ); - iauA2tf ( 7, ra, &pm, i ); - printf ( " %2.2d %2.2d %2.2d.%7.7d", i[0],i[1],i[2],i[3] ); - iauA2af ( 6, dc, &pm, i ); - printf ( " %c%2.2d %2.2d %2.2d.%6.6d\n", pm, i[0],i[1],i[2],i[3] ); -} diff --git a/devel/export_cache.py b/devel/export_cache.py deleted file mode 100644 index b399122c..00000000 --- a/devel/export_cache.py +++ /dev/null @@ -1,15 +0,0 @@ -import numpy as np -import astropy.units as u -from astropy.time import Time -import astropy.utils.data as aud - -print("Current cached urls:") -print(aud.get_cached_urls()) - -# aud.clear_download_cache() -print(Time.now().delta_ut1_utc) # requires finals2000A.all -Time("J2018") + np.linspace(-40, 0, 1000)*u.year - -print("New cached urls:") -print(aud.get_cached_urls()) -aud.export_download_cache("cache.zip") diff --git a/devel/import_cache.py b/devel/import_cache.py deleted file mode 100644 index e88a1637..00000000 --- a/devel/import_cache.py +++ /dev/null @@ -1,13 +0,0 @@ -import astropy.utils.data as aud - -print("Current cached urls:") -print(aud.get_cached_urls()) -print("Saving old cache to old_cache.zip") -aud.export_download_cache("old_cache.zip") -aud.clear_download_cache() -print("Cleared cached urls:") -print(aud.get_cached_urls()) -print("Importing from cache.zip") -aud.import_download_cache("cache.zip") -print("New cached urls:") -print(aud.get_cached_urls()) diff --git a/docs/README.rst b/docs/README.rst index 7cc84a0d..7d0161f1 100644 --- a/docs/README.rst +++ b/docs/README.rst @@ -1,22 +1,39 @@ +=================== SSAPy Documentation =================== Building the docs ----------------- -First, build and _install_ `ssapy` following the `Installing SSAPy `_ section of the documentation. +First, build and *install* ``ssapy`` by following the +`Installing SSAPy `_ +section of the documentation. + +If needed, install the documentation dependencies: + +.. code-block:: bash + + pip install -r requirements.txt -Then, to build the HTML documentation locally, from the `docs` directory, run +Then, from the ``docs`` directory, build the HTML documentation locally with: .. code-block:: bash make html -(run it twice to generate all files.) +You may need to run this command twice to generate all files correctly. + +Then open ``_build/html/index.html`` in a browser to view the documentation locally. + +Alternatively, you can run: + +.. code-block:: bash -Then open `_build/html/index.html` to browse the docs locally. + sphinx-autobuild source _build/html -Alternatively, you can run `sphinx-autobuild source _build/html` to start a server that watches for changes in `/docs` -and regenerates the HTML docs automatically while serving them at http://127.0.0.1:8000/. +This starts a local server that watches for changes in ``docs/`` and +automatically rebuilds the HTML documentation while serving it at +http://127.0.0.1:8000/. -Note that if you updated docstrings, you'll need to re-build and re-install ssapy before re-building the docs. +Note that if you update docstrings, you may need to rebuild and reinstall +``ssapy`` before rebuilding the documentation. \ No newline at end of file diff --git a/docs/source/contribution_guide.rst b/docs/source/contribution_guide.rst index e0ab3398..e52561f4 100644 --- a/docs/source/contribution_guide.rst +++ b/docs/source/contribution_guide.rst @@ -8,430 +8,217 @@ Contribution Guide ================== -This guide is intended for developers or administrators who want to -contribute a new feature or bugfix to SSAPy. -It assumes that you have at least some familiarity with Git and GitHub. -The guide will show a few examples of contributing workflows and discuss -the granularity of pull-requests (PRs). It will also discuss the tests your -PR must pass in order to be accepted into SSAPy. +This guide is intended for developers and administrators who want to +contribute a new feature or bug fix to SSAPy. It assumes some familiarity +with Git and GitHub. -First, what is a PR? Quoting `Bitbucket's tutorials `_: +A pull request (PR) is the primary mechanism for contributing changes to +SSAPy. In general, each PR should correspond to a single completed feature, +bug fix, refactor, or documentation improvement. Smaller, focused PRs are +much easier to review and maintain than large PRs covering unrelated changes. - Pull requests are a mechanism for a developer to notify team members that - they have **completed a feature**. The pull request is more than just a - notification—it’s a dedicated forum for discussing the proposed feature. - -The emphasis is on a **completed feature**. The changes one proposes in a PR should -correspond to one feature/bugfix/extension/etc. One can create PRs with -changes relevant to different ideas, however reviewing such PRs becomes tedious -and error prone. If possible, try to follow the **one-PR-one-feature** rule. +If possible, follow a **one PR, one feature** rule. -------- Branches -------- -SSAPy's ``main`` branch has the latest contributions. Nearly all pull +SSAPy's ``main`` branch contains the latest development work. Nearly all pull requests should start from ``main`` and target ``main``. -There is a branch for each major release series. Release branches -originate from ``main`` and have tags for each point release in the -series. For example, ``releases/v0.14`` might have tags for ``0.14.0``, -``0.14.1``, ``0.14.2``, etc. versions of SSAPy. We backport important bug -fixes to these branches, but we do not advance the package versions or -make other changes that would change the way SSAPy concretizes -dependencies. Currently, the maintainers manage these branches by -cherry-picking from ``main``. See :ref:`releases` for more -information. +There may also be release branches for major release series. Important bug +fixes may be backported to those branches by the maintainers as needed. ---------------------- Continuous Integration ---------------------- -SSAPy uses `Github Actions `_ for Continuous Integration -testing. This means that every time you submit a pull request, a series of tests will -be run to make sure you didn't accidentally introduce any bugs into SSAPy. **Your PR -will not be accepted until it passes all of these tests.** While you can certainly wait -for the results of these tests after submitting a PR, we recommend that you run them -locally to speed up the review process. - -.. note:: +SSAPy uses `GitHub Actions `_ for +continuous integration (CI). Every pull request and relevant push will trigger +automated checks such as package builds, tests, and documentation builds. - Oftentimes, CI will fail for reasons other than a problem with your PR. - For example, apt-get, pip, or homebrew will fail to download one of the - dependencies for the test suite, or a transient bug will cause the unit tests - to timeout. If any job fails, click the "Details" link and click on the test(s) - that is failing. If it doesn't look like it is failing for reasons related to - your PR, you have two options. If you have write permissions for the SSAPy - repository, you should see a "Restart workflow" button on the right-hand side. If - not, you can close and reopen your PR to rerun all of the tests. If the same - test keeps failing, there may be a problem with your PR. If you notice that - every recent PR is failing with the same error message, it may be that an issue - occurred with the CI infrastructure or one of SSAPy's dependencies put out a - new release that is causing problems. If this is the case, please file an issue. +**Your PR will not be accepted until the required CI checks pass.** +Sometimes CI fails for reasons unrelated to your PR, such as transient network +issues or package manager failures. If this happens, inspect the failing job in +GitHub Actions before assuming your changes are at fault. If the failure appears +transient, rerun the workflow if you have permission, or push a small follow-up +commit / reopen the PR to trigger CI again. -We currently test against Python 3.10 on both macOS and Linux and -perform 3 types of tests: - -.. _cmd-ssapy-unit-test: +The exact test matrix may change over time. Refer to the repository's GitHub +Actions workflow files for the current platforms and Python versions being +tested. ^^^^^^^^^^ Unit Tests ^^^^^^^^^^ -Unit tests ensure that core SSAPy features like fetching or spec resolution are -working as expected. If your PR only adds new packages or modifies existing ones, -there's very little chance that your changes could cause the unit tests to fail. -However, if you make changes to SSAPy's core libraries, you should run the unit -tests to make sure you didn't break anything. - -Since they test things like fetching from VCS repos, the unit tests require -`git `_, `mercurial `_, -and `subversion `_ to run. Make sure these are -installed on your system and can be found in your ``PATH``. All of these can be -installed with SSAPy or with your system package manager. +SSAPy uses `pytest `_ for unit testing. -To run *all* of the unit tests, use: +To run the full test suite locally: .. code-block:: console - $ ssapy unit-test + $ pytest -v -These tests may take several minutes to complete. If you know you are -only modifying a single SSAPy feature, you can run subsets of tests at a -time. For example, this would run all the tests in -``tests/*.py``: +To run a specific test file: .. code-block:: console - $ ssapy unit-test tests/*.py + $ pytest -v tests/test_compute.py -This allows you to develop iteratively: make a change, test that change, -make another change, test that change, etc. We use `pytest -`_ as our tests framework, and these types of -arguments are just passed to the ``pytest`` command underneath. See `the -pytest docs -`_ -for more details on test selection syntax. - -By default, ``pytest`` captures the output of all unit tests, and it will -print any captured output for failed tests. Sometimes it's helpful to see -your output interactively, while the tests run (e.g., if you add print -statements to a unit tests). To see the output *live*, use the ``-s`` -argument to ``pytest``: +To run a specific test: .. code-block:: console - $ ssapy unit-test -s --list-long tests/architecture.py::test_platform - -Unit tests are crucial to making sure bugs aren't introduced into -SSAPy. If you are modifying core SSAPy libraries or adding new -functionality, please add new unit tests for your feature, and consider -strengthening existing tests. You will likely be asked to do this if you -submit a pull request to the SSAPy project on GitHub. Check out the -`pytest docs `_ and feel free to ask for guidance on -how to write tests! - -^^^^^^^^^^^^ -Style Tests -^^^^^^^^^^^^ - -SSAPy uses `Flake8 `_ to test for -`PEP 8 `_ conformance and -`mypy ` for type checking. PEP 8 is -a series of style guides for Python that provide suggestions for everything -from variable naming to indentation. In order to limit the number of PRs that -were mostly style changes, we decided to enforce PEP 8 conformance. Your PR -needs to comply with PEP 8 in order to be accepted, and if it modifies the -ssapy library it needs to successfully type-check with mypy as well. + $ pytest -v tests/test_compute.py::test_example -Testing for compliance with ssapy's style is easy. Simply run the ``ssapy style`` -command: +To see test output live while tests run: .. code-block:: console - $ ssapy style - -``ssapy style`` has a couple advantages over running the tools by hand: - -#. It only tests files that you have modified since branching off of - ``main``. - -#. It works regardless of what directory you are in. - -#. It automatically adds approved exemptions from the ``flake8`` - checks. For example, URLs are often longer than 80 characters, so we - exempt them from line length checks. We also exempt lines that start - with "homepage", "url", "version", "variant", "depends_on", and - "extends" in ``package.py`` files. This is now also possible when directly - running flake8 if you can use the ``ssapy`` formatter plugin included with - ssapy. - -More approved flake8 exemptions can be found -`here `_. + $ pytest -v -s -If all is well, you'll see something like this: +If your PR changes core SSAPy functionality, please run the relevant tests +locally before submitting the PR. If you add new functionality or fix a bug, +please also add or update tests where appropriate. -.. code-block:: console - - $ run-flake8-tests - Dependencies found. - ======================================================= - flake8: running flake8 code checks on SSAPy. - - Modified files: +^^^^^^^^^^^ +Style Tests +^^^^^^^^^^^ - var/ssapy/repos/builtin/packages/hdf5/package.py - var/ssapy/repos/builtin/packages/hdf/package.py - var/ssapy/repos/builtin/packages/netcdf/package.py - ======================================================= - Flake8 checks were clean. +SSAPy uses `Flake8 `_ for style checking. -However, if you aren't compliant with PEP 8, flake8 will complain: +To run style checks locally: .. code-block:: console - var/ssapy/repos/builtin/packages/netcdf/package.py:26: [F401] 'os' imported but unused - var/ssapy/repos/builtin/packages/netcdf/package.py:61: [E303] too many blank lines (2) - var/ssapy/repos/builtin/packages/netcdf/package.py:106: [E501] line too long (92 > 79 characters) - Flake8 found errors. + $ flake8 ssapy tests devel -Most of the error messages are straightforward, but if you don't understand what -they mean, just ask questions about them when you submit your PR. The line numbers -will change if you add or delete lines, so simply run ``ssapy style`` again -to update them. - -.. tip:: - - Try fixing flake8 errors in reverse order. This eliminates the need for - multiple runs of ``ssapy style`` just to re-compute line numbers and - makes it much easier to fix errors directly off of the CI output. +Please ensure that any code you contribute passes the project's style checks. +If additional static analysis tools are enabled in CI in the future, contributors +should also ensure those checks pass before requesting review. ^^^^^^^^^^^^^^^^^^^ Documentation Tests ^^^^^^^^^^^^^^^^^^^ -SSAPy uses `Sphinx `_ to build its -documentation. In order to prevent things like broken links and missing imports, -we added documentation tests that build the documentation and fail if there -are any warning or error messages. - -Building the documentation requires several dependencies: +SSAPy uses `Sphinx `_ to build documentation. -* docutils -* sphinx -* sphinx-rtd-theme -* sphinx-copybutton -* sphinx-autobuild -* sphinx-tabs -* sphinx-automodapi -* myst-parser -* graphviz - -All of these can be installed with Pip, e.g. +To build the documentation locally: .. code-block:: console - $ python3 -m pip install docutils sphinx, sphinx-rtd-theme sphinx-copybutton sphinx-autobuild sphinx-tabs sphinx-automodapi myst-parser graphviz - -Once all of the dependencies are installed, you can try building the documentation: - -.. code-block:: console - - $ cd path/to/ssapy/docs/ + $ pip install -r docs/requirements.txt + $ cd docs $ make clean - $ make + $ make html + +If your PR changes documentation, public APIs, or import structure, please build +the docs locally to make sure they still render correctly. -If you see any warning or error messages, you will have to correct those before your PR -is accepted. If you are editing the documentation, you should be running the -documentation tests to make sure there are no errors. Documentation changes can result -in some obfuscated warning messages. If you don't understand what they mean, feel free -to ask when you submit your PR. +Depending on the current documentation configuration, additional system packages +such as ``graphviz`` may be required. -------- Coverage -------- -SSAPy uses `Codecov `_ to generate and report unit test -coverage. This helps us tell what percentage of lines of code in SSAPy are -covered by unit tests. Although code covered by unit tests can still contain -bugs, it is much less error prone than code that is not covered by unit tests. - -Codecov provides `browser extensions `_ -for Google Chrome and Firefox. These extensions integrate with GitHub -and allow you to see coverage line-by-line when viewing the SSAPy repository. -If you are new to SSAPy, a great way to get started is to write unit tests to -increase coverage! - -Unlike with CI on Github Actions Codecov tests are not required to pass in order for your -PR to be merged. If you modify core SSAPy libraries, we would greatly -appreciate unit tests that cover these changed lines. Otherwise, we have no -way of knowing whether or not your changes introduce a bug. If you make -substantial changes to the core, we may request unit tests to increase coverage. - -.. note:: - - You may notice that the Codecov tests fail even though - you didn't modify any core files. This means that SSAPy's overall coverage - has increased since you branched off of ``main``. This is a good thing! - If you really want to get the Codecov tests to pass, you can rebase off of - the latest ``main``, but again, this is not required. +SSAPy uses `Codecov `_ to report unit test coverage. +Coverage checks help identify whether changed code is exercised by tests. +Although coverage alone does not guarantee correctness, changes to core library +code should ideally be accompanied by tests covering the modified behavior. ------------- Git Workflows ------------- -SSAPy is still in the beta stages of development. Most of our users run off of -the ``main`` branch, and fixes and new features are constantly being merged. So -how do you keep up-to-date with upstream while maintaining your own local -differences and contributing PRs to SSAPy? +SSAPy development is active, and ``main`` may change frequently. To keep your +work manageable and reviewable, it is best to make changes on a dedicated branch. ^^^^^^^^^ Branching ^^^^^^^^^ -The easiest way to contribute a pull request is to make all of your changes on -new branches. Make sure your ``main`` is up-to-date and create a new branch -off of it: +Start by updating your local ``main`` branch and creating a new feature branch: .. code-block:: console $ git checkout main $ git pull upstream main - $ git branch - $ git checkout + $ git checkout -b -Here we assume that the local ``main`` branch tracks the upstream ``main`` -branch of SSAPy. This is not a requirement and you could also do the same with -remote branches. But for some it is more convenient to have a local branch that -tracks upstream. - -Normally we prefer that commits pertaining to a package ```` have -a message ``: descriptive message``. It is important to add -descriptive message so that others, who might be looking at your changes later -(in a year or maybe two), would understand the rationale behind them. - -Now, you can make your changes while keeping the ``main`` branch pure. -Edit a few files and commit them by running: +Make your changes, then commit them in logically grouped commits: .. code-block:: console - $ git add - $ git commit --message + $ git add + $ git commit -m "" -Next, push it to your remote fork and create a PR: +Push the branch to your fork: .. code-block:: console $ git push origin --set-upstream -GitHub provides a `tutorial `_ -on how to file a pull request. When you send the request, make ``main`` the -destination branch. - -If you need this change immediately and don't have time to wait for your PR to -be merged, you can always work on this branch. But if you have multiple PRs, -another option is to maintain a Frankenstein branch that combines all of your -other branches: +Then open a pull request targeting ``main``. -.. code-block:: console - - $ git checkout main - $ git branch - $ git checkout - $ git merge - -This can be done with each new PR you submit. Just make sure to keep this local -branch up-to-date with upstream ``main`` too. +Please use descriptive commit messages so future contributors can understand the +intent of the changes. ^^^^^^^^^^^^^^ Cherry-Picking ^^^^^^^^^^^^^^ -What if you made some changes to your local modified ``main`` branch and already -committed them, but later decided to contribute them to SSAPy? You can use -cherry-picking to create a new branch with only these commits. - -First, check out your local modified ``main`` branch: - -.. code-block:: console - - $ git checkout +If you already made commits on another branch and later decide to submit some of +them upstream, you can create a new branch from ``main`` and cherry-pick the +relevant commits. -Now, get the hashes of the commits you want from the output of: +First, find the commit hashes you want: .. code-block:: console $ git log -Next, create a new branch off of upstream ``main`` and copy the commits -that you want in your PR: +Then create a branch from updated ``main`` and cherry-pick the commits: .. code-block:: console $ git checkout main $ git pull upstream main - $ git branch - $ git checkout + $ git checkout -b $ git cherry-pick - $ git push origin --set-upstream - -Now you can create a PR from the web-interface of GitHub. The net result is as -follows: -#. You patched your local version of SSAPy and can use it further. -#. You "cherry-picked" these changes in a stand-alone branch and submitted it - as a PR upstream. +Push the new branch and open a pull request: -Should you have several commits to contribute, you could follow the same -procedure by getting hashes of all of them and cherry-picking to the PR branch. - -.. note:: - - It is important that whenever you change something that might be of - importance upstream, create a pull request as soon as possible. Do not wait - for weeks/months to do this, because: +.. code-block:: console - #. you might forget why you modified certain files - #. it could get difficult to isolate this change into a stand-alone clean PR. + $ git push origin --set-upstream ^^^^^^^^ Rebasing ^^^^^^^^ -Other developers are constantly making contributions to SSAPy, possibly on the -same files that your PR changed. If their PR is merged before yours, it can -create a merge conflict. This means that your PR can no longer be automatically -merged without a chance of breaking your changes. In this case, you will be -asked to rebase on top of the latest upstream ``main``. - -First, make sure your ``main`` branch is up-to-date: +If ``main`` has moved forward and your branch has conflicts or is out of date, +rebase your branch on top of the latest ``main``: .. code-block:: console $ git checkout main $ git pull upstream main - -Now, we need to switch to the branch you submitted for your PR and rebase it -on top of ``main``: - -.. code-block:: console - $ git checkout $ git rebase main -Git will likely ask you to resolve conflicts. Edit the file that it says can't -be merged automatically and resolve the conflict. Then, run: +If Git reports conflicts, resolve them, then continue: .. code-block:: console - $ git add + $ git add $ git rebase --continue -You may have to repeat this process multiple times until all conflicts are resolved. -Once this is done, simply force push your rebased branch to your remote fork: +Repeat until the rebase completes. Then force-push the updated branch: .. code-block:: console @@ -441,24 +228,23 @@ Once this is done, simply force push your rebased branch to your remote fork: Rebasing with cherry-pick ^^^^^^^^^^^^^^^^^^^^^^^^^ -You can also perform a rebase using ``cherry-pick``. First, create a temporary -backup branch: +You can also rebase manually by resetting a branch to ``main`` and cherry-picking +back the commits you want to keep. + +Create a backup branch first: .. code-block:: console $ git checkout $ git branch tmp -If anything goes wrong, you can always go back to your ``tmp`` branch. -Now, look at the logs and save the hashes of any commits you would like to keep: +Record the commit hashes you want to preserve: .. code-block:: console $ git log -Next, go back to the original branch and reset it to ``main``. -Before doing so, make sure that you local ``main`` branch is up-to-date -with upstream: +Update ``main`` and reset your working branch: .. code-block:: console @@ -467,20 +253,20 @@ with upstream: $ git checkout $ git reset --hard main -Now you can cherry-pick relevant commits: +Then cherry-pick the desired commits: .. code-block:: console $ git cherry-pick $ git cherry-pick -Push the modified branch to your fork: +Push the updated branch: .. code-block:: console $ git push --force origin -If everything looks good, delete the backup branch: +If everything looks good, remove the backup branch: .. code-block:: console @@ -490,39 +276,33 @@ If everything looks good, delete the backup branch: Re-writing History ^^^^^^^^^^^^^^^^^^ -Sometimes you may end up on a branch that has diverged so much from ``main`` -that it cannot easily be rebased. If the current commits history is more of -an experimental nature and only the net result is important, you may rewrite -the history. +Sometimes a branch diverges so far from ``main`` that a clean rebase is difficult. +If only the final result matters, you may choose to rewrite the branch history. -First, merge upstream ``main`` and reset you branch to it. On the branch -in question, run: +On the branch in question: .. code-block:: console $ git merge main $ git reset main -At this point your branch will point to the same commit as ``main`` and -thereby the two are indistinguishable. However, all the files that were -previously modified will stay as such. In other words, you do not lose the -changes you made. Changes can be reviewed by looking at diffs: +At this point, your branch points to the same commit as ``main``, but your local +file modifications remain in the working tree. Review them with: .. code-block:: console $ git status $ git diff -The next step is to rewrite the history by adding files and creating commits: +Then create a new, clean set of commits: .. code-block:: console - $ git add - $ git commit --message + $ git add + $ git commit -m "" -After all changed files are committed, you can push the branch to your fork -and create a PR: +Finally, push the rewritten branch to your fork and open or update the PR: .. code-block:: console - $ git push origin --set-upstream + $ git push --force origin \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index a53cde0f..aa11e85e 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -2,37 +2,48 @@ name = "llnl-ssapy" version = "1.1.4" authors = [ - { name="LLNL SSAPy Software Team", email="yeagerastro@gmail.com" }, + { name = "LLNL SSAPy Software Team", email = "yeagerastro@gmail.com" }, ] description = "A fast, flexible, high-fidelity orbital modeling and analysis tool for orbits spanning from low-Earth orbit into the cislunar regime." readme = "README.rst" requires-python = ">=3.8" +license = { file = "LICENSE" } + classifiers = [ "Programming Language :: Python :: 3", "Operating System :: OS Independent", ] -license = { file = "LICENSE" } + dependencies = [ - 'numpy', - 'scipy', - 'astropy', - 'pyerfa', - 'emcee', - 'lmfit', - 'sgp4', - 'matplotlib', - 'pandas', - 'h5py', - 'pypdf2', - 'imageio', - 'ipython', - 'ipyvolume', - 'ipython_genutils', - 'jplephem', - 'tqdm', - 'myst-parser', - 'graphviz', - ] + "numpy", + "scipy", + "astropy", + "pyerfa", + "emcee", + "lmfit", + "sgp4", + "ipyvolume", + "jplephem", + "tqdm", +] + +[project.optional-dependencies] +dev = [ + "pytest", + "build", + "cibuildwheel", + "delocate", +] + +docs = [ + "myst-parser", + "graphviz", +] + +[project.urls] +Homepage = "https://github.com/LLNL/SSAPy" +Issues = "https://github.com/LLNL/SSAPy/issues" +Documentation = "https://software.llnl.gov/SSAPy/" [build-system] requires = ["setuptools>=42", "wheel", "scikit-build", "cmake"] @@ -45,20 +56,7 @@ include-package-data = true [tool.setuptools.package-data] ssapy = ["*.cpp", "*.h", "data/*", "*.so"] -[tool.poetry] -packages = [ - { include = "ssapy" }, -] - -[tool.poetry.include] -files = ["ssapy/_ssapy.cpython-38-x86_64-linux-gnu.so"] - [tool.pytest.ini_options] testpaths = ["tests"] timeout = 30 -timeout_method = "thread" - -[project.urls] -Homepage = "https://github.com/LLNL/SSAPy" -Issues = "https://github.com/LLNL/SSAPy/issues" -Documentation = "https://software.llnl.gov/SSAPy/" +timeout_method = "thread" \ No newline at end of file diff --git a/requirements.txt b/requirements.txt index 13a43f0e..71745106 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,7 +1,5 @@ graphviz numpy -pandas -h5py scipy jplephem astropy @@ -9,13 +7,8 @@ pyerfa emcee lmfit sgp4 -matplotlib -pypdf2 -ipyvolume -ipython_genutils ipython pytest -imageio tqdm build cibuildwheel diff --git a/ssapy/compute.py b/ssapy/compute.py index c7869341..5c62c446 100644 --- a/ssapy/compute.py +++ b/ssapy/compute.py @@ -6,12 +6,11 @@ from astropy.time import Time import astropy.units as u -from .body import get_body -from .constants import RGEO, LD, EARTH_RADIUS, EARTH_MU, MOON_RADIUS, MOON_MU +from .constants import EARTH_RADIUS, EARTH_MU from .propagator import KeplerianPropagator from .utils import ( - norm, normed, unitAngle3, get_angle, LRU_Cache, lb_to_unit, sunPos, _gpsToTT, - iers_interp, rotation_matrix_from_vectors, angle_between_vectors, gcrf_to_itrf + norm, normed, unitAngle3, LRU_Cache, lb_to_unit, sunPos, _gpsToTT, + iers_interp ) from .orbit import Orbit from .ellipsoid import Ellipsoid @@ -19,7 +18,6 @@ try: import erfa except ImportError: - # Let this raise import astropy._erfa as erfa @@ -930,7 +928,7 @@ def radecRateObsToRV(ra, dec, slantRange, raRate=None, decRate=None, slantRangeR """ if obsPos is None: - return ValueError('obsPos must be set!') + raise ValueError('obsPos must be set!') rHat = lb_to_unit(ra, dec) @@ -1236,791 +1234,3 @@ def bracket(f, x, dx, xmax): "sunAltStart": sunAltStart, "sunAltEnd": sunAltEnd } - - -def nby3shape(arr_): - """ - Reshapes or transforms an input NumPy array into a shape compatible with (n, 3). - - This function takes a NumPy array and ensures it has a shape of `(n, 3)`, - where `n` is the number of rows. The behavior depends on the dimensionality of the input array: - - - If the input array is 1-dimensional, it reshapes it into a `(1, 3)` array. - - If the input array is 2-dimensional: - - If the second dimension already has size 3, the array is returned as-is. - - Otherwise, the array is transposed. - - Parameters: - arr_ (numpy.ndarray): The input NumPy array to reshape or transform. - - Returns: - numpy.ndarray: The reshaped or transformed array with a shape of `(n, 3)`. - - Raises: - ValueError: If the input array cannot be reshaped or transformed into the desired shape. - - Examples: - >>> import numpy as np - >>> arr1 = np.array([1, 2, 3]) - >>> nby3shape(arr1) - array([[1, 2, 3]]) - - >>> arr2 = np.array([[1, 2, 3], [4, 5, 6]]) - >>> nby3shape(arr2) - array([[1, 2, 3], - [4, 5, 6]]) - - >>> arr3 = np.array([[1, 4], [2, 5], [3, 6]]) - >>> nby3shape(arr3) - array([[1, 2, 3], - [4, 5, 6]]) - """ - - if arr_.ndim == 1: - return np.reshape(arr_, (1, 3)) - if arr_.ndim == 2: - if np.shape(arr_)[1] == 3: - return arr_ - else: - return arr_.T - - -def calculate_orbital_elements(r_, v_, mu_barycenter=EARTH_MU): - """ - Calculate the Keplerian orbital elements from position and velocity vectors. - - This function computes the Keplerian orbital elements (semi-major axis, eccentricity, inclination, true longitude, argument of periapsis, longitude of ascending node, true anomaly, and specific angular momentum) for one or more celestial objects given their position and velocity vectors. - - Parameters: - ---------- - r_ : (n, 3) numpy.ndarray - Array of position vectors (in meters) of the celestial objects. Each row represents a position vector. - v_ : (n, 3) numpy.ndarray - Array of velocity vectors (in meters per second) of the celestial objects. Each row represents a velocity vector. - mu_barycenter : float, optional - Gravitational parameter (standard gravitational constant times mass) of the central body (default is `EARTH_MU`). This parameter defines the gravitational influence of the central body on the orbiting object. - - Returns: - ------- - dict - A dictionary containing the orbital elements for each celestial object: - - 'a': Semi-major axis (in meters). - - 'e': Eccentricity (dimensionless). - - 'i': Inclination (in radians). - - 'tl': True longitude (in radians). - - 'ap': Argument of periapsis (in radians). - - 'raan': Longitude of ascending node (in radians). - - 'ta': True anomaly (in radians). - - 'L': Specific angular momentum (in meters squared per second). - - Notes: - ------ - - Position and velocity vectors should be provided in the same units. - - The function assumes that the input vectors are provided in an array where each row corresponds to a different celestial object. - - Orbital elements are computed using standard orbital mechanics formulas. - - The inclination is measured from the reference plane, and the argument of periapsis and true anomaly are measured in the orbital plane. - - Example: - -------- - >>> r = np.array([[1e7, 1e7, 1e7], [1e8, 1e8, 1e8]]) - >>> v = np.array([[1e3, 2e3, 3e3], [4e3, 5e3, 6e3]]) - >>> calculate_orbital_elements(r, v, mu_barycenter=3.986e14) - {'a': [1.5707e7, 2.234e8], 'e': [0.123, 0.456], 'i': [0.785, 0.654], 'tl': [2.345, 3.456], 'ap': [0.123, 0.456], 'raan': [1.234, 2.345], 'ta': [0.567, 1.678], 'L': [1.234e10, 2.345e11]} - """ - # mu_barycenter - all bodies interior to Earth - # 1.0013415732186798 #All bodies of solar system - mu_ = mu_barycenter - rarr = nby3shape(r_) - varr = nby3shape(v_) - aarr = [] - earr = [] - incarr = [] - true_longitudearr = [] - argument_of_periapsisarr = [] - longitude_of_ascending_nodearr = [] - true_anomalyarr = [] - hmagarr = [] - for r, v in zip(rarr, varr): - r = np.array(r) # print(f'r: {r}') - v = np.array(v) # print(f'v: {v}') - - rmag = np.sqrt(r.dot(r)) - vmag = np.sqrt(v.dot(v)) - - h = np.cross(r, v) - hmag = np.sqrt(h.dot(h)) - n = np.cross(np.array([0, 0, 1]), h) - - a = 1 / ((2 / rmag) - (vmag ** 2) / mu_) - - evector = np.cross(v, h) / (mu_) - r / rmag - e = np.sqrt(evector.dot(evector)) - - inc = np.arccos(h[2] / hmag) - - if np.dot(r, v) > 0: - true_anomaly = np.arccos(np.dot(evector, r) / (e * rmag)) - else: - true_anomaly = 2 * np.pi - np.arccos(np.dot(evector, r) / (e * rmag)) - if evector[2] >= 0: - argument_of_periapsis = np.arccos(np.dot(n, evector) / (e * np.sqrt(n.dot(n)))) - else: - argument_of_periapsis = 2 * np.pi - np.arccos(np.dot(n, evector) / (e * np.sqrt(n.dot(n)))) - if n[1] >= 0: - longitude_of_ascending_node = np.arccos(n[0] / np.sqrt(n.dot(n))) - else: - longitude_of_ascending_node = 2 * np.pi - np.arccos(n[0] / np.sqrt(n.dot(n))) - - true_longitude = true_anomaly + argument_of_periapsis + longitude_of_ascending_node - aarr.append(a) - earr.append(e) - incarr.append(inc) - true_longitudearr.append(true_longitude) - argument_of_periapsisarr.append(argument_of_periapsis) - longitude_of_ascending_nodearr.append(longitude_of_ascending_node) - true_anomalyarr.append(true_anomaly) - hmagarr.append(hmag) - return { - 'a': aarr, - 'e': earr, - 'i': incarr, - 'tl': true_longitudearr, - 'ap': argument_of_periapsisarr, - 'raan': longitude_of_ascending_nodearr, - 'ta': true_anomalyarr, - 'L': hmagarr - } - - -###################################################################################### -# Lambertian brightness functions -###################################################################################### - - -def moon_shine(r_moon, r_sat, r_earth, r_sun, radius, albedo, albedo_moon, albedo_back, albedo_front, area_panels): # In SI units, takes single values or arrays returns a fractional flux - """ - Calculate the fractional solar flux reflected from the Moon to the satellite. - - This function computes the fraction of solar flux reflected from the Moon to the satellite, including contributions from both the front and back surfaces of the satellite's solar panels. - - Parameters: - ---------- - r_moon : (n, 3) numpy.ndarray - Array of coordinates representing the position of the Moon. - r_sat : (n, 3) numpy.ndarray - Array of coordinates representing the position of the satellite. - r_earth : (n, 3) numpy.ndarray - Array of coordinates representing the position of the Earth. - r_sun : (n, 3) numpy.ndarray - Array of coordinates representing the position of the Sun. - radius : float - Radius of the satellite in meters. - albedo : float - Albedo of the satellite's surface. - albedo_moon : float - Albedo of the Moon. - albedo_back : float - Albedo of the back surface of the satellite's solar panels. - albedo_front : float - Albedo of the front surface of the satellite's solar panels. - area_panels : float - Area of the satellite's solar panels in square meters. - - Returns: - ------- - dict - Dictionary containing the flux contributions from the Moon to the satellite: - - 'moon_bus': Fraction of solar flux reflected off the satellite's bus from the Moon. - - 'moon_panels': Fraction of solar flux reflected off the satellite's panels from the Moon. - - Notes: - ------ - - The function assumes that the solar panels are always facing the Sun and calculates flux based on the phase angles. - - Fraction of solar flux contributions from both the front and back surfaces of the solar panels are computed. - - Example: - -------- - >>> r_moon = np.array([[1e8, 1e8, 1e8]]) - >>> r_sat = np.array([[1e7, 1e7, 1e7]]) - >>> r_earth = np.array([[0, 0, 0]]) - >>> r_sun = np.array([[1e11, 0, 0]]) - >>> moon_shine(r_moon, r_sat, r_earth, r_sun, radius=0.4, albedo=0.20, albedo_moon=0.12, albedo_back=0.50, albedo_front=0.05, area_panels=100) - {'moon_bus': array([...]), 'moon_panels': array([...])} - """ - # https://amostech.com/TechnicalPapers/2013/POSTER/COGNION.pdf - moon_phase_angle = get_angle(r_sun, r_moon, r_sat) # Phase of the moon as viewed from the sat. - sun_angle = get_angle(r_sun, r_sat, r_moon) # angle from Sun to object to Earth - moon_to_earth_angle = get_angle(r_moon, r_sat, r_earth) - r_moon_sat = np.linalg.norm(r_sat - r_moon, axis=-1) - r_earth_sat = np.linalg.norm(r_sat - r_earth, axis=-1) # Earth is the observer. - flux_moon_to_sat = 2 / 3 * albedo_moon * MOON_RADIUS**2 / (np.pi * (r_moon_sat)**2) * (np.sin(moon_phase_angle) + (np.pi - moon_phase_angle) * np.cos(moon_phase_angle)) # Fraction of sunlight reflected from the Moon to satellite - # Fraction of light from back of solar panel - flux_back = np.zeros_like(sun_angle) - flux_back[sun_angle > np.pi / 2] = np.abs(albedo_back * area_panels / (np.pi * r_earth_sat[sun_angle > np.pi / 2]**2) * np.cos(np.pi - moon_to_earth_angle[sun_angle > np.pi / 2]) * flux_moon_to_sat[sun_angle > np.pi / 2]) # Fraction of Moon light reflected off back of solar panels - which are assumed to be always facing the Sun. Angle: Sun - Observer - Sat - flux_front = np.zeros_like(sun_angle) - flux_front[sun_angle < np.pi / 2] = np.abs(albedo_front * area_panels / (np.pi * r_earth_sat[sun_angle < np.pi / 2]**2) * np.cos(moon_to_earth_angle[sun_angle < np.pi / 2]) * flux_moon_to_sat[sun_angle < np.pi / 2]) # Fraction of Sun light scattered off front of the solar panels - which are assumed to be always facing the Sun. Angle: Sun - Sat - Observer - flux_panels = flux_back + flux_front - flux_bus = 2 / 3 * albedo * radius**2 / (np.pi * r_earth_sat**2) * flux_moon_to_sat - return {'moon_bus': flux_bus, 'moon_panels': flux_panels} - - -def earth_shine(r_sat, r_earth, r_sun, radius, albedo, albedo_earth, albedo_back, area_panels): # In SI units, takes single values or arrays returns a flux - """ - Calculate the fractional flux of sunlight reflected from the Earth to the satellite. - - This function computes the flux of sunlight reflected from the Earth to the satellite, including contributions from the back surface of the satellite's solar panels. - - Parameters: - ---------- - r_sat : (n, 3) numpy.ndarray - Array of coordinates representing the position of the satellite. - r_earth : (n, 3) numpy.ndarray - Array of coordinates representing the position of the Earth. - r_sun : (n, 3) numpy.ndarray - Array of coordinates representing the position of the Sun. - radius : float - Radius of the satellite in meters. - albedo : float - Albedo of the satellite's surface. - albedo_earth : float - Albedo of the Earth. - albedo_back : float - Albedo of the back surface of the satellite's solar panels. - area_panels : float - Area of the satellite's solar panels in square meters. - - Returns: - ------- - dict - Dictionary containing the flux contributions from the Earth to the satellite: - - 'earth_bus': Fraction of solar flux reflected off the satellite's bus from the Earth. - - 'earth_panels': Fraction of solar flux reflected off the satellite's panels from the Earth. - - Notes: - ------ - - The function assumes that the solar panels are always facing the Sun and calculates flux based on the phase angle. - - Fraction of solar flux contributions from the back surface of the solar panels are computed. - - Example: - -------- - >>> r_sat = np.array([[1e7, 1e7, 1e7]]) - >>> r_earth = np.array([[1.496e11, 0, 0]]) - >>> r_sun = np.array([[0, 0, 0]]) - >>> earth_shine(r_sat, r_earth, r_sun, radius=0.4, albedo=0.20, albedo_earth=0.30, albedo_back=0.50, area_panels=100) - {'earth_bus': array([...]), 'earth_panels': array([...])} - """ - # https://amostech.com/TechnicalPapers/2013/POSTER/COGNION.pdf - phase_angle = get_angle(r_sun, r_sat, r_earth) # angle from Sun to object to Earth - earth_angle = np.pi - phase_angle # Sun to Earth to object. - r_earth_sat = np.linalg.norm(r_sat - r_earth, axis=-1) # Earth is the observer. - flux_earth_to_sat = 2 / 3 * albedo_earth * EARTH_RADIUS**2 / (np.pi * (r_earth_sat)**2) * (np.sin(earth_angle) + (np.pi - earth_angle) * np.cos(earth_angle)) # Fraction of sunlight reflected from the Earth to satellite - # Fraction of light from back of solar panel - flux_back = np.zeros_like(phase_angle) - flux_back[phase_angle > np.pi / 2] = albedo_back * area_panels / (np.pi * r_earth_sat[phase_angle > np.pi / 2]**2) * np.cos(np.pi - phase_angle[phase_angle > np.pi / 2]) * flux_earth_to_sat[phase_angle > np.pi / 2] # Fraction of Earth light reflected off back of solar panels - which are assumed to be always facing the Sun. Angle: Sun - Observer - Sat - flux_bus = 2 / 3 * albedo * radius**2 / (np.pi * r_earth_sat**2) * flux_earth_to_sat - return {'earth_bus': flux_bus, 'earth_panels': flux_back} - - -def sun_shine(r_sat, r_earth, r_sun, radius, albedo, albedo_front, area_panels): # In SI units, takes single values or arrays returns a fractional flux - """ - Calculate the fractional flux of sunlight reflected from the Sun to the satellite. - - This function computes the fractional flux of sunlight reflected from the Sun to the satellite, including contributions from the front surface of the satellite's solar panels. - - Parameters: - ---------- - r_sat : (n, 3) numpy.ndarray - Array of coordinates representing the position of the satellite. - r_earth : (n, 3) numpy.ndarray - Array of coordinates representing the position of the Earth. - r_sun : (n, 3) numpy.ndarray - Array of coordinates representing the position of the Sun. - radius : float - Radius of the satellite in meters. - albedo : float - Albedo of the satellite's surface. - albedo_front : float - Albedo of the front surface of the satellite's solar panels. - area_panels : float - Area of the satellite's solar panels in square meters. - - Returns: - ------- - dict - Dictionary containing the flux contributions from the Sun to the satellite: - - 'sun_bus': Fraction of solar flux reflected off the satellite's bus from the Sun. - - 'sun_panels': Fraction of solar flux reflected off the satellite's panels from the Sun. - - Notes: - ------ - - The function assumes that the solar panels are always facing the Sun and calculates flux based on the phase angle. - - Fraction of solar flux contributions from the front surface of the solar panels are computed. - - Example: - -------- - >>> r_sat = np.array([[1e7, 1e7, 1e7]]) - >>> r_earth = np.array([[0, 0, 0]]) - >>> r_sun = np.array([[1e11, 0, 0]]) - >>> sun_shine(r_sat, r_earth, r_sun, radius=0.4, albedo=0.20, albedo_front=0.05, area_panels=100) - {'sun_bus': array([...]), 'sun_panels': array([...])} - """ - # https://amostech.com/TechnicalPapers/2013/POSTER/COGNION.pdf - phase_angle = get_angle(r_sun, r_sat, r_earth) # angle from Sun to object to Earth - r_earth_sat = np.linalg.norm(r_sat - r_earth, axis=-1) # Earth is the observer. - flux_front = np.zeros_like(phase_angle) - flux_front[phase_angle < np.pi / 2] = albedo_front * area_panels / (np.pi * r_earth_sat[phase_angle < np.pi / 2]**2) * np.cos(phase_angle[phase_angle < np.pi / 2]) # Fraction of Sun light scattered off front of the solar panels - which are assumed to be always facing the Sun. Angle: Sun - Sat - Observer - flux_bus = 2 / 3 * albedo * radius**2 / (np.pi * (r_earth_sat)**2) * (np.sin(phase_angle) + (np.pi - phase_angle) * np.cos(phase_angle)) # Fraction of light reflected off satellite from Sun - return {'sun_bus': flux_bus, 'sun_panels': flux_front} - - -def calc_M_v(r_sat, r_earth, r_sun, r_moon=False, radius=0.4, albedo=0.20, sun_Mag=4.80, albedo_earth=0.30, albedo_moon=0.12, albedo_back=0.50, albedo_front=0.05, area_panels=100, return_components=False): - """ - Calculate the apparent magnitude (M_v) of a satellite due to reflections from the Sun, Earth, and optionally the Moon. - - This function computes the apparent magnitude of a satellite based on its reflected light from the Sun, Earth, and optionally the Moon. It uses separate functions to calculate the flux contributions from each of these sources and combines them to determine the overall apparent magnitude. - - Parameters: - ---------- - r_sat : (n, 3) numpy.ndarray - Position of the satellite in meters. - r_earth : (n, 3) numpy.ndarray - Position of the Earth in meters. - r_sun : (n, 3) numpy.ndarray - Position of the Sun in meters. - r_moon : (n, 3) numpy.ndarray or False, optional - Position of the Moon in meters. If False, the Moon's contribution is ignored (default is False). - radius : float, optional - Radius of the satellite in meters (default is 0.4 m). - albedo : float, optional - Albedo of the satellite's surface, representing its reflectivity (default is 0.20). - sun_Mag : float, optional - Solar magnitude (apparent magnitude of the Sun) used in magnitude calculations (default is 4.80). - albedo_earth : float, optional - Albedo of the Earth, representing its reflectivity (default is 0.30). - albedo_moon : float, optional - Albedo of the Moon, representing its reflectivity (default is 0.12). - albedo_back : float, optional - Albedo of the back surface of the satellite (default is 0.50). - albedo_front : float, optional - Albedo of the front surface of the satellite (default is 0.05). - area_panels : float, optional - Area of the satellite's panels in square meters (default is 100 m^2). - return_components : bool, optional - If True, returns the magnitude as well as the flux components from the Sun, Earth, and Moon (default is False). - - Returns: - ------- - float - The apparent magnitude (M_v) of the satellite as observed from Earth. - - dict, optional - If `return_components` is True, a dictionary containing the flux components from the Sun, Earth, and Moon. - - Notes: - ------ - - The function uses separate calculations for flux contributions from the Sun, Earth, and Moon: - - `sun_shine` calculates the flux from the Sun. - - `earth_shine` calculates the flux from the Earth. - - `moon_shine` calculates the flux from the Moon (if applicable). - - The apparent magnitude is calculated based on the distances between the satellite, Sun, Earth, and optionally the Moon, as well as their respective albedos and other parameters. - - Example usage: - -------------- - >>> r_sat = np.array([[1e7, 2e7, 3e7]]) - >>> r_earth = np.array([1.496e11, 0, 0]) - >>> r_sun = np.array([0, 0, 0]) - >>> Mag_v = calc_M_v(r_sat, r_earth, r_sun, return_components=True) - >>> Mag_v - (15.63, {'sun_bus': 0.1, 'sun_panels': 0.2, 'earth_bus': 0.05, 'earth_panels': 0.1, 'moon_bus': 0.03, 'moon_panels': 0.07}) - """ - r_sun_sat = np.linalg.norm(r_sat - r_sun, axis=-1) - frac_flux_sun = {'sun_bus': 0, 'sun_panels': 0} - frac_flux_earth = {'earth_bus': 0, 'earth_panels': 0} - frac_flux_moon = {'moon_bus': 0, 'moon_panels': 0} - frac_flux_sun = sun_shine(r_sat, r_earth, r_sun, radius, albedo, albedo_front, area_panels) - frac_flux_earth = earth_shine(r_sat, r_earth, r_sun, radius, albedo, albedo_earth, albedo_back, area_panels) - if r_moon is not False: - frac_flux_moon = moon_shine(r_moon, r_sat, r_earth, r_sun, radius, albedo, albedo_moon, albedo_back, albedo_front, area_panels) - merged_dict = {**frac_flux_sun, **frac_flux_earth, **frac_flux_moon} - total_frac_flux = sum(merged_dict.values()) - Mag_v = (2.5 * np.log10((r_sun_sat / (10 * u.Unit('parsec').to(u.Unit('m'))))**2) + sun_Mag) - 2.5 * np.log10(total_frac_flux) - if return_components: - return Mag_v, merged_dict - else: - return Mag_v - - -def M_v_lambertian(r_sat, times, radius=1.0, albedo=0.20, sun_Mag=4.80, albedo_earth=0.30, albedo_moon=0.12, plot=False): - """ - Calculate the apparent magnitude (M_v) of a satellite due to reflections from the Sun, Earth, and Moon. - - This function computes the apparent magnitude of a satellite based on its reflected light from the Sun, Earth, and Moon, using the Lambertian reflection model. It optionally generates plots to visualize the results. - - Parameters: - ---------- - r_sat : (n, 3) numpy.ndarray - Position of the satellite in meters. - times : Time or array_like - The times corresponding to the satellite and celestial body positions. Used to obtain the positions of the Sun and Moon. - radius : float, optional - Radius of the satellite in meters (default is 1.0 m). - albedo : float, optional - Albedo of the satellite's surface, representing its reflectivity (default is 0.20). - sun_Mag : float, optional - Solar magnitude (apparent magnitude of the Sun) used in magnitude calculations (default is 4.80). - albedo_earth : float, optional - Albedo of the Earth, representing its reflectivity (default is 0.30). - albedo_moon : float, optional - Albedo of the Moon, representing its reflectivity (default is 0.12). - plot : bool, optional - If True, generates plots to visualize solar phase angle and magnitudes (default is False). - - Returns: - ------- - numpy.ndarray - The apparent magnitude (M_v) of the satellite as observed from Earth, considering reflections from the Sun, Earth, and Moon. - - Notes: - ------ - - The function uses a Lambertian reflection model to compute the fraction of sunlight reflected by the satellite, Earth, and Moon. - - The apparent magnitude is calculated based on the distances between the satellite, Sun, Earth, and Moon, as well as their respective albedos. - - The function generates four subplots if `plot` is set to True: - 1. Solar phase angle of the satellite. - 2. Solar magnitude (M_v) of the satellite due to the Sun. - 3. Magnitude (M_v) of the satellite due to reflections from the Earth. - 4. Magnitude (M_v) of the satellite due to reflections from the Moon. - - Example usage: - -------------- - >>> r_sat = np.array([[1e7, 2e7, 3e7]]) - >>> times = Time("2024-01-01") - >>> M_v = M_v_lambertian(r_sat, times, plot=True) - >>> M_v - array([15.63]) - """ - pc_to_m = 3.085677581491367e+16 - r_sun = get_body('Sun').position(times).T - r_moon = get_body('Moon').position(times).T - r_earth = np.zeros_like(r_sun) - - r_sun_sat = np.linalg.norm(r_sat - r_sun, axis=-1) - r_earth_sat = np.linalg.norm(r_sat, axis=-1) - r_moon_sat = np.linalg.norm(r_sat - r_moon, axis=-1) - - sun_angle = get_angle(r_sun, r_sat, r_earth) - earth_angle = np.pi - sun_angle - moon_phase_angle = get_angle(r_sun, r_moon, r_sat) # Phase of the moon as viewed from the sat. - moon_to_earth_angle = get_angle(r_moon, r_sat, r_earth) - - flux_moon_to_sat = 2 / 3 * albedo_moon * MOON_RADIUS**2 / (np.pi * (r_moon_sat)**2) * (np.sin(moon_phase_angle) + (np.pi - moon_phase_angle) * np.cos(moon_phase_angle)) # Fraction of sunlight reflected from the Moon to satellite - flux_earth_to_sat = 2 / 3 * albedo_earth * EARTH_RADIUS**2 / (np.pi * (r_earth_sat)**2) * (np.sin(earth_angle) + (np.pi - earth_angle) * np.cos(earth_angle)) # Fraction of sunlight reflected from the Earth to satellite - - frac_flux_sun = 2 / 3 * albedo * radius**2 / (np.pi * (r_earth_sat)**2) * (np.sin(sun_angle) + (np.pi - sun_angle) * np.cos(sun_angle)) # Fraction of light reflected off satellite from Sun - frac_flux_earth = 2 / 3 * albedo * radius**2 / (np.pi * r_earth_sat**2) * flux_earth_to_sat - frac_flux_moon = 2 / 3 * albedo * radius**2 / (np.pi * r_earth_sat**2) * flux_moon_to_sat - Mag_v = (2.5 * np.log10((r_sun_sat / (10 * pc_to_m))**2) + sun_Mag) - 2.5 * np.log10(frac_flux_sun + frac_flux_earth + frac_flux_moon) - if plot: - import matplotlib.pyplot as plt - sun_scale = 149597870700.0 * (RGEO / np.max(r_earth_sat) ) * 0.75 - color_map ='inferno_r' - fig = plt.figure(figsize=(18, 4)) - ax = fig.add_subplot(1, 4, 1) - ax.scatter(r_earth[:, 0], r_earth[:, 1], c='Blue', s=10) - scatter = ax.scatter(r_sat[:, 0] / RGEO, r_sat[:, 1] / RGEO, c=sun_angle, cmap=color_map) - colorbar = plt.colorbar(scatter) - ax.scatter(r_sun[:, 0] / sun_scale, r_sun[:, 1] / sun_scale, c=plt.cm.Oranges(np.linspace(0.25, 0.75, len(r_sat[:, 0]))), s=10) - ax.set_title('Solar Phase') - ax.set_xlabel('X [GEO]') - ax.set_ylabel('Y [GEO]') - ax.axis('equal') - - ax = fig.add_subplot(1, 4, 2) - ax.scatter(r_earth[0], r_earth[1], c='Blue', s=10) - scatter = ax.scatter(r_sat[:, 0] / RGEO, r_sat[:, 1] / RGEO, c=(2.5 * np.log10((r_sun_sat / (10 * pc_to_m))**2) + sun_Mag) - 2.5 * np.log10(frac_flux_sun), cmap=color_map) - colorbar = plt.colorbar(scatter) - ax.scatter(r_sun[:, 0] / sun_scale, r_sun[:, 1] / sun_scale, c=plt.cm.Oranges(np.linspace(0.25, 0.75, len(r_sat[:, 0]))), s=10) - ax.set_title('Solar M_v') - ax.axis('equal') - - ax = fig.add_subplot(1, 4, 3) - ax.scatter(r_earth[:, 0], r_earth[:, 1], c='Blue', s=10) - scatter = ax.scatter(r_sat[:, 0] / RGEO, r_sat[:, 1] / RGEO, c=(2.5 * np.log10((r_sun_sat / (10 * pc_to_m))**2) + sun_Mag) - 2.5 * np.log10(frac_flux_earth), cmap=color_map) - colorbar = plt.colorbar(scatter) - ax.scatter(r_sun[:, 0] / sun_scale, r_sun[:, 1] / sun_scale, c=plt.cm.Oranges(np.linspace(0.25, 0.75, len(r_sat[:, 0]))), s=10) - - ax.set_title('Earth M_v') - ax.axis('equal') - - ax = fig.add_subplot(1, 4, 4) - ax.scatter(r_earth[:, 0], r_earth[:, 1], c='Blue', s=10) - scatter = ax.scatter(r_sat[:, 0] / RGEO, r_sat[:, 1] / RGEO, c=(2.5 * np.log10((r_sun_sat / (10 * pc_to_m))**2) + sun_Mag) - 2.5 * np.log10(frac_flux_moon), cmap=color_map) - ax.scatter(r_moon[:, 0] / RGEO, r_moon[:, 1] / RGEO, c=plt.cm.Greys(np.linspace(0.5, 1, len(r_sat[:, 0]))), s=5) - - colorbar = plt.colorbar(scatter) - ax.set_title('Lunar M_v') - ax.axis('equal') - plt.show() - - return Mag_v - - -def calc_gamma(r, t): - """ - Calculate the gamma angle between position and velocity vectors in the ITRF frame. - - Parameters: - r (numpy.ndarray): The position vectors in the GCRF frame, shaped (n, 3), where n is the number of vectors. - t (numpy.ndarray or astropy.time.Time): The times corresponding to the position vectors. Can be an array of GPS seconds or an Astropy Time object. - - Returns: - numpy.ndarray: An array of gamma angles in degrees between the position and velocity vectors for each time point. - - Notes: - - This function first converts the given position vectors from the GCRF frame to the ITRF frame. - - It then calculates the angle between the position and velocity vectors at each time point in the ITRF frame. - - If the input time array is an Astropy Time object, it converts it to GPS time before processing. - """ - r_itrf, v_itrf = gcrf_to_itrf(r, t, v=True) - if isinstance(t[0], Time): - t = t.gps - gamma = np.degrees(np.apply_along_axis(lambda x: angle_between_vectors(x[:3], x[3:]), 1, np.concatenate((r_itrf, v_itrf), axis=1))) - 90 - return gamma - - - -def moon_normal_vector(t): - """ - Calculate the normal vector to the Moon's orbital plane at a given time. - - This function computes the normal vector to the Moon's orbital plane by taking the cross product of the Moon's position vectors at two different times: the given time `t` and one week later. The resulting vector is normalized to provide the direction of the orbital plane's normal. - - Parameters: - ---------- - t : Time - The time at which to calculate the normal vector to the Moon's orbital plane. - - Returns: - ------- - numpy.ndarray - A 3-element array representing the normal vector to the Moon's orbital plane at the given time. The vector is normalized to have a unit length. - - Notes: - ------ - - The function assumes a circular orbit for the Moon and uses a time step of one week (604800 seconds) to calculate the normal vector. - - The normal vector is perpendicular to the plane defined by the Moon's position vectors at the given time and one week later. - - Example usage: - -------------- - >>> t = Time("2024-01-01") - >>> normal_vector = moon_normal_vector(t) - >>> normal_vector - array([-0.093, 0.014, 0.995]) - """ - r = get_body("moon").position(t).T - r_random = get_body("moon").position(t.gps + 604800).T - return np.cross(r, r_random) / np.linalg.norm(np.cross(r, r_random)) - - -def lunar_lagrange_points(t): - """ - Calculate the positions of the lunar Lagrange points in the GCRF frame at a given time. - - This function computes the positions of the five Lagrange points (L1, L2, L3, L4, and L5) in the Earth-Moon system at a specific time `t`. It considers the positions of the Earth and Moon and uses the orbital period of the Moon to find the Lagrange points. - - Parameters: - ---------- - t : Time - The time at which to calculate the Lagrange points. The position of the Moon at this time is used to compute the Lagrange points. - - Returns: - ------- - dict - A dictionary containing the coordinates of the five Lagrange points: - - "L1": Position of the first Lagrange point between the Earth and the Moon. - - "L2": Position of the second Lagrange point beyond the Moon. - - "L3": Position of the third Lagrange point directly opposite the Moon, relative to the Earth. - - "L4": Position of the fourth Lagrange point, calculated as the Moon's position offset by one-sixth of the lunar period. - - "L5": Position of the fifth Lagrange point, calculated as the Moon's position offset by negative one-sixth of the lunar period. - - Notes: - ------ - - The function assumes a circular orbit for the Moon. - - The lunar period used is approximately 2.36 million seconds. - - The gravitational parameters of the Earth and Moon are denoted as `EARTH_MU` and `MOON_MU`, respectively. - - Example usage: - -------------- - >>> t = Time("2024-01-01") - >>> lagrange_points = lunar_lagrange_points(t) - >>> lagrange_points["L1"] - array([1.02e6, 0.0, 0.0]) - >>> lagrange_points["L4"] - array([1.5e6, 1.5e6, 0.0]) - """ - - r = get_body("moon").position(t).T - d = np.linalg.norm(r) # Distance between Earth and Moon - unit_vector_moon = r / np.linalg.norm(r, axis=-1) - # plane_vector = np.cross(r, r_random) - lunar_period_seconds = 2.3605915968e6 - - # Coefficients of the quadratic equation - a = EARTH_MU - MOON_MU - b = 2 * MOON_MU * d - c = -MOON_MU * d**2 - - # Solve the quadratic equation - discriminant = b**2 - 4*a*c - - if discriminant >= 0: - L1_from_moon = (-b - np.sqrt(discriminant)) / (2*a) * unit_vector_moon - L2_from_moon = (-b + np.sqrt(discriminant)) / (2*a) * unit_vector_moon - else: - print("Discriminate is less than 0! THAT'S WEIRD FIX IT.") - L1_from_moon = None - L2_from_moon = None - - return { - "L1": L1_from_moon + r, - "L2": L2_from_moon + r, - "L3": -r, - "L4": get_body("moon").position(t.gps + lunar_period_seconds / 6).T, - "L5": get_body("moon").position(t.gps - lunar_period_seconds / 6).T - } - - -def lunar_lagrange_points_circular(t): - """ - Calculate the positions of the lunar Lagrange points in the GCRF frame for a given time. - - This function calculates the positions of the five Lagrange points (L1, L2, L3, L4, and L5) in the Earth-Moon system at a specific time `t`. It accounts for the rotation of the Moon's orbit around the Earth, providing the positions in a circular approximation of the Earth-Moon system. - - Parameters: - ---------- - t : Time - The time at which to calculate the Lagrange points. The position of the Moon at this time is used to compute the Lagrange points. - - Returns: - ------- - dict - A dictionary containing the coordinates of the five Lagrange points: - - "L1": Position of the first Lagrange point between the Earth and the Moon. - - "L2": Position of the second Lagrange point beyond the Moon. - - "L3": Position of the third Lagrange point directly opposite the Moon, relative to the Earth. - - "L4": Position of the fourth Lagrange point, forming an equilateral triangle with the Earth and Moon. - - "L5": Position of the fifth Lagrange point, forming an equilateral triangle with the Earth and Moon, but on the opposite side. - - Notes: - ------ - - The function assumes a circular orbit for the Moon and uses a rotation matrix to align the z-axis with the Moon's normal vector. - - The positions of L4 and L5 are calculated using a rotation matrix to align with the Moon's orientation. - - The gravitational parameters of the Earth and Moon are denoted as `EARTH_MU` and `MOON_MU`, respectively. - - Example usage: - -------------- - >>> t = Time("2024-01-01") - >>> lagrange_points = lunar_lagrange_points_circular(t) - >>> lagrange_points["L1"] - array([1.02e6, 0.0, 0.0]) - >>> lagrange_points["L4"] - array([1.5e6, 1.5e6, 0.0]) - """ - r = get_body("moon").position(t).T - d = np.linalg.norm(r) # Distance between Earth and Moon - unit_vector_moon = r / np.linalg.norm(r, axis=-1) - - # Coefficients of the quadratic equation - a = EARTH_MU - MOON_MU - b = 2 * MOON_MU * d - c = -MOON_MU * d**2 - - # Solve the quadratic equation - discriminant = b**2 - 4*a*c - - if discriminant >= 0: - L1_from_moon = (-b - np.sqrt(discriminant)) / (2*a) * unit_vector_moon - L2_from_moon = (-b + np.sqrt(discriminant)) / (2*a) * unit_vector_moon - else: - print("Discriminate is less than 0! THAT'S WEIRD FIX IT.") - L1_from_moon = None - L2_from_moon = None - - # L45 - # Create the rotation matrix to align z-axis with the normal vector - normal_vector = moon_normal_vector(t) - rotation_matrix = rotation_matrix_from_vectors(np.array([0, 0, 1]), normal_vector) - theta = np.radians(60) + np.arctan2(unit_vector_moon[1], unit_vector_moon[0]) - L4 = np.vstack((d * np.cos(theta), d * np.sin(theta), np.zeros_like(theta))).T - L4 = np.squeeze(L4 @ rotation_matrix.T) - theta = -np.radians(60) + np.arctan2(unit_vector_moon[1], unit_vector_moon[0]) - L5 = np.vstack((d * np.cos(theta), d * np.sin(theta), np.zeros_like(theta))).T - L5 = np.squeeze(L5 @ rotation_matrix.T) - - return { - "L1": L1_from_moon + r, - "L2": L2_from_moon + r, - "L3": -r, - "L4": L4, - "L5": L5 - } - - -def lagrange_points_lunar_frame(): - """ - Calculate the positions of the lunar Lagrange points in the lunar frame, This frame is defined by the coordinate transformation in utils.py gcrf_to_lunar(). - - Returns: - ------- - dict - A dictionary containing the coordinates of the five Lagrange points: - - "L1": Position of the first Lagrange point between the Earth and the Moon. - - "L2": Position of the second Lagrange point beyond the Moon. - - "L3": Position of the third Lagrange point directly opposite the Moon, relative to the Earth. - - "L4": Position of the fourth Lagrange point, forming an equilateral triangle with the Earth and Moon. - - "L5": Position of the fifth Lagrange point, forming an equilateral triangle with the Earth and Moon, but on the opposite side. - - Notes: - ------ - - The function assumes that the Earth and Moon are the two primary bodies, with the Earth-Moon distance denoted as `LD`. - - The gravitational parameters of the Earth and Moon are denoted as `EARTH_MU` and `MOON_MU`, respectively. - - The positions of L4 and L5 are calculated using the fact that these points form an equilateral triangle with the Earth and Moon. - - Example usage: - -------------- - >>> lagrange_points = lagrange_points_lunar_frame() - >>> lagrange_points["L1"] - array([1.01e6, 0.0, 0.0]) - >>> lagrange_points["L4"] - array([1.5e6, 1.5e6, 0.0]) - """ - r = np.array([LD / RGEO, 0, 0]) - d = np.linalg.norm(r) # Distance between Earth and Moon - unit_vector_moon = r / np.linalg.norm(r, axis=-1) - - # Coefficients of the quadratic equation - a = EARTH_MU - MOON_MU - b = 2 * MOON_MU * d - c = -MOON_MU * d**2 - - # Solve the quadratic equation - discriminant = b**2 - 4*a*c - - if discriminant >= 0: - L1_from_moon = (-b - np.sqrt(discriminant)) / (2*a) * unit_vector_moon - L2_from_moon = (-b + np.sqrt(discriminant)) / (2*a) * unit_vector_moon - else: - print("Discriminate is less than 0! THAT'S WEIRD FIX IT.") - L1_from_moon = None - L2_from_moon = None - - # L45 - theta = np.radians(60) - L4 = np.squeeze(np.vstack((d * np.cos(theta), d * np.sin(theta), np.zeros_like(theta))).T) - L5 = np.squeeze(np.vstack((d * np.cos(-theta), d * np.sin(-theta), np.zeros_like(-theta))).T) - return { - "L1": L1_from_moon + r, - "L2": L2_from_moon + r, - "L3": -r, - "L4": L4, - "L5": L5 - } diff --git a/ssapy/io.py b/ssapy/io.py index 5689e3e7..38d8072e 100644 --- a/ssapy/io.py +++ b/ssapy/io.py @@ -4,9 +4,7 @@ import datetime import numpy as np -import os -import csv -import pandas as pd +import astropy.coordinates as ac from astropy.time import Time import astropy.units as u from .constants import EARTH_MU @@ -613,1145 +611,3 @@ def load_b3obs_file(file_name): "tel_pos": np.array([d["tel_pos"] for d in pos]) } return catalog - -# ============================================================================= -# File Handling Functions -# ============================================================================= -def file_exists_extension_agnostic(filename): - """ - Check if a file with the given name and any extension exists. - - Parameters: - ---------- - filename : str - The name of the file to check, without extension. - - Returns: - ------- - bool - True if a file with the given name and any extension exists, False otherwise. - """ - from glob import glob - name, _ = os.path.splitext(filename) - return bool(glob(f"{name}.*")) - - -def exists(pathname): - """ - Check if a file or directory exists. - - Parameters: - ---------- - pathname : str - The path to the file or directory. - - Returns: - ------- - bool - True if the path exists as either a file or a directory, False otherwise. - """ - if os.path.isdir(pathname) or os.path.isfile(pathname): - return True - else: - return False - - -def mkdir(pathname): - """ - Creates a directory if it does not exist. - - Parameters: - ---------- - pathname : str - The path to the directory to be created. - """ - if not exists(pathname): - os.makedirs(pathname) - print("Directory '%s' created" % pathname) - return - - -def rmdir(source_): - """ - Deletes a directory and its contents if it exists. - - Parameters: - ---------- - source_ : str - The path to the directory to be deleted. - """ - if not exists(source_): - print(f'{source_}, does not exist, no delete.') - else: - import shutil - print(f'Deleted {source_}') - shutil.rmtree(source_) - return - - -def rmfile(pathname): - """ - Deletes a file if it exists. - - Parameters: - ---------- - pathname : str - The path to the file to be deleted. - """ - if exists(pathname): - os.remove(pathname) - print("File: '%s' deleted." % pathname) - return - - -def _sortbynum(files, index=0): - """ - Sorts a list of file paths based on numeric values in the filenames. - - This function assumes that each filename contains at least one numeric value - and sorts the files based on the first numeric value found in the filename. - - Parameters: - ---------- - files : list - List of file paths to be sorted. Each file path can be a full path or just a filename. - index: int - Index of the number in the string do you want to sort on. - - Returns: - ------- - list - List of file paths sorted by numeric values in their filenames. - - Notes: - ----- - - This function extracts the first numeric value it encounters in each filename. - - If no numeric value is found in a filename, the function may raise an error. - - The numeric value can appear anywhere in the filename. - - The function does not handle cases where filenames have different directory prefixes. - - Raises: - ------ - ValueError: - If a filename does not contain any numeric value. - - Examples: - -------- - >>> _sortbynum(['file2.txt', 'file10.txt', 'file1.txt']) - ['file1.txt', 'file2.txt', 'file10.txt'] - - >>> _sortbynum(['/path/to/file2.txt', '/path/to/file10.txt', '/path/to/file1.txt']) - ['/path/to/file1.txt', '/path/to/file2.txt', '/path/to/file10.txt'] - """ - import re - if len(files[0].split('/')) > 1: - files_shortened = [] - file_prefix = '/'.join(files[0].split('/')[:-1]) - for file in files: - files_shortened.append(file.split('/')[-1]) - files_sorted = sorted(files_shortened, key=lambda x: float(re.findall(r"(\d+)", x)[index])) - sorted_files = [] - for file in files_sorted: - sorted_files.append(f'{file_prefix}/{file}') - else: - sorted_files = sorted(files, key=lambda x: float(re.findall(r"(\d+)", x)[index])) - return sorted_files - - -def listdir(dir_path='*', files_only=False, exclude=None, sorted=False, index=0): - """ - Lists files and directories in a specified path with optional filtering and sorting. - - Parameters: - ---------- - dir_path : str, default='*' - The directory path or pattern to match files and directories. - files_only : bool, default=False - If True, only returns files, excluding directories. - exclude : str or None, optional - If specified, excludes files and directories whose base name contains this string. - sorted : bool, default=False - If True, sorts the resulting list by numeric values in filenames. - index : int, default=0 - sorted required to be true. Index of the digit used for sorting. - - Returns: - ------- - list - A list of file or directory paths based on the specified filters and sorting. - """ - from glob import glob - if '*' not in dir_path: - dir_path = os.path.join(dir_path, '*') - expanded_paths = glob(dir_path) - - if files_only: - files = [f for f in expanded_paths if os.path.isfile(f)] - print(f'{len(files)} files in {dir_path}') - else: - files = expanded_paths - print(f'{len(files)} files in {dir_path}') - - if exclude: - new_files = [file for file in files if exclude not in os.path.basename(file)] - files = new_files - if sorted: - return _sortbynum(files, index=index) - else: - return files - - -def get_memory_usage(): - """ - Print the memory usage of the current process. - - This function retrieves the memory usage of the current Python process - using the `psutil` library and prints it in gigabytes (GB). The memory - usage is calculated based on the resident set size (RSS), which represents - the portion of memory occupied by the process in RAM. - - Args: - None - - Returns: - None: The function does not return a value. It prints the memory usage directly. - """ - import os - import psutil - - print(f"Memory used: {psutil.Process(os.getpid()).memory_info().rss / 1024 ** 3:.2f} GB") - -###################################################################### -# Load and Save Functions -###################################################################### -###################################################################### -# Pickles -###################################################################### - - -def save_pickle(filename_, data_): - """ - Save data to a pickle file. - - This function serializes the given data and saves it to the specified file path - using the pickle module. The file is opened in write-binary mode to ensure - proper saving of the data. - - Args: - filename_ (str): The path to the file where the data will be saved. - data_ (object): The data to be serialized and saved to the pickle file. - - Returns: - None: The function does not return a value. The data is saved to the specified file. - """ - from six.moves import cPickle as pickle # for performance - with open(filename_, 'wb') as f: - pickle.dump(data_, f) - f.close() - return - - -def load_pickle(filename_): - """ - Load data from a pickle file. - - Args: - filename_ (str): The path to the pickle file to be loaded. - - Returns: - object: The data loaded from the pickle file. If an error occurs, - an empty list is returned. - """ - from six.moves import cPickle as pickle # for performance - try: - # print('Openning: ' + current_filename) - with open(filename_, 'rb') as f: - data = pickle.load(f) - f.close() - except (EOFError, FileNotFoundError, OSError, pickle.UnpicklingError) as err: - print(f'{err} - current_filename') - return [] - return data - - -def merge_dicts(file_names, save_path): - """ - Merge multiple dictionaries stored in pickle files into a single dictionary and save the result. - - Args: - file_names (list of str): A list of file paths to pickle files containing dictionaries to merge. - save_path (str): The file path where the merged dictionary will be saved as a pickle file. - - Returns: - None: The function does not return a value. The merged dictionary is saved to `save_path`. - """ - number_of_files = len(file_names); master_dict = {} - for count, file in enumerate(file_names): - print(f'Merging dict: {count+1} of {number_of_files}, name: {file}, num of master keys: {len(master_dict.keys())}, num of new keys: {len(master_dict.keys())}') - master_dict.update(load_pickle(file)) - print('Beginning final save.') - save_pickle(save_path, master_dict) - return - - -###################################################################### -# Sliceable Numpys save and load -###################################################################### - - -def save_np(filename_, data_): - """ - Save a NumPy array to a binary file. - - This function saves a NumPy array to a file in .npy format. If the file cannot be created or written to, it handles common exceptions and prints an error message. - - Parameters: - ---------- - filename_ : str - The path to the file where the NumPy array will be saved. - data_ : numpy.ndarray - The NumPy array to be saved. - - Returns: - ------- - None - The function does not return any value. It handles exceptions internally and prints error messages if any issues occur. - - Examples: - -------- - >>> arr = np.array([1, 2, 3, 4, 5]) - >>> save_np('array.npy', arr) - """ - try: - with open(filename_, 'wb') as f: - np.save(filename_, data_, allow_pickle=True) - f.close() - except (EOFError, FileNotFoundError, OSError) as err: - print(f'{err} - saving') - return - - -def load_np(filename_): - """ - Load a NumPy array from a binary file. - - This function loads a NumPy array from a file in .npy format. If the file cannot be read, it handles common exceptions and prints an error message. If loading fails, it returns an empty list. - - Parameters: - ---------- - filename_ : str - The path to the file from which the NumPy array will be loaded. - - Returns: - ------- - numpy.ndarray or list - The loaded NumPy array. If an error occurs during loading, returns an empty list. - - Examples: - -------- - >>> arr = load_np('array.npy') - >>> print(arr) - [1 2 3 4 5] - """ - try: - with open(filename_, 'rb') as f: - data = np.load(filename_, allow_pickle=True) - f.close() - except (EOFError, FileNotFoundError, OSError) as err: - print(f'{err} - loading') - return [] - return data - - -import h5py -###################################################################### -# HDF5 py files h5py -###################################################################### - - -def append_h5(filename, pathname, append_data): - """ - Append data to key in HDF5 file. - - Args: - filename (str): The filename of the HDF5 file. - pathname (str): The path to the key in the HDF5 file. - append_data (any): The data to be appended. - - Returns: - None - """ - try: - with h5py.File(filename, "a") as f: - if pathname in f: - path_data_old = np.array(f.get(pathname)) - append_data = np.append(path_data_old, np.array(append_data)) - del f[pathname] - f.create_dataset(pathname, data=np.array(append_data), maxshape=None) - except FileNotFoundError: - print(f"File not found: {filename}\nCreating new dataset: {filename}") - save_h5(filename, pathname, append_data) - - except (ValueError, KeyError) as err: - print(f"Error: {err}") - - -def overwrite_h5(filename, pathname, new_data): - """ - Overwrite key in HDF5 file. - - Args: - filename (str): The filename of the HDF5 file. - pathname (str): The path to the key in the HDF5 file. - new_data (any): The data to be overwritten. - - Returns: - None - """ - - try: - try: - with h5py.File(filename, "a") as f: - f.create_dataset(pathname, data=new_data, maxshape=None) - f.close() - except (FileNotFoundError, ValueError, KeyError): - try: - with h5py.File(filename, 'r+') as f: - del f[pathname] - f.close() - except (FileNotFoundError, ValueError, KeyError) as err: - print(f'Error: {err}') - try: - with h5py.File(filename, "a") as f: - f.create_dataset(pathname, data=new_data, maxshape=None) - f.close() - except (FileNotFoundError, ValueError, KeyError) as err: - print(f'File: {filename}{pathname}, Error: {err}') - except (BlockingIOError, OSError) as err: - print(f"\n{err}\nPath: {pathname}\nFile: {filename}\n") - return None - - -def save_h5(filename, pathname, data): - """ - Save data to HDF5 file with recursive attempt in case of write errors. - - Args: - filename (str): The filename of the HDF5 file. - pathname (str): The path to the data in the HDF5 file. - data (any): The data to be saved. - max_retries (int): Maximum number of recursive retries in case of write errors. - retry_delay (tuple): A tuple representing the range of delay (in seconds) between retries. - - Returns: - None - """ - try: - try: - with h5py.File(filename, "a") as f: - f.create_dataset(pathname, data=data, maxshape=None) - f.flush() - return - except ValueError as err: - print(f"Did not save, key: {pathname} exists in file: {filename}. {err}") - return # If the key already exists, no need to retry - except (BlockingIOError, OSError) as err: - print(f"\n{err}\nPath: {pathname}\nFile: {filename}\n") - return None - - -def read_h5(filename, pathname): - """ - Load data from HDF5 file. - - Args: - filename (str): The filename of the HDF5 file. - pathname (str): The path to the data in the HDF5 file. - - Returns: - The data loaded from the HDF5 file. - """ - try: - with h5py.File(filename, 'r') as f: - data = f.get(pathname) - if data is None: - return None - else: - return np.array(data) - except (ValueError, KeyError, TypeError): - return None - except FileNotFoundError: - print(f'File not found. {filename}') - raise - except (BlockingIOError, OSError) as err: - print(f"\n{err}\nPath: {pathname}\nFile: {filename}\n") - raise - - -def read_h5_all(file_path): - """ - Read all datasets from an HDF5 file into a dictionary. - - This function recursively traverses an HDF5 file and extracts all datasets into a dictionary. The keys of the dictionary are the paths to the datasets, and the values are the dataset contents. - - Parameters: - ---------- - file_path : str - The path to the HDF5 file from which datasets will be read. - - Returns: - ------- - dict - A dictionary where keys are the paths to datasets within the HDF5 file, and values are the contents of these datasets. - - Examples: - -------- - >>> data = read_h5_all('example.h5') - >>> print(data.keys()) - dict_keys(['/group1/dataset1', '/group2/dataset2']) - >>> print(data['/group1/dataset1']) - [1, 2, 3, 4, 5] - """ - data_dict = {} - - with h5py.File(file_path, 'r') as file: - # Recursive function to traverse the HDF5 file and populate the dictionary - def traverse(group, path=''): - for key, item in group.items(): - new_path = f"{path}/{key}" if path else key - - if isinstance(item, h5py.Group): - traverse(item, path=new_path) - else: - data_dict[new_path] = item[()] - - traverse(file) - return data_dict - - -def combine_h5(filename, files, verbose=False, overwrite=False): - """ - Combine multiple HDF5 files into a single HDF5 file. - - This function reads datasets from a list of HDF5 files and writes them to a specified output HDF5 file. If `overwrite` is `True`, it will remove any existing file at the specified `filename` before combining the files. The `verbose` parameter, if set to `True`, will display progress bars during the process. - - Parameters: - ---------- - filename : str - The path to the output HDF5 file where the combined datasets will be stored. - - files : list of str - A list of paths to the HDF5 files to be combined. - - verbose : bool, optional - If `True`, progress bars will be displayed for the file and key processing. Default is `False`. - - overwrite : bool, optional - If `True`, any existing file at `filename` will be removed before writing the new combined file. Default is `False`. - - Returns: - ------- - None - The function performs file operations and does not return any value. - - Examples: - -------- - >>> combine_h5('combined.h5', ['file1.h5', 'file2.h5'], verbose=True, overwrite=True) - """ - if verbose: - from tqdm import tqdm - iterable = enumerate(tqdm(files)) - else: - iterable = enumerate(files) - if overwrite: - rmfile(filename) - for idx, file in iterable: - if verbose: - iterable2 = tqdm(h5_keys(file)) - else: - iterable2 = files - for key in iterable2: - try: - if h5_key_exists(filename, key): - continue - save_h5(filename, key, read_h5(file, key)) - except TypeError as err: - print(read_h5(file, key)) - print(f'{err}, key: {key}, file: {file}') - print('Completed HDF5 merge.') - - -def h5_keys(file_path): - """ - List all groups in HDF5 file. - - Args: - file_path (str): The file_path of the HDF5 file. - - Returns: - A list of group keys in the HDF5 file. - """ - keys_list = [] - with h5py.File(file_path, 'r') as file: - # Recursive function to traverse the HDF5 file and collect keys - def traverse(group, path=''): - for key, item in group.items(): - new_path = f"{path}/{key}" if path else key - if isinstance(item, h5py.Group): - traverse(item, path=new_path) - else: - keys_list.append(new_path) - traverse(file) - return keys_list - - -def h5_root_keys(file_path): - """ - Retrieve the keys in the root group of an HDF5 file. - - This function opens an HDF5 file and returns a list of keys (dataset or group names) located in the root group of the file. - - Parameters: - ---------- - file_path : str - The path to the HDF5 file from which the root group keys are to be retrieved. - - Returns: - ------- - list of str - A list of keys in the root group of the HDF5 file. These keys represent the names of datasets or groups present at the root level of the file. - """ - with h5py.File(file_path, 'r') as file: - keys_in_root = list(file.keys()) - # print("Keys in the root group:", keys_in_root) - return keys_in_root - - -def h5_key_exists(filename, key): - """ - Checks if a key exists in an HDF5 file. - - Args: - filename (str): The filename of the HDF5 file. - key (str): The key to check. - - Returns: - True if the key exists, False otherwise. - """ - - try: - with h5py.File(filename, 'r') as f: - return str(key) in f - except IOError: - return False - - -###################################################################### -# CSV -###################################################################### - - -def makedf(df): - """ - Convert an input into a pandas DataFrame. - - This function takes an input which can be a list or a dictionary and converts it into a pandas DataFrame. If the input is already a DataFrame, it returns it unchanged. - - Parameters: - ---------- - df : list, dict, or pd.DataFrame - The input data to be converted into a DataFrame. This can be a list or dictionary to be transformed into a DataFrame, or an existing DataFrame which will be returned as is. - - Returns: - ------- - pd.DataFrame - A DataFrame created from the input data if the input is a list or dictionary. If the input is already a DataFrame, the original DataFrame is returned unchanged. - """ - if isinstance(df, (list, dict)): - return pd.DataFrame.from_dict(df) - else: - return df - - -def read_csv_header(file_name, sep=None): - """ - Get the header of a CSV file. - - Args: - file_name (str): The filename of the CSV file. - sep (str) optional: The delimiter used in the CSV file. - - Returns: - A list of the header fields. - """ - if sep is None: - sep = guess_csv_delimiter(file_name) # Guess the delimiter - with open(file_name, 'r') as infile: - reader = csv.DictReader(infile, delimiter=sep) - fieldnames = reader.fieldnames - return fieldnames - - -def read_csv(file_name, sep=None, dtypes=None, col=False, to_np=False, drop_nan=False, skiprows=[]): - """ - Read a CSV file with options. - - Parameters - ---------- - file_name : str - The path to the CSV file. - sep : str, optional - The delimiter used in the CSV file. If None, delimiter will be guessed. - dtypes : dict, optional - Dictionary specifying data types for columns. - col : bool or list of str, optional - Specify columns to read. If False, read all columns. - to_np : bool, optional - Convert the loaded data to a NumPy array. - drop_nan : bool, optional - Drop rows with missing values (NaNs) from the loaded DataFrame. - skiprows : list of int, optional - Rows to skip while reading the CSV file. - - Returns - ------- - DataFrame or NumPy array - The loaded data in either a DataFrame or a NumPy array format. - """ - if sep is None: - sep = guess_csv_delimiter(file_name) # Guess the delimiter - - if col is False: - try: - df = pd.read_csv(file_name, sep=sep, on_bad_lines='skip', skiprows=skiprows, dtype=dtypes) - except TypeError: - df = pd.read_csv(file_name, sep=sep, skiprows=skiprows, dtype=object) - else: - try: - if not isinstance(col, list): - col = [col] - df = pd.read_csv(file_name, sep=sep, usecols=col, on_bad_lines='skip', skiprows=skiprows, dtype=dtypes) - except TypeError: - df = pd.read_csv(file_name, sep=sep, usecols=col, skiprows=skiprows, dtype=object) - - if drop_nan: - df = df.dropna() - - if to_np: - return np.squeeze(df.to_numpy()) - else: - return df - - -def append_dict_to_csv(file_name, data_dict, delimiter='\t'): - """ - Append data from a dictionary to a CSV file. - - This function appends rows of data to a CSV file, where each key-value pair in the dictionary represents a column. If the CSV file does not already exist, it creates the file and writes the header row using the dictionary keys. - - Parameters: - ---------- - file_name : str - Path to the CSV file where data will be appended. - data_dict : dict - Dictionary where keys are column headers and values are lists of data to be written to the CSV file. All lists should be of the same length. - delimiter : str, optional - The delimiter used in the CSV file (default is tab `\t`). - - Notes: - ------ - - The function assumes that all lists in the dictionary `data_dict` have the same length. - - If the CSV file already exists, only the data rows are appended. If it doesn't exist, a new file is created with the header row based on the dictionary keys. - - The `delimiter` parameter allows specifying the delimiter used in the CSV file. Common values are `,` for commas and `\t` for tabs. - - Example: - -------- - >>> data_dict = { - >>> 'Name': ['Alice', 'Bob', 'Charlie'], - >>> 'Age': [25, 30, 35], - >>> 'City': ['New York', 'Los Angeles', 'Chicago'] - >>> } - >>> append_dict_to_csv('people.csv', data_dict, delimiter=',') - This will append data to 'people.csv', creating it if it does not exist, with columns 'Name', 'Age', 'City'. - - Dependencies: - -------------- - - `os.path.exists`: Used to check if the file already exists. - - `csv`: Standard library module used for reading and writing CSV files. - """ - # Extract keys and values from the dictionary - keys = list(data_dict.keys()) - values = list(data_dict.values()) - - # Determine the length of the arrays - array_length = len(values[0]) - - # Determine if file exists - file_exists = os.path.exists(file_name) - - # Open the CSV file in append mode - with open(file_name, 'a', newline='') as csvfile: - writer = csv.writer(csvfile, delimiter=delimiter) - - # Write header if file doesn't exist - if not file_exists: - writer.writerow(keys) - - # Write each element from arrays as a new row - for i in range(array_length): - row = [values[j][i] for j in range(len(keys))] - writer.writerow(row) - - -def guess_csv_delimiter(file_name): - """ - Guess the delimiter used in a CSV file. - - Args: - file_name (str): The path to the CSV file. - - Returns: - str: Guessed delimiter (one of ',', '\t', ';') - """ - with open(file_name, 'r', newline='') as file: - sample = file.read(4096) # Read a sample of the file's contents - sniffer = csv.Sniffer() - dialect = sniffer.sniff(sample) - return dialect.delimiter - - -def save_csv(file_name, df, sep='\t', dtypes=None): - """ - Save a Pandas DataFrame to a CSV file. - - Args: - file_name (str): The path to the CSV file. - df (DataFrame): The Pandas DataFrame to save. - sep (str): The delimiter used in the CSV file. - dtypes (dict): A dictionary specifying data types for columns. - - Returns: - None - """ - df = makedf(df) - - if dtypes: - df = df.astype(dtypes) - - df.to_csv(file_name, index=False, sep=sep) - print(f'Saved {file_name} successfully.') - return - - -def append_csv(file_names, save_path='combined_data.csv', sep=None, dtypes=False, progress=None): - """ - Appends multiple CSV files into a single CSV file. - - Args: - file_names (list): A list of CSV file names. - save_path (str): The path to the output CSV file. If not specified, the output will be saved to the current working directory. - sep (str): The delimiter used in the CSV files. - dtypes (dict): A dictionary specifying data types for columns. - - Returns: - None - """ - - error_files = [] - dataframes = [] - for i, file in enumerate(file_names): - try: - if sep is None: - sep = guess_csv_delimiter(file) # Guess the delimiter - df = pd.read_csv(file, sep=sep) - dataframes.append(df) - if progress is not None: - get_memory_usage() - print(f"Appended {i+1} of {len(file_names)}.") - except (FileNotFoundError, pd.errors.EmptyDataError, pd.errors.ParserError) as e: - error_files.append(file) - print(f"Error processing file {file}: {e}") - - combined_df = pd.concat(dataframes, ignore_index=True) - if dtypes: - combined_df = combined_df.astype(dtypes) - - if save_path: - combined_df.to_csv(save_path, sep=sep, index=False) - else: - combined_df.to_csv('combined_data.csv', sep=sep, index=False) - - print(f'The final dataframe has {combined_df.shape[0]} rows and {combined_df.shape[1]} columns.') - if error_files: - print(f'The following files ERRORED and were not included: {error_files}') - return - - -def append_csv_on_disk(csv_files, output_file): - """ - Append multiple CSV files into a single CSV file. - - This function merges multiple CSV files into one output CSV file. The output file will contain the header row from the first CSV file and data rows from all input CSV files. - - Parameters: - ---------- - csv_files : list of str - List of file paths to the CSV files to be merged. All CSV files should have the same delimiter and structure. - output_file : str - Path to the output CSV file where the merged data will be written. - - Notes: - ------ - - The function assumes all input CSV files have the same delimiter. It determines the delimiter from the first CSV file using the `guess_csv_delimiter` function. - - Only the header row from the first CSV file is included in the output file. Headers from subsequent files are ignored. - - This function overwrites the output file if it already exists. - - Example: - -------- - >>> csv_files = ['file1.csv', 'file2.csv', 'file3.csv'] - >>> output_file = 'merged_output.csv' - >>> append_csv_on_disk(csv_files, output_file) - Completed appending of: merged_output.csv. - - Dependencies: - -------------- - - `guess_csv_delimiter` function: A utility function used to guess the delimiter of the CSV files. - - `csv` module: Standard library module used for reading and writing CSV files. - """ - # Assumes each file has the same delimiters - delimiter = guess_csv_delimiter(csv_files[0]) - # Open the output file for writing - with open(output_file, 'w', newline='') as outfile: - # Initialize the CSV writer - writer = csv.writer(outfile, delimiter=delimiter) - - # Write the header row from the first CSV file - with open(csv_files[0], 'r', newline='') as first_file: - reader = csv.reader(first_file, delimiter=delimiter) - header = next(reader) - writer.writerow(header) - - # Write the data rows from the first CSV file - for row in reader: - writer.writerow(row) - - # Write the data rows from the remaining CSV files - for file in csv_files[1:]: - with open(file, 'r', newline='') as infile: - reader = csv.reader(infile, delimiter=delimiter) - next(reader) # Skip the header row - for row in reader: - writer.writerow(row) - print(f'Completed appending of: {output_file}.') - - -def save_csv_header(filename, header, delimiter='\t'): - """ - Saves a header row to a CSV file with a specified delimiter. - - Parameters: - filename (str): The name of the file where the header will be saved. - header (list): A list of strings representing the column names. - delimiter (str, optional): The delimiter to use between columns in the CSV file. - Default is tab ('\t'). - - Example: - save_csv_header('output.csv', ['Name', 'Age', 'City'], delimiter=',') - """ - with open(filename, 'w', newline='') as csvfile: - writer = csv.writer(csvfile, delimiter=delimiter) - writer.writerow(header) - - -def save_csv_array_to_line(filename, array, delimiter='\t'): - """ - Appends a single row of data to a CSV file with a specified delimiter. - - Parameters: - filename (str): The name of the file to which the row will be appended. - array (list): A list of values representing a single row of data to be appended to the CSV file. - delimiter (str, optional): The delimiter to use between columns in the CSV file. - Default is tab ('\t'). - - Example: - save_csv_array_to_line('output.csv', ['Alice', 30, 'New York'], delimiter=',') - """ - with open(filename, 'a', newline='') as csvfile: - writer = csv.writer(csvfile, delimiter=delimiter) - writer.writerow(array) - - -def save_csv_line(file_name, df, sep='\t', dtypes=None): - """ - Save a Pandas DataFrame to a CSV file, appending the DataFrame to the file if it exists. - - Args: - file_name (str): The path to the CSV file. - df (DataFrame): The Pandas DataFrame to save. - sep (str): The delimiter used in the CSV file. - - Returns: - None - """ - df = makedf(df) - if dtypes: - df = df.astype(dtypes) - if exists(file_name): - df.to_csv(file_name, mode='a', index=False, header=False, sep=sep) - else: - save_csv(file_name, df, sep=sep) - return - - -_column_data = None -def exists_in_csv(csv_file, column, number, sep='\t'): - """ - Checks if a number exists in a specific column of a CSV file. - - This function reads a specified column from a CSV file and checks if a given number is present in that column. - - Parameters: - ---------- - csv_file : str - Path to the CSV file. - column : str or int - The column to search in. - number : int or float - The number to check for existence in the column. - sep : str, default='\t' - Delimiter used in the CSV file. - - Returns: - ------- - bool - True if the number exists in the column, False otherwise. - """ - try: - global _column_data - if _column_data is None: - _column_data = read_csv(csv_file, sep=sep, col=column, to_np=True) - return np.isin(number, _column_data) - except IOError: - return False - - -def exists_in_csv_old(csv_file, column, number, sep='\t'): - """ - Check if a specific value exists in a given column of a CSV file. - - This function reads a CSV file and checks whether the specified `number` - exists in the specified `column`. If the file cannot be opened or read, - the function returns `False`. - - Args: - csv_file (str): The path to the CSV file. - column (str): The name of the column to search in. - number (int or str): The value to search for in the specified column. - sep (str, optional): The delimiter used in the CSV file. Defaults to '\t'. - - Returns: - bool: - - `True` if the value exists in the specified column. - - `False` if the value does not exist or if the file cannot be opened. - """ - try: - with open(csv_file, 'r') as f: - reader = csv.DictReader(f, delimiter=sep) - for row in reader: - if row[column] == str(number): - return True - except IOError: - return False - - -def pd_flatten(data, factor=1): - """ - Flatten and process a list of data values. - - This function takes a list of data values, attempts to split each value - based on commas (excluding the first and last characters), and flattens - the resulting list. If splitting fails (e.g., due to a `TypeError`), the - original value is added to the result. Finally, all values are converted - to floats and divided by the specified `factor`. - - Args: - data (list): A list of data values to be processed. Each value can be - a string or a type that supports slicing and splitting. - factor (float, optional): A divisor applied to each processed value. - Defaults to 1. - - Returns: - list: A list of processed float values, flattened and divided by `factor`. - """ - tmp = [] - for x in data: - try: - tmp.extend(x[1:-1].split(',')) - except TypeError: - tmp.append(x) - return [float(x) / factor for x in tmp] - -# -# TURN AN ARRAY SAVED AS A STRING BACK INTO AN ARRAY - - -def str_to_array(s): - """ - Convert a string representation of an array back into a NumPy array. - - This function takes a string formatted as an array (e.g., "[1.0, 2.0, 3.0]"), - removes the square brackets, splits the elements by commas, and converts - them into a NumPy array of floats. - - Args: - s (str): A string representation of an array, with elements separated - by commas and enclosed in square brackets. - - Returns: - numpy.ndarray: A NumPy array containing the float values extracted - from the input string. - """ - s = s.replace('[', '').replace(']', '') # Remove square brackets - return np.array([float(x) for x in s.split(',')]) - - -def pdstr_to_arrays(df): - """ - Convert a pandas Series or DataFrame with string representations of arrays - into a NumPy array of actual arrays. - - This function applies the `str_to_array` function to each element of the - input pandas object (Series or DataFrame), converting string representations - of arrays into NumPy arrays. The result is returned as a NumPy array. - - Args: - df (pandas.Series or pandas.DataFrame): A pandas object containing - string representations of arrays. - - Returns: - numpy.ndarray: A NumPy array where each element is a NumPy array - derived from the corresponding string in the input. - """ - return df.apply(str_to_array).to_numpy() - - -def get_all_files_recursive(path_name=os.getcwd()): - """ - Recursively retrieve all file paths from a directory and its subdirectories. - - This function walks through the directory tree starting from the specified - path and collects the full paths of all files found. If no path is provided, - it defaults to the current working directory. - - Args: - path_name (str, optional): The root directory to start the search. - Defaults to the current working directory. - - Returns: - list: A list of full file paths for all files found in the directory - tree starting at `path_name`. - """ - listOfFiles = list() - for (dirpath, dirnames, filenames) in os.walk(path_name): - listOfFiles += [os.path.join(dirpath, file) for file in filenames] - return listOfFiles diff --git a/ssapy/plotUtils.py b/ssapy/plotUtils.py index 3f0c8cf6..67f24e94 100644 --- a/ssapy/plotUtils.py +++ b/ssapy/plotUtils.py @@ -1,29 +1,13 @@ """ Utility functions for plotting. """ - - -from .body import get_body -from .compute import groundTrack, lagrange_points_lunar_frame, calculate_orbital_elements -from .constants import RGEO, LD, EARTH_RADIUS, MOON_RADIUS, EARTH_MU, MOON_MU -from .utils import find_file, Time, find_smallest_bounding_cube, gcrf_to_itrf, gcrf_to_lunar_fixed, gcrf_to_lunar +from .constants import EARTH_RADIUS, MOON_RADIUS +from .utils import find_file, Time import numpy as np -import os -import re -import io - -import matplotlib.pyplot as plt -import matplotlib.cm as cm -from matplotlib import colors as mplcolors - -from PyPDF2 import PdfMerger -from matplotlib.backends.backend_pdf import PdfPages from PIL import Image as PILImage import ipyvolume as ipv -from typing import Union - def load_earth_file(): """ @@ -158,1287 +142,4 @@ def draw_moon(time, ngrid=100, R=MOON_RADIUS, rfactor=1): u=u, v=v, wireframe=False, texture=moon - ) - - -def ground_track_plot(r, t, ground_stations=None, save_path=False): - """ - Parameters - ---------- - r : (3,) array_like - Orbit positions in meters. - t: (n,) array_like - array of Astropy Time objects or time in gps seconds. - - optional - ground_stations: (n,2) array of of ground station (lat,lon) in degrees - """ - lon, lat, height = groundTrack(r, t) - - fig = plt.figure(figsize=(15, 12)) - plt.imshow(load_earth_file(), extent=[-180, 180, -90, 90]) - plt.plot(np.rad2deg(lon), np.rad2deg(lat)) - if ground_stations is not None: - for ground_station in ground_stations: - plt.scatter(ground_station[1], ground_station[0], s=50, color='Red') - plt.ylim(-90, 90) - plt.xlim(-180, 180) - plt.show() - if save_path: - save_plot(fig, save_path) - - -def groundTrackVideo(r, time): - """ - Parameters - ---------- - r : (3,) array_like - Position of orbiting object in meters. - t : float or astropy.time.Time - If float or array of float, then should correspond to GPS seconds; i.e., - seconds since 1980-01-06 00:00:00 UTC - """ - ipvfig = ipv.figure(width=2000 / 2, height=1000 / 2) - ipv.style.set_style_dark() - ipv.style.box_off() - ipv.style.axes_off() - widgets = [] - widgets.append(draw_earth(time)) - widgets.append( - ipv.scatter( - r[:, 0, None], - r[:, 1, None], - r[:, 2, None], - marker='sphere', - color='magenta', - size=10 # Increase the dot size (default is 1) - ) - ) - # Line plot showing the path - widgets.append( - ipv.plot( - r[:, 0], - r[:, 1], - r[:, 2], - color='white', - linewidth=1 - ) - ) - ipv.animation_control(widgets, sequence_length=len(time), interval=0) - ipv.xyzlim(-10_000_000, 10_000_000) - ipvfig.camera.position = (-2, 0, 0.2) - ipvfig.camera.up = (0, 0, 1) - ipv.show() - - -def check_numpy_array(variable: Union[np.ndarray, list]) -> str: - """ - Checks if the input variable is a NumPy array, a list of NumPy arrays, or neither. - - Parameters - ---------- - variable : Union[np.ndarray, list] - The variable to check. It can either be a NumPy array or a list of NumPy arrays. - - Returns - ------- - str - Returns a string indicating the type of the variable: - - "numpy array" if the variable is a single NumPy array, - - "list of numpy array" if it is a list of NumPy arrays, - - "not numpy" if it is neither. - """ - if isinstance(variable, np.ndarray): - return "numpy array" - elif isinstance(variable, list): - if len(variable) == 0: # Handle empty list explicitly - return "not numpy" - elif all(isinstance(item, np.ndarray) for item in variable): - return "list of numpy array" - return "not numpy" - - -def check_type(t): - """ - Determines the type of the input and provides a description based on its structure. - - This function checks the input `t` and returns a string describing its type or structure: - - If `t` is `None`, it returns `None`. - - If `t` is a `list`, it checks whether all elements in the list are either lists or NumPy arrays: - - Returns "List of arrays" if all elements are lists or arrays. - - Returns "List of non-arrays" if not all elements are lists or arrays. - - If `t` is a `Time` object or a NumPy array, it returns "Single array or list". - - For any other type, it returns "Not a list or array". - - Args: - t (Any): The input to be checked. - - Returns: - str or None: A description of the type or structure of `t`. - """ - if t is None: - return None - elif isinstance(t, list): - # Check if each element is a list or array - if all(isinstance(item, (list, np.ndarray)) for item in t): - return "List of arrays" - else: - return "List of non-arrays" - elif isinstance(t, (Time, np.ndarray)): - return "Single array or list" - else: - return "Not a list or array" - - -def orbit_plot(r, t=None, title='', figsize=(7, 7), save_path=False, frame="gcrf", show=False): - """ - Plots the trajectory of one or more orbits in various views and coordinate frames. - - This function visualizes the position data of one or more orbits in 2D and 3D plots. - It supports different reference frames (e.g., GCRF, ITRF, Lunar) and allows customization - of plot appearance, including figure size, title, and saving the output. - - The function generates the following plots: - - XY plane scatter plot with Earth/Moon markers and optional Lagrange points. - - XZ plane scatter plot with Earth/Moon markers. - - YZ plane scatter plot with Earth/Moon markers. - - 3D scatter plot of the orbit(s) with Earth/Moon represented as spheres. - - Args: - r (numpy.ndarray or list of numpy.ndarray): The position data of the orbit(s). - Can be a single NumPy array for one orbit or a list of arrays for multiple orbits. - t (numpy.ndarray or list, optional): Time data corresponding to the position data. - Must match the shape of `r` or be a list of arrays for multiple orbits. - Defaults to None. - title (str, optional): The title of the plot. Defaults to an empty string. - figsize (tuple, optional): The size of the figure in inches (width, height). - Defaults to (7, 7). - save_path (str or bool, optional): Path to save the plot. If False, the plot is not saved. - Defaults to False. - frame (str, optional): The reference frame for the plot. Accepted values are - "gcrf", "itrf", "lunar", "lunar fixed", or "lunar axis". Defaults to "gcrf". - show (bool, optional): Whether to display the plot. Defaults to False. - - Returns: - tuple: A tuple containing: - - fig (matplotlib.figure.Figure): The figure object. - - axes (list): A list of subplot axes [ax1, ax2, ax3, ax4]. - - Raises: - ValueError: If the input `r` or `t` is not in a valid format or if the specified frame is not recognized. - - Notes: - - The function supports transformations between coordinate frames and adjusts the plot accordingly. - - Orbital bodies (Earth, Moon) are represented as spheres, scaled appropriately. - - Lagrange points are plotted for Lunar frames, with markers and labels. - - The bounds of the plots are dynamically adjusted based on the input data. - - The function allows saving the plot to a specified path and optionally displaying it. - - The axes are styled with a black background and white labels/ticks for better visibility. - """ - input_type = check_numpy_array(r) - t_type = check_type(t) - - if input_type == "numpy array": - num_orbits = 1 - r = [r] - - if input_type == "list of numpy array": - num_orbits = len(r) - - fig = plt.figure(dpi=100, figsize=figsize, facecolor='black') - ax1 = fig.add_subplot(2, 2, 1) - ax2 = fig.add_subplot(2, 2, 2) - ax3 = fig.add_subplot(2, 2, 3) - ax4 = fig.add_subplot(2, 2, 4, projection='3d') - - bounds = {"lower": np.array([np.inf, np.inf, np.inf]), "upper": np.array([-np.inf, -np.inf, -np.inf])} - - # Check if all arrays in `r` are the same shape - same_shape = all(np.shape(arr)[0] == np.shape(r[0]) for arr in r) - for orbit_index in range(num_orbits): - xyz = r[orbit_index] - - if t_type is None: - if frame == "gcrf": - r_moon = np.atleast_2d(get_body("moon").position(Time("2000-1-1"))) - else: - raise ValueError("Need to provide t or list of t for each orbit in itrf, lunar or lunar fixed frames") - else: - if frame == "gcrf": - if t_type == "Single array or list": - t_current = t - elif t_type == "List of non-arrays" or t_type == "List of arrays": - t_current = max(t, key=len) - else: - if input_type == "numpy array": - # Single array case - t_current = t - if np.shape(t)[0] != np.shape(r)[1]: - raise ValueError("For a single numpy array 'r', 't' must be a 1D array of the same length as the first dimension of 'r'.") - - elif input_type == "list of numpy array": - if same_shape: - if t_type == "Single array or list": - t_current = t - elif t_type == "List of non-arrays" or t_type == "List of arrays": - t_current = max(t, key=len) - # Single `t` array is allowed - if len(t_current) != len(xyz): - raise ValueError("When 'r' is a list of arrays with the same shape, 't' must be a single 1D array matching the length of the first dimension of the arrays in 'r'.") - else: - # `t` must be a list of 1D arrays - if t_type == "Single array or list": - raise ValueError("When 'r' is a list of differing size numpy arrays, 't' must be a list of 1D arrays of equal length to the corresponding arrays in 'r'.") - elif t_type == "List of non-arrays" or t_type == "List of arrays": - if len(xyz) == len(t[orbit_index]): - t_current = t[orbit_index] - else: - print(f"length of t: {len(t_current)} and r: {len(xyz)}") - raise ValueError(f"'t' must be a 1D array matching the length of the first dimension of 'r[{orbit_index}]'.") - - r_moon = get_body("moon").position(t_current).T - r_earth = np.zeros(np.shape(r_moon)) - - # Dictionary of frame transformations and titles - def get_main_category(frame): - variant_mapping = { - "gcrf": "gcrf", - "gcrs": "gcrf", - "itrf": "itrf", - "itrs": "itrf", - "lunar": "lunar", - "lunar_fixed": "lunar", - "lunar fixed": "lunar", - "lunar_centered": "lunar", - "lunar centered": "lunar", - "lunarearthfixed": "lunar axis", - "lunarearth": "lunar axis", - "lunar axis": "lunar axis", - "lunar_axis": "lunar axis", - "lunaraxis": "lunar axis", - } - return variant_mapping.get(frame.lower()) - - frame_transformations = { - "gcrf": ("GCRF", None), - "itrf": ("ITRF", gcrf_to_itrf), - "lunar": ("Lunar Frame", gcrf_to_lunar_fixed), - "lunar axis": ("Moon on x-axis Frame", gcrf_to_lunar), - } - - # Check if the frame is in the dictionary, and set central_dot accordingly - frame = get_main_category(frame) - if frame in frame_transformations: - title2, transform_func = frame_transformations[frame] - if transform_func: - xyz = transform_func(xyz, t_current) - r_moon = transform_func(r_moon, t_current) - r_earth = transform_func(r_earth, t_current) - else: - raise ValueError("Unknown plot type provided. Accepted: gcrf, itrf, lunar, lunar fixed") - - xyz = xyz / RGEO - r_moon = r_moon / RGEO - r_earth = r_earth / RGEO - - lower_bound_temp, upper_bound_temp = find_smallest_bounding_cube(xyz, pad=1) - bounds["lower"] = np.minimum(bounds["lower"], lower_bound_temp) - bounds["upper"] = np.maximum(bounds["upper"], upper_bound_temp) - - if np.size(r_moon[:, 0]) > 1: - grey_colors = cm.Greys(np.linspace(0, .8, len(r_moon[:, 0])))[::-1] - blues = cm.Blues(np.linspace(.4, .9, len(r_moon[:, 0])))[::-1] - else: - grey_colors = "grey" - blues = 'Blue' - plot_settings = { - "gcrf": { - "primary_color": "blue", - "primary_size": (EARTH_RADIUS / RGEO), - "secondary_x": r_moon[:, 0], - "secondary_y": r_moon[:, 1], - "secondary_z": r_moon[:, 2], - "secondary_color": grey_colors, - "secondary_size": (MOON_RADIUS / RGEO) - }, - "itrf": { - "primary_color": "blue", - "primary_size": (EARTH_RADIUS / RGEO), - "secondary_x": r_moon[:, 0], - "secondary_y": r_moon[:, 1], - "secondary_z": r_moon[:, 2], - "secondary_color": grey_colors, - "secondary_size": (MOON_RADIUS / RGEO) - }, - "lunar": { - "primary_color": "grey", - "primary_size": (MOON_RADIUS / RGEO), - "secondary_x": r_earth[:, 0], - "secondary_y": r_earth[:, 1], - "secondary_z": r_earth[:, 2], - "secondary_color": blues, - "secondary_size": (EARTH_RADIUS / RGEO) - }, - "lunar axis": { - "primary_color": "blue", - "primary_size": (EARTH_RADIUS / RGEO), - "secondary_x": r_moon[:, 0], - "secondary_y": r_moon[:, 1], - "secondary_z": r_moon[:, 2], - "secondary_color": grey_colors, - "secondary_size": (MOON_RADIUS / RGEO) - } - } - try: - stn = plot_settings[frame] - except KeyError: - raise ValueError("Unknown plot type provided. Accepted: 'gcrf', 'itrf', 'lunar', 'lunar fixed'") - - if input_type == "numpy array": - scatter_dot_colors = cm.rainbow(np.linspace(0, 1, len(xyz[:, 0]))) - else: - scatter_dot_colors = cm.rainbow(np.linspace(0, 1, num_orbits))[orbit_index] - - ax1.scatter(xyz[:, 0], xyz[:, 1], color=scatter_dot_colors, s=1) - ax1.add_patch(plt.Circle(xy=(0, 0), radius=1, color='white', linestyle='dashed', fill=False)) # Circle marking GEO - ax1.add_patch(plt.Circle(xy=(0, 0), radius=stn['primary_size'], color=stn['primary_color'], linestyle='dashed', fill=False)) # Circle marking EARTH or MOON - if r_moon[:, 0] is not False: - ax1.scatter(stn['secondary_x'], stn['secondary_y'], color=stn['secondary_color'], s=stn['secondary_size']) - ax1.set_aspect('equal') - ax1.set_xlabel('x [GEO]', color='white') - ax1.set_ylabel('y [GEO]', color='white') - ax1.set_title(f'Frame: {title2}', color='white') - if 'lunar' in frame: - colors = ['red', 'green', 'purple', 'orange', 'cyan'] - for (point, pos), color in zip(lagrange_points_lunar_frame().items(), colors): - if 'axis' in frame: - pass - else: - pos[0] = pos[0] - LD / RGEO - if bounds["lower"][0] <= pos[0] <= bounds["upper"][0] and bounds["lower"][1] <= pos[1] <= bounds["upper"][1]: - ax1.scatter(pos[0], pos[1], color='white', label=point, s=10) - ax1.text(pos[0], pos[1], point, color='white') - - ax2.scatter(xyz[:, 0], xyz[:, 2], color=scatter_dot_colors, s=1) - ax2.add_patch(plt.Circle(xy=(0, 0), radius=1, color='white', linestyle='dashed', fill=False)) # Circle marking GEO - ax2.add_patch(plt.Circle(xy=(0, 0), radius=stn['primary_size'], color=stn['primary_color'], linestyle='dashed', fill=False)) # Circle marking EARTH or MOON - if r_moon[:, 0] is not False: - ax2.scatter(stn['secondary_x'], stn['secondary_z'], color=stn['secondary_color'], s=stn['secondary_size']) - ax2.set_aspect('equal') - ax2.set_xlabel('x [GEO]', color='white') - ax2.set_ylabel('z [GEO]', color='white') - ax2.yaxis.tick_right() # Move y-axis ticks to the right - ax2.yaxis.set_label_position("right") # Move y-axis label to the right - ax2.set_title(f'{title}', color='white') - if 'lunar' in frame: - colors = ['red', 'green', 'purple', 'orange', 'cyan'] - for (point, pos), color in zip(lagrange_points_lunar_frame().items(), colors): - if 'axis' in frame: - pass - else: - pos[0] = pos[0] - LD / RGEO - if bounds["lower"][0] <= pos[0] <= bounds["upper"][0] and bounds["lower"][2] <= pos[2] <= bounds["upper"][2]: - ax2.scatter(pos[0], pos[2], color='white', label=point, s=10) - ax2.text(pos[0], pos[2], point, color='white') - - ax3.scatter(xyz[:, 1], xyz[:, 2], color=scatter_dot_colors, s=1) - ax3.add_patch(plt.Circle(xy=(0, 0), radius=1, color='white', linestyle='dashed', fill=False)) - ax3.add_patch(plt.Circle(xy=(0, 0), radius=stn['primary_size'], color=stn['primary_color'], linestyle='dashed', fill=False)) # Circle marking EARTH or MOON - if r_moon[:, 0] is not False: - ax1.scatter(stn['secondary_y'], stn['secondary_z'], color=stn['secondary_color'], s=stn['secondary_size']) - ax3.set_aspect('equal') - ax3.set_xlabel('y [GEO]', color='white') - ax3.set_ylabel('z [GEO]', color='white') - if 'lunar' in frame: - colors = ['red', 'green', 'purple', 'orange', 'cyan'] - for (point, pos), color in zip(lagrange_points_lunar_frame().items(), colors): - if 'axis' in frame: - pass - else: - pos[0] = pos[0] - LD / RGEO - if bounds["lower"][1] <= pos[1] <= bounds["upper"][1] and bounds["lower"][2] <= pos[2] <= bounds["upper"][2]: - ax3.scatter(pos[1], pos[2], color='white', label=point, s=10) - ax3.text(pos[1], pos[2], point, color='white') - - # Create a 3d sphere of the Earth and Moon - u = np.linspace(0, 2 * np.pi, 180) - v = np.linspace(-np.pi/2, np.pi/2, 180) - - ax4.scatter3D(xyz[:, 0], xyz[:, 1], xyz[:, 2], color=scatter_dot_colors, s=1) - mesh_x = np.outer(np.cos(u), np.cos(v)).T * stn['primary_size'] + 0 - mesh_y = np.outer(np.sin(u), np.cos(v)).T * stn['primary_size'] + 0 - mesh_z = np.outer(np.ones(np.size(u)), np.sin(v)).T * stn['primary_size'] + 0 - ax4.plot_surface(mesh_x, mesh_y, mesh_z, color=stn['primary_color'], alpha=0.6, edgecolor='none') - if r_moon[:, 0] is not False: - ax4.scatter3D(stn['secondary_x'], stn['secondary_y'], stn['secondary_z'], color=stn['secondary_color'], s=stn['secondary_size']) - - ax4.set_xlabel('x [GEO]', color='white') - ax4.set_ylabel('y [GEO]', color='white') - ax4.set_zlabel('z [GEO]', color='white') - if 'lunar' in frame: - colors = ['red', 'green', 'purple', 'orange', 'cyan'] - for (point, pos), color in zip(lagrange_points_lunar_frame().items(), colors): - if 'axis' in frame: - pass - else: - pos[0] = pos[0] - LD / RGEO - if bounds["lower"][0] <= pos[0] <= bounds["upper"][0] and bounds["lower"][1] <= pos[1] <= bounds["upper"][1] and bounds["lower"][2] <= pos[2] <= bounds["upper"][2]: - ax4.scatter(pos[0], pos[1], pos[2], color='white', label=point, s=10) - ax4.text(pos[0], pos[1], pos[2], point, color='white') - - ax1.set_xlim(bounds["lower"][0], bounds["upper"][0]) - ax1.set_ylim(bounds["lower"][1], bounds["upper"][1]) - - ax2.set_xlim(bounds["lower"][0], bounds["upper"][0]) - ax2.set_ylim(bounds["lower"][2], bounds["upper"][2]) - - ax3.set_xlim(bounds["lower"][1], bounds["upper"][1]) - ax3.set_ylim(bounds["lower"][2], bounds["upper"][2]) - - ax4.set_xlim(bounds["lower"][0], bounds["upper"][0]) - ax4.set_ylim(bounds["lower"][1], bounds["upper"][1]) - ax4.set_zlim(bounds["lower"][2], bounds["upper"][2]) - ax4.set_box_aspect([1, 1, 1]) - - for ax in [ax1, ax2, ax3, ax4]: - ax.set_facecolor('black') - ax.tick_params(axis='both', colors='white') - for label in ax.get_xticklabels() + ax.get_yticklabels(): - label.set_color('white') - for spine in ax.spines.values(): - spine.set_edgecolor('white') - - if save_path: - save_plot(fig, save_path) - if show: - plt.show() - plt.close() - return fig, [ax1, ax2, ax3, ax4] - - -def globe_plot(r, t, limits=False, title='', figsize=(7, 8), save_path=False, el=30, az=0, scale=1): - """ - Plot a 3D scatter plot of position vectors on a globe representation. - - Parameters: - - r (array-like): Position vectors with shape (n, 3), where n is the number of points. - - t (array-like): Time array corresponding to the position vectors. This parameter is not used in the current function implementation but is included for consistency. - - limits (float, optional): The limit for the plot axes. If not provided, it is calculated based on the data. Default is False. - - title (str, optional): Title of the plot. Default is an empty string. - - figsize (tuple of int, optional): Figure size (width, height) in inches. Default is (7, 8). - - save_path (str, optional): Path to save the generated plot. If not provided, the plot will not be saved. Default is False. - - el (int, optional): Elevation angle (in degrees) for the view of the plot. Default is 30. - - az (int, optional): Azimuth angle (in degrees) for the view of the plot. Default is 0. - - scale (int, optional): Scale factor for resizing the Earth image. Default is 1. - - Returns: - - fig (matplotlib.figure.Figure): The figure object containing the plot. - - ax (matplotlib.axes._subplots.Axes3DSubplot): The 3D axis object used in the plot. - - The function creates a 3D scatter plot of the position vectors on a globe. The globe is represented using a textured Earth image, and the scatter points are colored using a rainbow colormap. The plot's background is set to black, and the plot is displayed with customizable elevation and azimuth angles. - - Example usage: - ``` - import numpy as np - from your_module import globe_plot - - # Example data - r = np.array([[1, 2, 3], [4, 5, 6]]) # Replace with actual data - t = np.arange(len(r)) # Replace with actual time data - - globe_plot(r, t, save_path='globe_plot.png') - ``` - """ - x = r[:, 0] / RGEO - y = r[:, 1] / RGEO - z = r[:, 2] / RGEO - if limits is False: - limits = np.nanmax(np.abs([x, y, z])) * 1.2 - - earth_png = PILImage.open(find_file("earth", ext=".png")) - earth_png = earth_png.resize((5400 // scale, 2700 // scale)) - bm = np.array(earth_png.resize([int(d) for d in earth_png.size])) / 256. - lons = np.linspace(-180, 180, bm.shape[1]) * np.pi / 180 - lats = np.linspace(-90, 90, bm.shape[0])[::-1] * np.pi / 180 - mesh_x = np.outer(np.cos(lons), np.cos(lats)).T * EARTH_RADIUS / RGEO - mesh_y = np.outer(np.sin(lons), np.cos(lats)).T * EARTH_RADIUS / RGEO - mesh_z = np.outer(np.ones(np.size(lons)), np.sin(lats)).T * EARTH_RADIUS / RGEO - - scatter_dot_colors = plt.cm.rainbow(np.linspace(0, 1, len(x))) - fig = plt.figure(dpi=100, figsize=figsize) - ax = fig.add_subplot(111, projection='3d') - fig.patch.set_facecolor('black') - ax.tick_params(axis='both', colors='white') - ax.grid(True, color='grey', linestyle='--', linewidth=0.5) - ax.set_facecolor('black') # Set plot background color to black - ax.scatter(x, y, z, color=scatter_dot_colors, s=1) - ax.plot_surface(mesh_x, mesh_y, mesh_z, rstride=4, cstride=4, facecolors=bm, shade=False) - ax.view_init(elev=el, azim=az) - ax.set_xlim([-limits, limits]) - ax.set_ylim([-limits, limits]) - ax.set_zlim([-limits, limits]) - ax.set_xlabel('x [GEO]', color='white') # Set x-axis label color to white - ax.set_ylabel('y [GEO]', color='white') # Set y-axis label color to white - ax.set_zlabel('z [GEO]', color='white') # Set z-axis label color to white - ax.tick_params(axis='x', colors='white') # Set x-axis tick color to white - ax.tick_params(axis='y', colors='white') # Set y-axis tick color to white - ax.tick_params(axis='z', colors='white') # Set z-axis tick color to white - ax.set_aspect('equal') - fig, ax = set_color_theme(fig, ax, theme='black') - if save_path: - save_plot(fig, save_path) - return fig, ax - - -def koe_plot(r, v, t=np.linspace(Time("2025-01-01", scale='utc'), Time("2026-01-01", scale='utc'), int(365.25*24)), elements=['a', 'e', 'i'], save_path=False, body='Earth'): - """ - Plot Keplerian orbital elements over time for a given trajectory. - - Parameters: - - r (array-like): Position vectors for the orbit. - - v (array-like): Velocity vectors for the orbit. - - t (array-like, optional): Time array for the plot, given as a sequence of `astropy.time.Time` objects or a `Time` object with `np.linspace`. Default is one year of hourly intervals starting from "2025-01-01". - - elements (list of str, optional): List of orbital elements to plot. Options include 'a' (semi-major axis), 'e' (eccentricity), and 'i' (inclination). Default is ['a', 'e', 'i']. - - save_path (str, optional): Path to save the generated plot. If not provided, the plot will not be saved. Default is False. - - body (str, optional): The celestial body for which to calculate the orbital elements. Options are 'Earth' or 'Moon'. Default is 'Earth'. - - Returns: - - fig (matplotlib.figure.Figure): The figure object containing the plot. - - ax1 (matplotlib.axes.Axes): The primary axis object used in the plot. - - The function calculates orbital elements for the given position and velocity vectors, and plots these elements over time. It creates a plot with two y-axes: one for the eccentricity and inclination, and the other for the semi-major axis. The x-axis represents time in decimal years. - - Example usage: - ``` - import numpy as np - from astropy.time import Time - from your_module import koe_plot - - # Example data - r = np.array([[[1, 0, 0], [0, 1, 0]]]) # Replace with actual data - v = np.array([[[0, 1, 0], [-1, 0, 0]]]) # Replace with actual data - t = Time("2025-01-01", scale='utc') + np.linspace(0, int(1 * 365.25), int(365.25 * 24)) - - koe_plot(r, v, t, save_path='orbital_elements_plot.png') - ``` - """ - if 'earth' in body.lower(): - orbital_elements = calculate_orbital_elements(r, v, mu_barycenter=EARTH_MU) - else: - orbital_elements = calculate_orbital_elements(r, v, mu_barycenter=MOON_MU) - fig, ax1 = plt.subplots(dpi=100) - fig.patch.set_facecolor('white') - ax1.plot([], [], label='semi-major axis [GEO]', c='C0', linestyle='-') - ax2 = ax1.twinx() - set_color_theme(fig, *[ax1, ax2], theme='white') - - ax1.plot(Time(t).decimalyear, [x for x in orbital_elements['e']], label='eccentricity', c='C1') - ax1.plot(Time(t).decimalyear, [x for x in orbital_elements['i']], label='inclination [rad]', c='C2') - ax1.set_xlabel('Year') - ax1.set_ylim((0, np.pi / 2)) - ylabel = ax1.set_ylabel('', color='black') - x = ylabel.get_position()[0] + 0.05 - y = ylabel.get_position()[1] - fig.text(x - 0.001, y - 0.225, 'Eccentricity', color='C1', rotation=90) - fig.text(x, y - 0.05, '/', color='k', rotation=90) - fig.text(x, y - 0.025, 'Inclination [Radians]', color='C2', rotation=90) - - ax1.legend(loc='upper left') - a = [x / RGEO for x in orbital_elements['a']] - ax2.plot(Time(t).decimalyear, a, label='semi-major axis [GEO]', c='C0', linestyle='-') - ax2.set_ylabel('semi-major axis [GEO]', color='C0') - ax2.yaxis.label.set_color('C0') - ax2.tick_params(axis='y', colors='C0') - ax2.spines['right'].set_color('C0') - - if np.abs(np.max(a) - np.min(a)) < 2: - ax2.set_ylim((np.min(a) - 0.5, np.max(a) + 0.5)) - format_date_axis(t, ax1) - - plt.show(block=False) - if save_path: - save_plot(fig, save_path) - return fig, ax1 - - -def koe_hist_2d(stable_data, title="Initial orbital elements of\n1 year stable cislunar orbits", limits=[1, 50], bins=200, logscale=False, cmap='coolwarm', save_path=False): - """ - Create a 2D histogram plot for various Keplerian orbital elements of stable cislunar orbits. - - Parameters: - - stable_data (object): An object with attributes `a`, `e`, `i`, and `ta`, which are arrays of semi-major axis, eccentricity, inclination, and true anomaly, respectively. - - title (str, optional): Title of the figure. Default is "Initial orbital elements of\n1 year stable cislunar orbits". - - limits (list, optional): Color scale limits for the histogram. Default is [1, 50]. - - bins (int, optional): Number of bins for the 2D histograms. Default is 200. - - logscale (bool or str, optional): Whether to use logarithmic scaling for the color bar. Default is False. Can also be 'log' to apply logarithmic scaling. - - cmap (str, optional): Colormap to use for the histograms. Default is 'coolwarm'. - - save_path (str, optional): Path to save the generated plot. If not provided, the plot will not be saved. Default is False. - - Returns: - - fig (matplotlib.figure.Figure): The figure object containing the 2D histograms. - - This function creates a 3x3 grid of 2D histograms showing the relationships between various orbital elements, including semi-major axis, eccentricity, inclination, and true anomaly. The color scale of the histograms can be adjusted with a logarithmic or linear normalization. The plot is customized with labels and a color bar. - - Example usage: - ``` - import numpy as np - from your_module import koe_hist_2d - - # Example data - class StableData: - def __init__(self): - self.a = np.random.uniform(1, 20, 1000) - self.e = np.random.uniform(0, 1, 1000) - self.i = np.radians(np.random.uniform(0, 90, 1000)) - self.ta = np.radians(np.random.uniform(0, 360, 1000)) - - stable_data = StableData() - koe_hist_2d(stable_data, save_path='orbit_histograms.pdf') - ``` - """ - if logscale or logscale == 'log': - norm = mplcolors.LogNorm(limits[0], limits[1]) - else: - norm = mplcolors.Normalize(limits[0], limits[1]) - fig, axes = plt.subplots(dpi=100, figsize=(10, 8), nrows=3, ncols=3) - fig.patch.set_facecolor('white') - st = fig.suptitle(title, fontsize=12) - st.set_x(0.46) - st.set_y(0.9) - ax = axes.flat[0] - ax.hist2d([x / RGEO for x in stable_data.a], [x for x in stable_data.e], bins=bins, norm=norm, cmap=cmap) - ax.set_xlabel("") - ax.set_ylabel("eccentricity") - ax.set_xticks(np.arange(1, 20, 2)) - ax.set_yticks(np.arange(0, 1, 0.2)) - ax.set_xlim((1, 18)) - axes.flat[1].set_axis_off() - axes.flat[2].set_axis_off() - - ax = axes.flat[3] - ax.hist2d([x / RGEO for x in stable_data.a], [np.degrees(x) for x in stable_data.i], bins=bins, norm=norm, cmap=cmap) - ax.set_xlabel("") - ax.set_ylabel("inclination [deg]") - ax.set_xticks(np.arange(1, 20, 2)) - ax.set_yticks(np.arange(0, 91, 15)) - ax.set_xlim((1, 18)) - ax = axes.flat[4] - ax.hist2d([x for x in stable_data.e], [np.degrees(x) for x in stable_data.i], bins=bins, norm=norm, cmap=cmap) - ax.set_xlabel("") - ax.set_ylabel("") - ax.set_xticks(np.arange(0, 1, 0.2)) - ax.set_yticks(np.arange(0, 91, 15)) - axes.flat[5].set_axis_off() - - ax = axes.flat[6] - ax.hist2d([x / RGEO for x in stable_data.a], [np.degrees(x) for x in stable_data.ta], bins=bins, norm=norm, cmap=cmap) - ax.set_xlabel("semi-major axis [GEO]") - ax.set_ylabel("True Anomaly [deg]") - ax.set_xticks(np.arange(1, 20, 2)) - ax.set_yticks(np.arange(0, 361, 60)) - ax.set_xlim((1, 18)) - ax = axes.flat[7] - ax.hist2d([x for x in stable_data.e], [np.degrees(x) for x in stable_data.ta], bins=bins, norm=norm, cmap=cmap) - ax.set_xlabel("eccentricity") - ax.set_ylabel("") - ax.set_xticks(np.arange(0, 1, 0.2)) - ax.set_yticks(np.arange(0, 361, 60)) - ax = axes.flat[8] - ax.hist2d([np.degrees(x) for x in stable_data.i], [np.degrees(x) for x in stable_data.ta], bins=bins, norm=norm, cmap=cmap) - ax.set_xlabel("inclination [deg]") - ax.set_ylabel("") - ax.set_xticks(np.arange(0, 91, 15)) - ax.set_yticks(np.arange(0, 361, 60)) - - im = fig.subplots_adjust(right=0.8) - cbar_ax = fig.add_axes([0.82, 0.15, 0.01, 0.7]) - fig.colorbar(im, cax=cbar_ax, norm=norm, cmap=cmap) - fig, ax = set_color_theme(fig, ax, theme='white') - if save_path: - save_plot(fig, save_path) - return fig - - - -def scatter_2d(x, y, cs, xlabel='x', ylabel='y', title='', cbar_label='', dotsize=1, colorsMap='jet', colorscale='linear', colormin=False, colormax=False, save_path=False): - """ - Create a 2D scatter plot with optional color mapping. - - Parameters: - - x (numpy.ndarray): Array of x-coordinates. - - y (numpy.ndarray): Array of y-coordinates. - - cs (numpy.ndarray): Array of values for color mapping. - - xlabel (str, optional): Label for the x-axis. Default is 'x'. - - ylabel (str, optional): Label for the y-axis. Default is 'y'. - - title (str, optional): Title of the plot. Default is an empty string. - - cbar_label (str, optional): Label for the color bar. Default is an empty string. - - dotsize (int, optional): Size of the dots in the scatter plot. Default is 1. - - colorsMap (str, optional): Colormap to use for the color mapping. Default is 'jet'. - - colorscale (str, optional): Scale for the color mapping, either 'linear' or 'log'. Default is 'linear'. - - colormin (float, optional): Minimum value for color scaling. If False, it is set to the minimum value of `cs`. Default is False. - - colormax (float, optional): Maximum value for color scaling. If False, it is set to the maximum value of `cs`. Default is False. - - save_path (str, optional): File path to save the plot. If not provided, the plot is not saved. Default is False. - - Returns: - - fig (matplotlib.figure.Figure): The figure object. - - ax (matplotlib.axes._subplots.AxesSubplot): The 2D axis object. - - This function creates a 2D scatter plot with optional color mapping based on the values provided in `cs`. - The color mapping can be adjusted using either a linear or logarithmic scale. The plot can be customized with axis labels, title, and colormap. - The plot can also be saved to a specified file path. - - Example usage: - ``` - import numpy as np - from your_module import scatter_2d - - # Example data - x = np.random.rand(100) - y = np.random.rand(100) - cs = np.random.rand(100) - - scatter_2d(x, y, cs, xlabel='X-axis', ylabel='Y-axis', cbar_label='Color Scale', title='2D Scatter Plot') - ``` - """ - fig = plt.figure() - ax = fig.add_subplot(111) - if colormax is False: - colormax = np.max(cs) - if colormin is False: - colormin = np.min(cs) - cm = plt.get_cmap(colorsMap) - if colorscale == 'linear': - cNorm = mplcolors.Normalize(vmin=colormin, vmax=colormax) - elif colorscale == 'log': - cNorm = mplcolors.LogNorm(vmin=colormin, vmax=colormax) - scalarMap = cm.ScalarMappable(norm=cNorm, cmap=cm) - ax.scatter(x, y, c=scalarMap.to_rgba(cs), s=dotsize) - ax.set_xlabel(xlabel) - ax.set_ylabel(ylabel) - ax.set_title(title) - scalarMap.set_array(cs) - fig.colorbar(scalarMap, shrink=.5, label=f'{cbar_label}', pad=0.04) - plt.tight_layout() - fig, ax = set_color_theme(fig, ax, theme='black') - plt.show(block=False) - if save_path: - save_plot(fig, save_path) - return - - -def scatter_3d(x, y=None, z=None, cs=None, xlabel='x', ylabel='y', zlabel='z', cbar_label='', dotsize=1, colorsMap='jet', title='', save_path=False): - """ - Create a 3D scatter plot with optional color mapping. - - Parameters: - - x (numpy.ndarray): Array of x-coordinates or a 2D array with shape (n, 3) representing the x, y, z coordinates. - - y (numpy.ndarray, optional): Array of y-coordinates. Required if `x` is not a 2D array with shape (n, 3). Default is None. - - z (numpy.ndarray, optional): Array of z-coordinates. Required if `x` is not a 2D array with shape (n, 3). Default is None. - - cs (numpy.ndarray, optional): Array of values for color mapping. Default is None. - - xlabel (str, optional): Label for the x-axis. Default is 'x'. - - ylabel (str, optional): Label for the y-axis. Default is 'y'. - - zlabel (str, optional): Label for the z-axis. Default is 'z'. - - cbar_label (str, optional): Label for the color bar. Default is an empty string. - - dotsize (int, optional): Size of the dots in the scatter plot. Default is 1. - - colorsMap (str, optional): Colormap to use for the color mapping. Default is 'jet'. - - title (str, optional): Title of the plot. Default is an empty string. - - save_path (str, optional): File path to save the plot. If not provided, the plot is not saved. Default is False. - - Returns: - - fig (matplotlib.figure.Figure): The figure object. - - ax (matplotlib.axes._subplots.Axes3DSubplot): The 3D axis object. - - This function creates a 3D scatter plot with optional color mapping based on the values provided in `cs`. - The plot can be customized with axis labels, title, and colormap. The plot can also be saved to a specified file path. - - Example usage: - ``` - import numpy as np - from your_module import scatter_3d - - # Example data - x = np.random.rand(100) - y = np.random.rand(100) - z = np.random.rand(100) - cs = np.random.rand(100) - - scatter_3d(x, y, z, cs, xlabel='X-axis', ylabel='Y-axis', zlabel='Z-axis', cbar_label='Color Scale', title='3D Scatter Plot') - ``` - """ - fig = plt.figure() - ax = fig.add_subplot(111, projection='3d') - if x.ndim > 1: - r = x - x = r[:, 0] - y = r[:, 1] - z = r[:, 2] - if cs is None: - ax.scatter(x, y, z, s=dotsize) - else: - cm = plt.get_cmap(colorsMap) - cNorm = mplcolors.Normalize(vmin=min(cs), vmax=max(cs)) - scalarMap = cm.ScalarMappable(norm=cNorm, cmap=cm) - ax.scatter(x, y, z, c=scalarMap.to_rgba(cs), s=dotsize) - scalarMap.set_array(cs) - fig.colorbar(scalarMap, shrink=.5, label=f'{cbar_label}', pad=0.075) - ax.set_xlabel(xlabel) - ax.set_ylabel(ylabel) - ax.set_zlabel(zlabel) - plt.title(title) - plt.tight_layout() - fig, ax = set_color_theme(fig, ax, theme='black') - plt.show(block=False) - if save_path: - save_plot(fig, save_path) - return fig, ax - - -def scatter_dot_colors_scaled(num_colors): - """ - Generates a scaled array of colors using the rainbow colormap. - - This function creates a list of colors evenly spaced across the rainbow colormap. - The number of colors generated is determined by the `num_colors` parameter. - - Args: - num_colors (int): The number of colors to generate. - - Returns: - numpy.ndarray: An array of RGBA color values, where each entry corresponds to a color in the rainbow colormap. - - Example: - >>> scatter_dot_colors_scaled(5) - array([[1. , 0. , 0. , 1. ], - [0.75 , 0.75 , 0. , 1. ], - [0. , 1. , 0. , 1. ], - [0. , 0.75 , 0.75 , 1. ], - [0. , 0. , 1. , 1. ]]) - """ - return cm.rainbow(np.linspace(0, 1, num_colors)) - - -def orbit_divergence_plot(rs, r_moon=[], t=False, limits=False, title='', save_path=False): - """ - Plot multiple cislunar orbits in the GCRF frame with respect to the Earth and Moon. - - Parameters: - - rs (numpy.ndarray): A 3D array of shape (n, 3, m) where n is the number of time steps, - 3 represents the x, y, z coordinates, and m is the number of orbits. - - r_moon (numpy.ndarray, optional): A 2D array of shape (3, n) representing the Moon's position at each time step. - If not provided, it is calculated based on the time `t`. - - t (astropy.time.Time, optional): The time at which to calculate the Moon's position if `r_moon` is not provided. Default is False. - - limits (float, optional): The plot limits in units of Earth's radius (GEO). If not provided, it is calculated as 1.2 times the maximum norm of `rs`. Default is False. - - title (str, optional): The title of the plot. Default is an empty string. - - save_path (str, optional): The file path to save the plot. If not provided, the plot is not saved. Default is False. - - Returns: - None - - This function creates a 3-panel plot of multiple cislunar orbits in the GCRF frame. Each panel represents a different plane (xy, xz, yz) with Earth at the center. - The orbits are plotted with color gradients to indicate progression. The Moon's position is also plotted if provided or calculated. - - Example usage: - ``` - import numpy as np - from astropy.time import Time - from your_module import orbit_divergence_plot - - # Example data - rs = np.random.randn(100, 3, 5) # 5 orbits with 100 time steps each - t = Time("2025-01-01") - - orbit_divergence_plot(rs, t=t, title='Cislunar Orbits') - ``` - """ - if limits is False: - limits = np.nanmax(np.linalg.norm(rs, axis=1) / RGEO) * 1.2 - print(f'limits: {limits}') - if np.size(r_moon) < 1: - moon = get_body("moon") - r_moon = moon.position(t) - else: - # print('Lunar position(s) provided.') - if r_moon.ndim != 2: - raise IndexError(f"input moon data shape: {np.shape(r_moon)}, input should be 2 dimensions.") - return None - if np.shape(r_moon)[1] == 3: - r_moon = r_moon.T - # print(f"Tranposed input to {np.shape(r_moon)}") - fig = plt.figure(dpi=100, figsize=(15, 4)) - for i in range(rs.shape[-1]): - r = rs[:, :, i] - x = r[:, 0] / RGEO - y = r[:, 1] / RGEO - z = r[:, 2] / RGEO - xm = r_moon[0] / RGEO - ym = r_moon[1] / RGEO - zm = r_moon[2] / RGEO - scatter_dot_colors = cm.rainbow(np.linspace(0, 1, len(x))) - - # Creating plot - plt.subplot(1, 3, 1) - plt.scatter(x, y, color=scatter_dot_colors, s=1) - plt.scatter(0, 0, color="blue", s=50) - plt.scatter(xm, ym, color="grey", s=5) - plt.axis('scaled') - plt.xlabel('x [GEO]') - plt.ylabel('y [GEO]') - plt.xlim((-limits, limits)) - plt.ylim((-limits, limits)) - plt.text(x[0], y[0], r'$\leftarrow$ start') - plt.text(x[-1], y[-1], r'$\leftarrow$ end') - - plt.subplot(1, 3, 2) - plt.scatter(x, z, color=scatter_dot_colors, s=1) - plt.scatter(0, 0, color="blue", s=50) - plt.scatter(xm, zm, color="grey", s=5) - plt.axis('scaled') - plt.xlabel('x [GEO]') - plt.ylabel('z [GEO]') - plt.xlim((-limits, limits)) - plt.ylim((-limits, limits)) - plt.text(x[0], z[0], r'$\leftarrow$ start') - plt.text(x[-1], z[-1], r'$\leftarrow$ end') - plt.title(f'{title}') - - plt.subplot(1, 3, 3) - plt.scatter(y, z, color=scatter_dot_colors, s=1) - plt.scatter(0, 0, color="blue", s=50) - plt.scatter(ym, zm, color="grey", s=5) - plt.axis('scaled') - plt.xlabel('y [GEO]') - plt.ylabel('z [GEO]') - plt.xlim((-limits, limits)) - plt.ylim((-limits, limits)) - plt.text(y[0], z[0], r'$\leftarrow$ start') - plt.text(y[-1], z[-1], r'$\leftarrow$ end') - plt.tight_layout() - plt.show(block=False) - if save_path: - save_plot(fig, save_path) - return - - -def set_color_theme(fig, *axes, theme): - """ - Set the color theme of the figure and axes to white or black and the text color to white or black. - - Parameters: - - fig (matplotlib.figure.Figure): The figure to modify. - - axes (list of matplotlib.axes._subplots.AxesSubplot): One or more axes to modify. - - theme (str) either black/dark or white. - - Returns: - - fig (matplotlib.figure.Figure): The modified figure. - - axes (tuple of matplotlib.axes._subplots.AxesSubplot): The modified axes. - - This function changes the background color of the given figure and its axes to black or white. - It also sets the color of all text items (title, labels, tick labels) to white or black. - - Example usage: - ``` - import matplotlib.pyplot as plt - - fig, ax = plt.subplots() - ax.plot([1, 2, 3], [4, 5, 6]) - set_color_theme(fig, ax, theme='black') - plt.show() - ``` - """ - if theme == 'black' or theme == 'dark': - background = 'black' - secondary = 'white' - else: - background = 'white' - secondary = 'black' - - fig.patch.set_facecolor(background) - - for ax in axes: - ax.set_facecolor(background) - ax_items = [ax.title, ax.xaxis.label, ax.yaxis.label] - if hasattr(ax, 'zaxis'): - ax_items.append(ax.zaxis.label) - ax_items += ax.get_xticklabels() + ax.get_yticklabels() - if hasattr(ax, 'get_zticklabels'): - ax_items += ax.get_zticklabels() - ax_items += ax.get_xticklines() + ax.get_yticklines() - if hasattr(ax, 'get_zticklines'): - ax_items += ax.get_zticklines() - for item in ax_items: - item.set_color(secondary) - - return fig, axes - - -def draw_dashed_circle(ax, normal_vector, radius, dashes, dash_length=0.1, label='Dashed Circle'): - """ - Draw a dashed circle on a 3D axis with a given normal vector. - - Parameters: - - ax (matplotlib.axes._subplots.Axes3DSubplot): The 3D axis on which to draw the circle. - - normal_vector (array-like): A 3-element array representing the normal vector to the plane of the circle. - - radius (float): The radius of the circle. - - dashes (int): The number of dashes to be used in drawing the circle. - - dash_length (float, optional): The relative length of each dash, as a fraction of the circle's circumference. Default is 0.1. - - label (str, optional): The label for the circle. Default is 'Dashed Circle'. - - Returns: - None - - This function draws a dashed circle on a 3D axis. The circle is defined in the xy-plane, then rotated to align with the given normal vector. The circle is divided into dashes to create the dashed effect. - - Example usage: - ``` - import numpy as np - import matplotlib.pyplot as plt - from mpl_toolkits.mplot3d import Axes3D - from your_module import draw_dashed_circle - - fig = plt.figure() - ax = fig.add_subplot(111, projection='3d') - normal_vector = [0, 0, 1] - radius = 5 - dashes = 20 - - draw_dashed_circle(ax, normal_vector, radius, dashes) - - plt.show() - ``` - """ - from .utils import rotation_matrix_from_vectors - # Define the circle in the xy-plane - theta = np.linspace(0, 2 * np.pi, 1000) - x_circle = radius * np.cos(theta) - y_circle = radius * np.sin(theta) - z_circle = np.zeros_like(theta) - - # Stack the coordinates into a matrix - circle_points = np.vstack((x_circle, y_circle, z_circle)).T - - # Create the rotation matrix to align z-axis with the normal vector - normal_vector = normal_vector / np.linalg.norm(normal_vector) - rotation_matrix = rotation_matrix_from_vectors(np.array([0, 0, 1]), normal_vector) - - # Rotate the circle points - rotated_points = circle_points @ rotation_matrix.T - - # Create dashed effect - dash_points = [] - dash_gap = int(len(theta) / dashes) - for i in range(dashes): - start_idx = i * dash_gap - end_idx = start_idx + int(dash_length * len(theta)) - dash_points.append(rotated_points[start_idx:end_idx]) - - # Plot the dashed circle in 3D - for points in dash_points: - ax.plot(points[:, 0], points[:, 1], points[:, 2], 'k--', label=label) - label = None # Only one label - - -# ##################################################################### -# Formatting x axis -# ##################################################################### -def format_date_axis(time_array, ax): - """ - Format the x-axis of a plot with time-based labels depending on the span of the time array. - - Parameters: - - time_array (array-like): An array of time objects (e.g., astropy.time.Time) to be used for the x-axis labels. - - ax (matplotlib.axes.Axes): The matplotlib axes object on which to set the x-axis labels. - - Returns: - None - - This function formats the x-axis labels of a plot based on the span of the provided time array. The labels are - set to show either hours and day-month or month-year formats, depending on the time span. - - The function performs the following steps: - 1. If the time span is less than one month: - - If the time span is less than a day, the labels show 'HH:MM dd-Mon'. - - Otherwise, the labels show 'dd-Mon-YYYY'. - 2. If the time span is more than one month, the labels show 'Mon-YYYY'. - - The function selects six nearly evenly spaced points in the time array to set the x-axis labels. - - Example usage: - ``` - import matplotlib.pyplot as plt - from astropy.time import Time - import numpy as np - - # Example time array - time_array = Time(['2024-07-01T00:00:00', '2024-07-01T06:00:00', '2024-07-01T12:00:00', - '2024-07-01T18:00:00', '2024-07-02T00:00:00']) - - fig, ax = plt.subplots() - ax.plot(time_array.decimalyear, np.random.rand(len(time_array))) - format_date_axis(time_array, ax) - plt.show() - ``` - """ - n = 6 # Number of nearly evenly spaced points to select - time_span_in_months = (time_array[-1].datetime - time_array[0].datetime).days / 30 - if time_span_in_months < 1: - # Get the time span in hours - time_span_in_hours = (time_array[-1].datetime - time_array[0].datetime).total_seconds() / 3600 - - if time_span_in_hours < 24: - # If the time span is less than a day, format the x-axis with hh:mm dd-mon - selected_times = np.linspace(time_array[0], time_array[-1], n) - selected_hour_strings = [t.strftime('%H:%M') for t in selected_times] - selected_day_month_strings = [t.strftime('%d-%b') for t in selected_times] - selected_tick_labels = [f'{hour} {day_month}' for hour, day_month in zip(selected_hour_strings, selected_day_month_strings)] - selected_decimal_years = [t.decimalyear for t in selected_times] - # Set the x-axis tick positions and labels - ax.set_xticks(selected_decimal_years) - ax.set_xticklabels(selected_tick_labels) - return - if n >= time_span_in_months: - # Get evenly spaced points in the time_array - selected_indices = np.round(np.linspace(0, len(time_array) - 1, n)).astype(int) - selected_times = time_array[selected_indices] - selected_month_year_strings = [t.strftime('%d-%b-%Y') for t in selected_times] - else: - # Get the first of n nearly evenly spaced months in the time - step = int(len(time_array) / (n - 1)) - 1 - selected_times = time_array[::step] - selected_month_year_strings = [t.strftime('%b-%Y') for t in selected_times] - selected_decimal_years = [t.decimalyear for t in selected_times] - # Set the x-axis tick positions and labels - ax.set_xticks(selected_decimal_years) - ax.set_xticklabels(selected_month_year_strings) - - # Optional: Rotate the tick labels for better visibility - plt.xticks(rotation=0) - return - - -save_plot_to_pdf_call_count = 0 - - -def save_plot_to_pdf(figure, pdf_path): - """ - Save a Matplotlib figure to a PDF file, with support for merging with existing PDFs. - - Parameters: - - figure (matplotlib.figure.Figure): The Matplotlib figure to be saved. - - pdf_path (str): The path to the PDF file. If the file exists, the figure will be appended to it. - - Returns: - None - - This function saves a Matplotlib figure as a PNG in-memory and then converts it to a PDF. - If the specified PDF file already exists, the new figure is appended to it. Otherwise, - a new PDF file is created. The function also keeps track of how many times it has been called - using a global variable `save_plot_to_pdf_call_count`. - - The function performs the following steps: - 1. Expands the user directory if the path starts with `~`. - 2. Generates a temporary PDF path by appending "_temp.pdf" to the original path. - 3. Saves the figure as a PNG in-memory using a BytesIO buffer. - 4. Opens the in-memory PNG using PIL and creates a new figure to display the image. - 5. Saves the new figure with the image into a temporary PDF. - 6. If the specified PDF file exists, merges the temporary PDF with the existing one. - Otherwise, renames the temporary PDF to the specified path. - 7. Closes the original and temporary figures and prints a message indicating the save location. - - Example usage: - ``` - import matplotlib.pyplot as plt - - fig, ax = plt.subplots() - ax.plot([1, 2, 3], [4, 5, 6]) - save_plot_to_pdf(fig, '~/Desktop/my_plot.pdf') - ``` - """ - global save_plot_to_pdf_call_count - save_plot_to_pdf_call_count += 1 - if '~' == pdf_path[0]: - pdf_path = os.path.expanduser(pdf_path) - if '.' in pdf_path: - temp_pdf_path = re.sub(r"\.[^.]+$", "_temp.pdf", pdf_path) - else: - temp_pdf_path = f"{pdf_path}_temp.pdf" - # Save the figure as a PNG in-memory using BytesIO - png_buffer = io.BytesIO() - figure.savefig(png_buffer, format='png', dpi=300, bbox_inches='tight') - # Rewind the buffer to the beginning - png_buffer.seek(0) - # Open the in-memory PNG using PIL - png_image = PILImage.open(png_buffer) - with PdfPages(temp_pdf_path) as pdf: - # Create a new figure and axis to display the image - img_fig, img_ax = plt.subplots() - img_ax.imshow(png_image) - img_ax.axis('off') - # Save the figure with the image into the PDF - pdf.savefig(img_fig, dpi=300, bbox_inches='tight') - if os.path.exists(pdf_path): - merger = PdfMerger() - with open(pdf_path, "rb") as main_pdf, open(temp_pdf_path, "rb") as temp_pdf: - merger.append(main_pdf) - merger.append(temp_pdf) - with open(pdf_path, "wb") as merged_pdf: - merger.write(merged_pdf) - os.remove(temp_pdf_path) - else: - os.rename(temp_pdf_path, pdf_path) - plt.close(figure) - plt.close(img_fig) # Close the figure and new figure created - print(f"Saved figure {save_plot_to_pdf_call_count} to {pdf_path}") - return - - -def save_plot(figure, save_path, dpi=200): - """ - Save a Python figure as a PNG/JPG/PDF/ect. image. If no extension is given in the save_path, a .png is defaulted. - - Parameters: - figure (matplotlib.figure.Figure): The figure object to be saved. - save_path (str): The file path where the image will be saved. - - Returns: - None - """ - if save_path.lower().endswith('.pdf'): - save_plot_to_pdf(figure, save_path) - return - try: - base_name, extension = os.path.splitext(save_path) - if extension.lower() == '': - save_path = base_name + '.png' - # Save the figure as a PNG image - figure.savefig(save_path, dpi=dpi, bbox_inches='tight') - plt.close(figure) # Close the figure to release resources - # print(f"Figure saved at: {save_path}") - except Exception as e: - print(f"Error occurred while saving the figure: {e}") - - -def save_animated_gif(gif_name, frames, fps=30): - """ - Create a GIF from a sequence of image frames. - - Parameters: - - gif_name (str): The name of the output GIF file, including the .gif extension. - - frames (list of str): A list of file paths to the image frames to be included in the GIF. - - fps (int, optional): Frames per second for the GIF. Default is 30. - - Returns: - None - - This function uses the imageio library to write a GIF file. It prints messages indicating - the start and completion of the GIF writing process. Each frame is read from the provided - file paths and appended to the GIF. - - Example usage: - frames = ['frame1.png', 'frame2.png', 'frame3.png'] - write_gif('output.gif', frames, fps=24) - """ - import imageio - print(f'Writing gif: {gif_name}') - with imageio.get_writer(gif_name, mode='I', duration=1 / fps) as writer: - for i, filename in enumerate(frames): - image = imageio.imread(filename) - writer.append_data(image) - print(f'Wrote {gif_name}') - return + ) \ No newline at end of file diff --git a/ssapy/simple.py b/ssapy/simple.py deleted file mode 100644 index b3ffab54..00000000 --- a/ssapy/simple.py +++ /dev/null @@ -1,286 +0,0 @@ -# flake8: noqa: E501 - -""" -Functions to simplify certain aspects of SSAPy. -For when you want a quick answer and do not need want to use high fidelity defaults. -""" - -from .utils import get_times, points_on_circle -from . import Orbit, rv -from .accel import AccelKepler, AccelSolRad, AccelEarthRad, AccelDrag -from .body import get_body -from .gravity import AccelHarmonic, AccelThirdBody -from .propagator import RK78Propagator - -from astropy.time import Time -import numpy as np -from typing import Union, List, Tuple - - -def keplerian_prop(integration_timestep: float = 10) -> RK78Propagator: - """ - Create and return an RK78Propagator for a Keplerian orbit. - - This propagator uses only the Keplerian acceleration for a two-body problem. - - Parameters: - ---------- - integration_timestep : float, optional - The time step for the RK78Propagator integration (default is 10 seconds). - - Returns: - ------- - RK78Propagator - An instance of RK78Propagator configured with Keplerian acceleration. - """ - return RK78Propagator(AccelKepler(), h=integration_timestep) - - -accel_3_cache = None -def threebody_prop(integration_timestep: float = 10) -> RK78Propagator: - """ - Create and return an RK78Propagator with a set of accelerations for a three-body problem. - - The three bodies considered are Earth (Keplerian effect), Moon, and the Earth itself. - - Parameters: - ---------- - integration_timestep : float, optional - The time step for the RK78Propagator integration (default is 10 seconds). - - Returns: - ------- - RK78Propagator - An instance of RK78Propagator configured with the three-body accelerations. - """ - global accel_3_cache - if accel_3_cache is None: - accel_3_cache = AccelKepler() + AccelThirdBody(get_body("moon")) - return RK78Propagator(accel_3_cache, h=integration_timestep) - - -accel_4_cache = None -def fourbody_prop(integration_timestep: float = 10) -> RK78Propagator: - """ - Create and return an RK78Propagator with a set of accelerations for a four-body problem. - - The four bodies considered are Earth (Keplerian effect), Moon, Sun, and the Earth itself. - - Parameters: - ---------- - integration_timestep : float, optional - The time step for the RK78Propagator integration (default is 10 seconds). - - Returns: - ------- - RK78Propagator - An instance of RK78Propagator configured with the four-body accelerations. - """ - global accel_4_cache - if accel_4_cache is None: - accel_4_cache = AccelKepler() + AccelThirdBody(get_body("moon")) + AccelThirdBody(get_body("Sun")) - return RK78Propagator(accel_4_cache, h=integration_timestep) - - -accel_best_cache = None -def best_prop(integration_timestep=10, kwargs=dict(mass=250, area=.022, CD=2.3, CR=1.3)): - """ - Create and return an RK78Propagator with a comprehensive set of accelerations. - - Parameters: - ---------- - integration_timestep : float, optional - The time step for the RK78Propagator integration (default is 10 seconds). - kwargs : dict, optional - Dictionary of parameters for non-conservative forces (mass, area, CD, CR). - If not provided, defaults are used. - - Returns: - ------- - RK78Propagator - An instance of RK78Propagator configured with cached accelerations. - """ - global accel_best_cache - if accel_best_cache is None: - aEarth = AccelKepler() + AccelHarmonic(get_body("Earth", model="EGM2008"), 140, 140) - aMoon = AccelThirdBody(get_body("moon")) + AccelHarmonic(get_body("moon"), 20, 20) - aSun = AccelThirdBody(get_body("Sun")) - aMercury = AccelThirdBody(get_body("Mercury")) - aVenus = AccelThirdBody(get_body("Venus")) - aMars = AccelThirdBody(get_body("Mars")) - aJupiter = AccelThirdBody(get_body("Jupiter")) - aSaturn = AccelThirdBody(get_body("Saturn")) - aUranus = AccelThirdBody(get_body("Uranus")) - aNeptune = AccelThirdBody(get_body("Neptune")) - nonConservative = AccelSolRad(**kwargs) + AccelEarthRad(**kwargs) + AccelDrag(**kwargs) - planets = aMercury + aVenus + aMars + aJupiter + aSaturn + aUranus + aNeptune - accel_best_cache = aEarth + aMoon + aSun + planets + nonConservative - return RK78Propagator(accel_best_cache, h=integration_timestep) - - -def ssapy_kwargs(mass=250, area=0.022, CD=2.3, CR=1.3): - """ - Generate a dictionary of default parameters for a space object used in simulations. - - Parameters: - ---------- - mass : float, optional - Mass of the object in kilograms (default is 250 kg). - area : float, optional - Cross-sectional area of the object in square meters (default is 0.022 m^2). - CD : float, optional - Drag coefficient of the object (default is 2.3). - CR : float, optional - Radiation pressure coefficient of the object (default is 1.3). - - Returns: - ------- - dict - A dictionary containing the parameters for the space object. - """ - # Asteroid parameters - kwargs = dict( - mass=mass, # [kg] - area=area, # [m^2] - CD=CD, # Drag coefficient - CR=CR, # Radiation pressure coefficient - ) - return kwargs - - -def ssapy_prop(integration_timestep=60, propkw=ssapy_kwargs()): - """ - Setup and return an RK78 propagator with specified accelerations and radiation pressure effects. - - Parameters: - ---------- - integration_timestep : int - Time step for the numerical integration (in seconds). - propkw : dict, optional - Keyword arguments for radiation pressure accelerations. If None, default arguments are used. - - Returns: - ------- - RK78Propagator - An RK78 propagator configured with the specified accelerations and time step. - """ - # Accelerations - pass a body object or string of body name. - moon = get_body("moon") - sun = get_body("Sun") - Mercury = get_body("Mercury") - Venus = get_body("Venus") - Earth = get_body("Earth", model="EGM2008") - Mars = get_body("Mars") - Jupiter = get_body("Jupiter") - Saturn = get_body("Saturn") - Uranus = get_body("Uranus") - Neptune = get_body("Neptune") - aEarth = AccelKepler() + AccelHarmonic(Earth, 140, 140) - aSun = AccelThirdBody(sun) - aMoon = AccelThirdBody(moon) + AccelHarmonic(moon, 20, 20) - aSolRad = AccelSolRad(**propkw) - aEarthRad = AccelEarthRad(**propkw) - accel = aEarth + aMoon + aSun + aSolRad + aEarthRad - # Build propagator - prop = RK78Propagator(accel, h=integration_timestep) - return prop - - -# Uses the current best propagator and acceleration models in ssapy -def ssapy_orbit(orbit=None, a=None, e=0, i=0, pa=0, raan=0, ta=0, r=None, v=None, duration=(30, 'day'), freq=(1, 'hr'), t0=Time("2025-01-01", scale='utc'), t=None, prop=ssapy_prop()): - """ - Compute the orbit of a spacecraft given either Keplerian elements or position and velocity vectors. - - Parameters: - - orbit (Orbit, optional): An Orbit object if you already have an orbit defined. - - a (float, optional): Semi-major axis of the orbit in meters. - - e (float, optional): Eccentricity of the orbit (default is 0, i.e., circular orbit). - - i (float, optional): Inclination of the orbit in degrees. - - pa (float, optional): Argument of perigee in degrees. - - raan (float, optional): Right ascension of the ascending node in degrees. - - ta (float, optional): True anomaly in degrees. - - r (array-like, optional): Position vector in meters. - - v (array-like, optional): Velocity vector in meters per second. - - duration (tuple, optional): Duration of the simulation as a tuple (value, unit), where unit is 'day', 'hour', etc. Default is 30 days. - - freq (tuple, optional): Frequency of the output as a tuple (value, unit), where unit is 'day', 'hour', etc. Default is 1 hour. - - t0 (str, optional): Start date of the simulation in 'YYYY-MM-DD' format. Default is "2025-01-01". - - t (array-like, optional): Specific times at which to compute the orbit. If None, times will be generated based on duration and frequency. - - prop (function, optional): A function to compute the perturbation effects. Default is `ssapy_prop()`. - - Returns: - - r (array-like): Position vectors of the spacecraft at the specified times. - - v (array-like): Velocity vectors of the spacecraft at the specified times. - - t (array-like): Times at which the orbit was computed. Returned only if `t` was None. - - Raises: - - ValueError: If neither Keplerian elements nor position and velocity vectors are provided. - - RuntimeError or ValueError: If an error occurs during computation. - """ - t0 = Time(t0, scale='utc') - if t is None: - time_is_None = True - t = get_times(duration=duration, freq=freq, t0=t0) - else: - t0 = t[0] - time_is_None = False - - if orbit is not None: - pass - elif a is not None: - kElements = [a, e, i, pa, raan, ta] - orbit = Orbit.fromKeplerianElements(*kElements, t0) - elif r is not None and v is not None: - orbit = Orbit(r, v, t0) - else: - raise ValueError("Either Keplerian elements (a, e, i, pa, raan, ta) or position and velocity vectors (r, v) must be provided.") - - try: - r, v = rv(orbit, t, prop) - if time_is_None: - return r, v, t - else: - return r, v - except (RuntimeError, ValueError) as err: - print(err) - return np.nan, np.nan, np.nan - - -def get_similar_orbits(r0, v0, rad=1e5, num_orbits=4, duration=(90, 'days'), freq=(1, 'hour'), start_date="2025-1-1", mass=250): - """ - Generate similar orbits by varying the initial position. - - Parameters: - ---------- - r0 : array_like - Initial position vector of shape (3,). - v0 : array_like - Initial velocity vector of shape (3,). - rad : float - Radius of the circle around the initial position to generate similar orbits. - num_orbits : int - Number of similar orbits to generate. - duration : tuple - Duration of the orbit simulation. - freq : tuple - Frequency of output data. - start_date : str - Start date for the simulation. - mass : float - Mass of the satellite. - - Returns: - ------- - trajectories : ndarray - Stacked array of shape (3, n_times, num_orbits) containing the trajectories. - """ - r0 = np.reshape(r0, (1, 3)) - v0 = np.reshape(v0, (1, 3)) - print(r0, v0) - for idx, point in enumerate(points_on_circle(r0, v0, rad=rad, num_points=num_orbits)): - # Calculate entire satellite trajectory - r, v = ssapy_orbit(r=point, v=v0, duration=duration, freq=freq, start_date=start_date, integration_timestep=10, mass=mass, area=mass / 19000 + 0.01, CD=2.3, CR=1.3) - if idx == 0: - trajectories = np.concatenate((r0, v0), axis=1)[:len(r)] - rv = np.concatenate((r, v), axis=1) - trajectories = np.dstack((trajectories, rv)) - return trajectories diff --git a/ssapy/utils.py b/ssapy/utils.py index a5d2d9e9..bba950c2 100644 --- a/ssapy/utils.py +++ b/ssapy/utils.py @@ -6,7 +6,7 @@ import numpy as np from astropy.time import Time import astropy.units as u -from typing import Union, List, Tuple +from typing import Union, Tuple from . import datadir from .constants import RGEO, EARTH_RADIUS, MOON_RADIUS, WGS84_EARTH_OMEGA @@ -1373,235 +1373,6 @@ def get_angle(a, b, c): return np.arccos(cosine_angle) -def angle_between_vectors(vector1, vector2): - """ - Calculates the angle (in radians) between two vectors. - - Parameters: - ----------- - vector1 (ndarray): First vector. - vector2 (ndarray): Second vector. - - Returns: - -------- - float: Angle between the vectors in radians. - """ - return np.arccos(np.clip(np.dot(vector1, vector2) / (np.linalg.norm(vector1) * np.linalg.norm(vector2)), -1.0, 1.0)) - - -def rotation_matrix_from_vectors(vec1, vec2): - """ Find the rotation matrix that aligns vec1 to vec2 - :param vec1: A 3d "source" vector - :param vec2: A 3d "destination" vector - :return mat: A transform matrix (3x3) which when applied to vec1, aligns it with vec2. - """ - a, b = (vec1 / np.linalg.norm(vec1)).reshape(3), (vec2 / np.linalg.norm(vec2)).reshape(3) - v = np.cross(a, b) - c = np.dot(a, b) - s = np.linalg.norm(v) - kmat = np.array([[0, -v[2], v[1]], [v[2], 0, -v[0]], [-v[1], v[0], 0]]) - rotation_matrix = np.eye(3) + kmat + kmat.dot(kmat) * ((1 - c) / (s**2)) - return rotation_matrix - - -def rotate_vector(v_unit, theta, phi, plot_path=False, save_idx=False): - """ - Rotates a unit vector by specified angles and optionally plots the rotation path. - - Parameters: - ----------- - v_unit (ndarray): Input unit vector to be rotated. - theta (float): Rotation angle (in degrees) around a perpendicular axis. - phi (float): Rotation angle (in degrees) around the input vector. - plot_path (str, optional): Path to save the rotation plot. Defaults to False (no plot). - save_idx (int, optional): Index for saving the plot file. Defaults to False. - - Returns: - -------- - ndarray: Rotated unit vector. - """ - v_unit = v_unit / np.linalg.norm(v_unit, axis=-1) - if np.all(np.abs(v_unit) != np.max(np.abs(v_unit))): - perp_vector = np.cross(v_unit, np.array([1, 0, 0])) - else: - perp_vector = np.cross(v_unit, np.array([0, 1, 0])) - perp_vector /= np.linalg.norm(perp_vector) - - theta = np.radians(theta) - phi = np.radians(phi) - cos_theta = np.cos(theta) - sin_theta = np.sin(theta) - cos_phi = np.cos(phi) - sin_phi = np.sin(phi) - - R1 = np.array([ - [cos_theta + (1 - cos_theta) * perp_vector[0]**2, - (1 - cos_theta) * perp_vector[0] * perp_vector[1] - sin_theta * perp_vector[2], - (1 - cos_theta) * perp_vector[0] * perp_vector[2] + sin_theta * perp_vector[1]], - [(1 - cos_theta) * perp_vector[1] * perp_vector[0] + sin_theta * perp_vector[2], - cos_theta + (1 - cos_theta) * perp_vector[1]**2, - (1 - cos_theta) * perp_vector[1] * perp_vector[2] - sin_theta * perp_vector[0]], - [(1 - cos_theta) * perp_vector[2] * perp_vector[0] - sin_theta * perp_vector[1], - (1 - cos_theta) * perp_vector[2] * perp_vector[1] + sin_theta * perp_vector[0], - cos_theta + (1 - cos_theta) * perp_vector[2]**2] - ]) - - # Apply the rotation matrix to v_unit to get the rotated unit vector - v1 = np.dot(R1, v_unit) - - # Rotation matrix for rotation about v_unit - R2 = np.array([[cos_phi + (1 - cos_phi) * v_unit[0]**2, - (1 - cos_phi) * v_unit[0] * v_unit[1] - sin_phi * v_unit[2], - (1 - cos_phi) * v_unit[0] * v_unit[2] + sin_phi * v_unit[1]], - [(1 - cos_phi) * v_unit[1] * v_unit[0] + sin_phi * v_unit[2], - cos_phi + (1 - cos_phi) * v_unit[1]**2, - (1 - cos_phi) * v_unit[1] * v_unit[2] - sin_phi * v_unit[0]], - [(1 - cos_phi) * v_unit[2] * v_unit[0] - sin_phi * v_unit[1], - (1 - cos_phi) * v_unit[2] * v_unit[1] + sin_phi * v_unit[0], - cos_phi + (1 - cos_phi) * v_unit[2]**2]]) - - v2 = np.dot(R2, v1) - - if plot_path is not False: - import matplotlib.pyplot as plt - plt.rcParams.update({'font.size': 9, 'figure.facecolor': 'black'}) - fig = plt.figure() - ax = fig.add_subplot(111, projection='3d') - ax.quiver(0, 0, 0, v_unit[0], v_unit[1], v_unit[2], color='b') - ax.quiver(0, 0, 0, v1[0], v1[1], v1[2], color='g') - ax.quiver(0, 0, 0, v2[0], v2[1], v2[2], color='r') - ax.set_xlabel('X', color='white') - ax.set_ylabel('Y', color='white') - ax.set_zlabel('Z', color='white') - ax.set_facecolor('black') # Set plot background color to black - ax.tick_params(axis='x', colors='white') # Set x-axis tick color to white - ax.tick_params(axis='y', colors='white') # Set y-axis tick color to white - ax.tick_params(axis='z', colors='white') # Set z-axis tick color to white - ax.set_title('Vector Plot', color='white') - ax.set_xlim(-1, 1) - ax.set_ylim(-1, 1) - ax.set_zlim(-1, 1) - plt.grid(True) - if save_idx is not False: - from .plotUtils import save_plot - ax.set_title(f'Vector Plot\ntheta: {np.degrees(theta):.0f}, phi: {np.degrees(phi):.0f}', color='white') - save_plot(fig, f"{plot_path}{save_idx}.png") - return v2 / np.linalg.norm(v2, axis=-1) - - -def rotate_points_3d(points, axis=np.array([0, 0, 1]), theta=-np.pi / 2): - """ - Rotate a set of 3D points about a 3D axis by an angle theta in radians. - - Args: - points (np.ndarray): The set of 3D points to rotate, as an Nx3 array. - axis (np.ndarray): The 3D axis to rotate about, as a length-3 array. Default is the z-axis. - theta (float): The angle to rotate by, in radians. Default is pi/2. - - Returns: - np.ndarray: The rotated set of 3D points, as an Nx3 array. - """ - # Normalize the axis to be a unit vector - axis = axis / np.linalg.norm(axis) - - # Compute the quaternion representing the rotation - qw = np.cos(theta / 2) - qx, qy, qz = axis * np.sin(theta / 2) - - # Construct the rotation matrix from the quaternion - R = np.array([ - [1 - 2 * qy**2 - 2 * qz**2, 2 * qx * qy - 2 * qz * qw, 2 * qx * qz + 2 * qy * qw], - [2 * qx * qy + 2 * qz * qw, 1 - 2 * qx**2 - 2 * qz**2, 2 * qy * qz - 2 * qx * qw], - [2 * qx * qz - 2 * qy * qw, 2 * qy * qz + 2 * qx * qw, 1 - 2 * qx**2 - 2 * qy**2] - ]) - - # Apply the rotation matrix to the set of points - rotated_points = np.dot(R, points.T).T - - return rotated_points - - -def perpendicular_vectors(v): - """Returns two vectors that are perpendicular to v and each other.""" - # Check if v is the zero vector - if np.allclose(v, np.zeros_like(v)): - raise ValueError("Input vector cannot be the zero vector.") - - # Choose an arbitrary non-zero vector w that is not parallel to v - w = np.array([1., 0., 0.]) - if np.allclose(v, w) or np.allclose(v, -w): - w = np.array([0., 1., 0.]) - u = np.cross(v, w) - if np.allclose(u, np.zeros_like(u)): - w = np.array([0., 0., 1.]) - u = np.cross(v, w) - w = np.cross(v, u) - - return u, w - - -def points_on_circle(r, v, rad, num_points=4): - """ - Generate points on a circle in 3D space. - - The circle is defined by its center `r`, radius `rad`, and a normal vector `v`. - The function computes `num_points` evenly spaced points on the circle. - - Parameters: - ----------- - r (numpy.ndarray): A 3D vector representing the center of the circle. - v (numpy.ndarray): A 3D vector representing the normal to the circle's plane. - rad (float): The radius of the circle. - num_points (int, optional): The number of points to generate on the circle. - Defaults to 4. - - Returns: - -------- - numpy.ndarray: An array of shape (num_points, 3), where each row represents - the coordinates of a point on the circle. - - Raises: - ------- - ValueError: If the normal vector `v` is the zero vector. - """ - # Convert inputs to numpy arrays - r = np.array(r) - v = np.array(v) - - # Find the perpendicular vectors to the given vector v - if np.all(v[:2] == 0): - if np.all(v[2] == 0): - raise ValueError("The given vector v must not be the zero vector.") - else: - u = np.array([1, 0, 0]) - else: - u = np.array([-v[1], v[0], 0]) - u = u / np.linalg.norm(u) - w = np.cross(u, v) - w_norm = np.linalg.norm(w) - if w_norm < 1e-15: - # v is parallel to z-axis - w = np.array([0, 1, 0]) - else: - w = w / w_norm - # Generate a sequence of angles for equally spaced points - angles = np.linspace(0, 2 * np.pi, num_points, endpoint=False) - - # Compute the x, y, z coordinates of each point on the circle - x = rad * np.cos(angles) * u[0] + rad * np.sin(angles) * w[0] - y = rad * np.cos(angles) * u[1] + rad * np.sin(angles) * w[1] - z = rad * np.cos(angles) * u[2] + rad * np.sin(angles) * w[2] - - # Apply rotation about z-axis by 90 degrees - rot_matrix = np.array([[0, 1, 0], [-1, 0, 0], [0, 0, 1]]) - rotated_points = np.dot(rot_matrix, np.column_stack((x, y, z)).T).T - - # Translate the rotated points to the center point r - points_rotated = rotated_points + r.reshape(1, 3) - - return points_rotated - - def dms_to_rad(coords): """ Convert coordinates from degrees, minutes, and seconds (DMS) format to radians. @@ -2571,400 +2342,6 @@ def ecliptic_to_equatorial(lon, lat, degrees=False): return ra, dec -def proper_motion_ra_dec(r=None, v=None, x=None, y=None, z=None, vx=None, vy=None, vz=None, r_earth=np.array([0, 0, 0]), v_earth=np.array([0, 0, 0]), input_unit='si'): - """ - Calculate the proper motion in right ascension (RA) and declination (DEC) for celestial objects. - - This function computes the proper motion in RA and DEC based on the position and velocity of the object - relative to Earth. Proper motion is expressed in arcseconds per second. - - Parameters: - ----------- - r (numpy array, optional): Position vector of the object [x, y, z] (in meters or AU, depending on `input_unit`). - v (numpy array, optional): Velocity vector of the object [vx, vy, vz] (in meters/second or AU/s, depending on `input_unit`). - x, y, z (float, optional): Individual position coordinates of the object (used if `r` is not provided). - vx, vy, vz (float, optional): Individual velocity components of the object (used if `v` is not provided). - r_earth (numpy array, optional): Position vector of Earth [x, y, z] (default is [0, 0, 0]). - v_earth (numpy array, optional): Velocity vector of Earth [vx, vy, vz] (default is [0, 0, 0]). - input_unit (str, optional): Unit system for input data ('si' for SI units, 'rebound' for REBOUND simulation units). - Default is 'si'. - - Returns: - -------- - tuple: Proper motion in RA and DEC: - - pmra (numpy array): Proper motion in RA (arcseconds per second). - - pmdec (numpy array): Proper motion in DEC (arcseconds per second). - - Notes: - ------ - - If `r` and `v` are not provided, the function expects individual coordinates (`x`, `y`, `z`) and velocities (`vx`, `vy`, `vz`). - - Earth's position and velocity are subtracted from the input position and velocity vectors to calculate relative motion. - - The `einsum_norm` function calculates the magnitude of the position vector. - - Proper motion is scaled by a factor of 206265 to convert radians to arcseconds. - - For REBOUND simulation units, proper motion is adjusted to account for time scaling. - """ - - if r is None or v is None: - if x is not None and y is not None and z is not None and vx is not None and vy is not None and vz is not None: - r = np.array([x, y, z]) - v = np.array([vx, vy, vz]) - else: - raise ValueError("Either provide r and v arrays or individual coordinates (x, y, z) and velocities (vx, vy, vz)") - - # Subtract Earth's position and velocity from the input arrays - r = r - r_earth - v = v - v_earth - - # Distances to Earth and Sun - d_earth_mag = einsum_norm(r, 'ij,ij->i') - - # RA / DEC calculation - ra = rad0to2pi(np.arctan2(r[:, 1], r[:, 0])) # in radians - dec = np.arcsin(r[:, 2] / d_earth_mag) - ra_unit_vector = np.array([-np.sin(ra), np.cos(ra), np.zeros(np.shape(ra))]).T - dec_unit_vector = -np.array([np.cos(np.pi / 2 - dec) * np.cos(ra), np.cos(np.pi / 2 - dec) * np.sin(ra), -np.sin(np.pi / 2 - dec)]).T - pmra = (np.einsum('ij,ij->i', v, ra_unit_vector)) / d_earth_mag * 206265 # arcseconds / second - pmdec = (np.einsum('ij,ij->i', v, dec_unit_vector)) / d_earth_mag * 206265 # arcseconds / second - - if input_unit == 'si': - return pmra, pmdec - elif input_unit == 'rebound': - pmra = pmra / (31557600 * 2 * np.pi) - pmdec = pmdec / (31557600 * 2 * np.pi) # arcseconds * (au/sim_time)/au, convert to arcseconds / second - return pmra, pmdec - else: - print('Error - units provided not available, provide either SI or rebound units.') - return - - - -def gcrf_to_lunar(r, t, v=None): - """ - Transform position and velocity vectors from the GCRF (Geocentric Celestial Reference Frame) to a lunar-centric frame. - - This function converts coordinates from the Earth-centered GCRF to a coordinate system centered on the Moon. - It uses the Moon's position and velocity to define the transformation. - - Parameters: - ----------- - r (numpy array): Position vector(s) in the GCRF [x, y, z]. - t (numpy array): Time(s) at which the position vector(s) are defined. - v (numpy array, optional): Velocity vector(s) in the GCRF [vx, vy, vz]. If not provided, only position is transformed. - - Returns: - -------- - numpy array or tuple: - - If `v` is not provided: Transformed position vector(s) in the lunar-centric frame. - - If `v` is provided: A tuple containing: - - r_lunar (numpy array): Transformed position vector(s) in the lunar-centric frame. - - v_lunar (numpy array): Transformed velocity vector(s) in the lunar-centric frame. - - Notes: - ------ - - The `MoonPosition` class is used to calculate the Moon's position at a given time. - - The Moon's velocity is approximated using finite differences over a ±5-second interval. - - The lunar-centric frame is defined with the following axes: - - x-axis: Points from the Moon toward the Earth (direction of the Moon's position vector). - - y-axis: Perpendicular to the Moon's velocity vector, in the plane of motion. - - z-axis: Perpendicular to both the x-axis and y-axis (right-hand rule). - - The transformation matrix `R` is constructed using these axes and applied to the input position vector(s). - """ - from .body import MoonPosition - class MoonRotator: - def __init__(self): - self.mpm = MoonPosition() - - def __call__(self, r, t): - rmoon = self.mpm(t) - vmoon = (self.mpm(t + 5.0) - self.mpm(t - 5.0)) / 10. - xhat = normed(rmoon.T).T - vpar = np.einsum("ab,ab->b", xhat, vmoon) * xhat - vperp = vmoon - vpar - yhat = normed(vperp.T).T - zhat = np.cross(xhat, yhat, axisa=0, axisb=0).T - R = np.empty((3, 3, len(t))) - R[0] = xhat - R[1] = yhat - R[2] = zhat - return np.einsum("abc,cb->ca", R, r) - rotator = MoonRotator() - if v is None: - return rotator(r, t) - else: - r_lunar = rotator(r, t) - v_lunar = v_from_r(r_lunar, t) - return r_lunar, v_lunar - - -def gcrf_to_lunar_fixed(r, t, v=None): - """ - Transform position and velocity vectors from the GCRF (Geocentric Celestial Reference Frame) - to a Moon-fixed (lunar-centric) frame. - - This function adjusts the position and velocity vectors to account for the Moon's motion, - effectively transforming them into a frame fixed to the Moon. - - Parameters: - ----------- - r (numpy array): Position vector(s) in the GCRF [x, y, z]. - t (numpy array): Time(s) at which the position vector(s) are defined. - v (numpy array, optional): Velocity vector(s) in the GCRF [vx, vy, vz]. If not provided, only position is transformed. - - Returns: - -------- - numpy array or tuple: - - If `v` is not provided: Transformed position vector(s) in the Moon-fixed frame. - - If `v` is provided: A tuple containing: - - r_lunar (numpy array): Transformed position vector(s) in the Moon-fixed frame. - - v_lunar (numpy array): Transformed velocity vector(s) in the Moon-fixed frame. - - Notes: - ------ - - The `get_body` function is used to retrieve the Moon's position at a given time. - - The Moon's position is subtracted from the transformed lunar-centric position to obtain a Moon-fixed reference frame. - - If velocity is provided, it is recalculated in the Moon-fixed frame using the `v_from_r` function. - """ - from .body import get_body - r_lunar = gcrf_to_lunar(r, t) - gcrf_to_lunar(get_body('moon').position(t).T, t) - if v is None: - return r_lunar - else: - v = v_from_r(r_lunar, t) - return r_lunar, v - - -def gcrf_to_radec(gcrf_coords): - x, y, z = gcrf_coords - # Calculate right ascension in radians - ra = np.arctan2(y, x) - # Convert right ascension to degrees - ra_deg = np.degrees(ra) - # Normalize right ascension to the range [0, 360) - ra_deg = ra_deg % 360 - # Calculate declination in radians - dec_rad = np.arctan2(z, np.sqrt(x**2 + y**2)) - # Convert declination to degrees - dec_deg = np.degrees(dec_rad) - return (ra_deg, dec_deg) - - -def gcrf_to_ecef_bad(r_gcrf, t): - """ - Convert position vectors from the GCRF (Geocentric Celestial Reference Frame) to the ECEF (Earth-Centered, Earth-Fixed) frame. - - Parameters: - r_gcrf (numpy array): Position vector(s) in the GCRF [x, y, z]. - t (Time or float): Time(s) at which the position vector(s) are defined. If `t` is a `Time` object, GPS seconds are extracted. - - Returns: - numpy array: Position vector(s) in the ECEF frame. - - Notes: - - The Earth's rotation rate is defined by `WGS84_EARTH_OMEGA`. - - The rotation is performed around the Z-axis to account for Earth's rotation. - """ - if isinstance(t, Time): - t = t.gps - r_gcrf = np.atleast_2d(r_gcrf) - rotation_angles = WGS84_EARTH_OMEGA * (t - Time("1980-3-20T11:06:00", format='isot').gps) - cos_thetas = np.cos(rotation_angles) - sin_thetas = np.sin(rotation_angles) - - # Create an array of 3x3 rotation matrices - Rz = np.array([[cos_thetas, -sin_thetas, np.zeros_like(cos_thetas)], - [sin_thetas, cos_thetas, np.zeros_like(cos_thetas)], - [np.zeros_like(cos_thetas), np.zeros_like(cos_thetas), np.ones_like(cos_thetas)]]).T - - # Apply the rotation matrices to all rows of r_gcrf simultaneously - r_ecef = np.einsum('ijk,ik->ij', Rz, r_gcrf) - return r_ecef - - -def gcrf_to_lat_lon(r, t): - """ - Converts a position vector in the GCRF (Geocentric Celestial Reference Frame) - to latitude, longitude, and height coordinates on Earth. - - Parameters: - ----------- - r (array-like): The position vector in GCRF coordinates (x, y, z) in meters. - t (datetime or float): The time associated with the position vector. - This can be a datetime object or a timestamp in seconds. - - Returns: - -------- - tuple: A tuple containing: - - lon (float): Longitude in degrees (East-positive). - - lat (float): Latitude in degrees (North-positive). - - height (float): Height above the Earth's surface in meters. - - Note: - ----- - This function relies on the `groundTrack` function from the `.compute` module - to perform the conversion. - """ - from .compute import groundTrack - lon, lat, height = groundTrack(r, t) - return lon, lat, height - - -def gcrf_to_itrf(r_gcrf, t, v=None): - """ - Converts a position vector in the GCRF (Geocentric Celestial Reference Frame) - to the ITRF (International Terrestrial Reference Frame) in Cartesian coordinates. - - Parameters: - ----------- - r_gcrf (array-like): The position vector in GCRF coordinates (x, y, z) in meters. - t (datetime or float): The time associated with the position vector. - This can be a datetime object or a timestamp in seconds. - v (array-like, optional): Velocity vector in GCRF coordinates. If provided, the function - will return the velocity transformed to the ITRF frame as well. - - Returns: - -------- - tuple: - - If `v` is not provided: - - np.array: A 2D array containing the transformed position vector in ITRF coordinates. - - If `v` is provided: - - np.array: A 2D array containing the transformed position vector in ITRF coordinates. - - np.array: The velocity vector transformed to the ITRF frame. - - Notes: - ------ - - The function relies on the `groundTrack` function from the `.compute` module to perform the - position transformation. - - If velocity (`v`) is provided, the function assumes the existence of a `v_from_r` function - to compute the velocity transformation. - """ - from .compute import groundTrack - x, y, z = groundTrack(r_gcrf, t, format='cartesian') - _ = np.array([x, y, z]).T - if v is None: - return _ - else: - return _, v_from_r(_, t) - - -def gcrf_to_sim_geo(r_gcrf, t, h=10): - """ - Transforms a position vector in the GCRF (Geocentric Celestial Reference Frame) - to a simplified geostationary-like coordinate system. - - Parameters: - ----------- - r_gcrf (array-like): The position vector(s) in GCRF coordinates (x, y, z) in meters. - Can be a single vector or a 2D array of vectors. - t (object): A time object containing GPS time information. Must include a `gps` attribute - (e.g., `t.gps`) that provides time values in seconds. - h (float, optional): Step size for numerical propagation in seconds. If the minimum difference - between consecutive GPS time values is smaller than `h`, the step size - will be adjusted accordingly. Default is 10 seconds. - - Returns: - -------- - np.array: A 2D array of transformed position vectors in the simplified geostationary-like - coordinate system. - - Notes: - ------ - - The function uses the `Orbit` class to define an orbit from Keplerian elements and propagates - it using the `RK78Propagator` with the `AccelKepler` acceleration model. - - The transformation involves calculating the rotation required to align the geostationary - reference frame with the GCRF position vector. - """ - from .accel import AccelKepler - from .compute import rv - from .orbit import Orbit - from .propagator import RK78Propagator - if np.min(np.diff(t.gps)) < h: - h = np.min(np.diff(t.gps)) - r_gcrf = np.atleast_2d(r_gcrf) - r_geo, v_geo = rv(Orbit.fromKeplerianElements(*[RGEO, 0, 0, 0, 0, 0], t=t[0]), t, propagator=RK78Propagator(AccelKepler(), h=h)) - angle_geo_to_x = np.arctan2(r_geo[:, 1], r_geo[:, 0]) - c = np.cos(angle_geo_to_x) - s = np.sin(angle_geo_to_x) - rotation = np.array([[c, -s, np.zeros_like(c)], [s, c, np.zeros_like(c)], [np.zeros_like(c), np.zeros_like(c), np.ones_like(c)]]).T - return np.einsum('ijk,ik->ij', rotation, r_gcrf) - - -# Function still in development, not 100% accurate. -def gcrf_to_itrf_astropy(state_vectors, t): - """ - Converts position vectors from the GCRF (Geocentric Celestial Reference Frame) to the ITRF - (International Terrestrial Reference Frame) using Astropy. - - This function is still under development and may not produce 100% accurate results. - - Parameters: - ----------- - state_vectors (np.array): A 2D array of shape (N, 3), where N is the number of position vectors. - Each row contains the (x, y, z) Cartesian coordinates in meters in the GCRF frame. - t (astropy.time.Time): An Astropy `Time` object representing the observation time(s) for the transformation. - - Returns: - -------- - np.array: A 2D array of shape (N, 3), where N is the number of position vectors. Each row contains - the (x, y, z) Cartesian coordinates in meters in the ITRF frame. - - Notes: - ------ - - The transformation uses Astropy's `SkyCoord` and `GCRS`/`ITRS` frames for coordinate conversion. - - The barycentric position of Earth is calculated using the `solar_system_ephemeris` context manager - with the DE430 ephemeris. - - The transformation accounts for Earth's barycentric position to ensure the coordinates are - relative to Earth's center in the ITRF frame. - - The function assumes the input `state_vectors` are in meters and outputs coordinates in meters. - - - """ - import astropy.units as u - from astropy.coordinates import GCRS, ITRS, SkyCoord, get_body_barycentric, solar_system_ephemeris, ICRS - - sc = SkyCoord(x=state_vectors[:, 0] * u.m, y=state_vectors[:, 1] * u.m, z=state_vectors[:, 2] * u.m, representation_type='cartesian', frame=GCRS(obstime=t)) - sc_itrs = sc.transform_to(ITRS(obstime=t)) - with solar_system_ephemeris.set('de430'): # other options: builtin, de432s - earth = get_body_barycentric('earth', t) - earth_center_itrs = SkyCoord(earth.x, earth.y, earth.z, representation_type='cartesian', frame=ICRS()).transform_to(ITRS(obstime=t)) - itrs_coords = SkyCoord( - sc_itrs.x.value - earth_center_itrs.x.to_value(u.m), - sc_itrs.y.value - earth_center_itrs.y.to_value(u.m), - sc_itrs.z.value - earth_center_itrs.z.to_value(u.m), - representation_type='cartesian', - frame=ITRS(obstime=t) - ) - # Extract Cartesian coordinates and convert to meters - itrs_coords_meters = np.array([itrs_coords.x, - itrs_coords.y, - itrs_coords.z]).T - return itrs_coords_meters - - -def v_from_r(r, t): - """ - Calculate the velocity from position and time data. - - Parameters: - ----------- - r (ndarray): Array of position data with shape (N, D), - where N is the number of time steps and D is the number of dimensions. - t (array-like): Array of time data corresponding to the position data. - If the first element is of type `Time`, it will be converted to GPS time. - - Returns: - -------- - ndarray: Array of velocity data with shape (N, D), calculated as the rate of change of position - over time. The last row of the velocity array is repeated to match the input shape. - """ - if isinstance(t[0], Time): - t = t.gps - delta_r = np.diff(r, axis=0) - delta_t = np.diff(t) - v = delta_r / delta_t[:, np.newaxis] - v = np.vstack((v, v[-1])) - return v - - # Stolen from https://github.com/lsst/utils/blob/main/python/lsst/utils/wrappers.py INTRINSIC_SPECIAL_ATTRIBUTES = frozenset( ( @@ -3224,45 +2601,6 @@ def dd_to_hms(degree_decimal): return f'{int(_h)}:{int(_m)}:{_s}' -def get_times(duration: Tuple[int, str], freq: Tuple[int, str], t0: Union[str, Time] = "2025-01-01") -> np.ndarray: - """ - Calculate a list of times spaced equally apart over a specified duration. - - Parameters - ---------- - duration : tuple - A tuple containing the length of time and the unit (e.g., (30, 'day')). - freq : tuple - A tuple containing the frequency value and its unit (e.g., (1, 'hr')). - t0 : str or Time, optional - The starting time. Default is "2025-01-01". - - Returns - ------- - np.ndarray - A list of times spaced equally apart over the specified duration. - """ - if isinstance(t0, str): - t0 = Time(t0, scale='utc') - unit_dict = {'second': 1, 'sec': 1, 's': 1, 'minute': 60, 'min': 60, 'hour': 3600, 'hr': 3600, 'h': 3600, 'day': 86400, 'd': 86400, 'week': 604800, 'month': 2630016, 'mo': 2630016, 'year': 31557600, 'yr': 31557600} - dur_val, dur_unit = duration - freq_val, freq_unit = freq - if dur_unit[-1] == 's' and len(dur_unit) > 1: - dur_unit = dur_unit[:-1] - if freq_unit[-1] == 's' and len(freq_unit) > 1: - freq_unit = freq_unit[:-1] - if dur_unit.lower() not in unit_dict: - raise ValueError(f'Error, {dur_unit} is not a valid time unit. Valid options are: {", ".join(unit_dict.keys())}.') - if freq_unit.lower() not in unit_dict: - raise ValueError(f'Error, {freq_unit} is not a valid time unit. Valid options are: {", ".join(unit_dict.keys())}.') - dur_seconds = dur_val * unit_dict[dur_unit.lower()] - freq_seconds = freq_val * unit_dict[freq_unit.lower()] - timesteps = int(dur_seconds / freq_seconds) + 1 - - times = t0 + np.linspace(0, dur_seconds, timesteps) / unit_dict['day'] * u.day - return times - - def interpolate_points_between(r, m): """ Interpolates points between the given points. @@ -3283,94 +2621,3 @@ def interpolate_points_between(r, m): z = np.linspace(r[i, 2], r[i, 2], m) interpolated_points = np.vstack((interpolated_points, np.array([x, y, z]).T)) return np.vstack((interpolated_points, r[-1])) - - -def check_lunar_collision(r, times, m=1000): - """ - Checks if the trajectory of a particle intersects with the Moon. - - Parameters - ---------- - r : np.array - The particle's trajectory in Cartesian coordinates. - times : an array of astropy.Time where r points are calculated. - m : int, optional - The number of points to interpolate between. Defaults to 1000. - - Returns - ------- - np.array - Indexes where collision occurs. - """ - from .body import get_body - # For a time step of 1 hour, m=1000 will be sensitive of collisions up to 482 km/s - new_r = interpolate_points_between(r, m) - # Time span of integration - times_new = Time(np.linspace(times.decimalyear[0], times.decimalyear[-1], int(len(times) * m + 1)), format='decimalyear', scale='utc') - moon_r = get_body('moon').position(times_new).T - collision_index = np.where(np.linalg.norm(new_r - moon_r, axis=-1) < MOON_RADIUS) - if np.size(collision_index) > 0: - collision_times = times_new[collision_index] - nearest_indices = find_nearest_indices(times.decimalyear, collision_times.decimalyear) - return np.array(list(set(nearest_indices))) - else: - return [] - - -def find_nearest_indices(A, B): - """ - Finds the indices of the nearest values in array `A` for each value in array `B`. - - Parameters: - ----------- - A (array-like): A 1D array or list of values to search within. - B (array-like): A 1D array or list of values for which the nearest values in `A` are to be found. - - Returns: - -------- - numpy.ndarray: A 1D array of indices corresponding to the nearest values in `A` for each value in `B`. - - Notes: - ------ - - This function uses broadcasting to compute the absolute differences between each element in `B` - and all elements in `A`. - - The nearest value is determined by finding the index of the minimum absolute difference. - - If there are multiple values in `A` equally close to a value in `B`, the index of the first - occurrence is returned. - - Example: - -------- - >>> import numpy as np - >>> A = np.array([1, 3, 7, 10]) - >>> B = np.array([2, 8]) - >>> find_nearest_indices(A, B) - array([1, 2]) # Nearest values are A[1] (3) for B[0] (2) and A[2] (7) for B[1] (8). - """ - # Calculate the absolute differences between B and A using broadcasting - abs_diff = np.abs(B[:, np.newaxis] - A) - # Find the index of the minimum absolute difference for each element of B - nearest_indices = np.argmin(abs_diff, axis=1) - return nearest_indices - - -def find_smallest_bounding_cube(r: np.ndarray, pad: float = 0.0) -> Tuple[np.ndarray, np.ndarray]: - """ - Find the smallest bounding cube for a set of 3D coordinates, with optional padding. - - Parameters: - r (np.ndarray): An array of shape (n, 3) containing the 3D coordinates. - pad (float): Amount to increase the bounding cube in all dimensions. - - Returns: - tuple: A tuple containing the lower and upper bounds of the bounding cube. - """ - min_coords = np.min(r, axis=0) - max_coords = np.max(r, axis=0) - ranges = max_coords - min_coords - max_range = np.max(ranges) - center = (max_coords + min_coords) / 2 - half_side_length = max_range / 2 + pad - lower_bound = center - half_side_length - upper_bound = center + half_side_length - - return lower_bound, upper_bound \ No newline at end of file diff --git a/tests/devel/resolve_state_methods.ipynb b/tests/devel/resolve_state_methods.ipynb deleted file mode 100644 index 456dfd87..00000000 --- a/tests/devel/resolve_state_methods.ipynb +++ /dev/null @@ -1,555 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Make state and state_osc consistent" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import tempfile\n", - "import numpy as np\n", - "import astropy.units as u\n", - "from astropy import time as at\n", - "\n", - "from ssa.orbits import orbits\n", - "from ssa.orbits import constants as orbits_constants\n", - "from ssa.orbits import utils as orbits_utils\n", - "\n", - "import matplotlib.pyplot as plt\n", - "%matplotlib inline\n", - "plt.style.use('ggplot')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## From Keplerian elements" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "# times = np.array([30, 32, 34])*u.min\n", - "x_ref = np.array([-5579.68152, -5999.98283, -6315.09741])*u.km\n", - "y_ref = np.array([2729.24460, 1951.42198, 1139.38652])*u.km\n", - "z_ref = np.array([2973.90172, 2765.92981, 2509.46697])*u.km\n", - "\n", - "# Copy orbit parameters from TSB example 2.2.4.1\n", - "a = 6828.973232519*u.km\n", - "e = 0.0090173388450585\n", - "i = 28.474011884869*u.deg\n", - "Omega = 35.911822759495*u.deg\n", - "omega = -44.55584705279*u.deg\n", - "M0 = 43.8860381032208*u.deg\n", - "# t0 <- 0 # arbitrary choice\n", - "t0_default = at.Time(2458316., format='jd')\n", - "orbit = orbits.Orbit(a=a, e=e, inclination=np.deg2rad(i), mean_anomaly_at_t0=np.deg2rad(M0),\n", - " laan=np.deg2rad(Omega), arg_periapsis=np.deg2rad(omega), t0=t0_default)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "times = np.linspace(0., 150., num=20) * u.min" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "p1vals = []\n", - "p2vals = []\n", - "for i,time in enumerate(times):\n", - " p1, _ = orbit.get_state(t0_default+time)\n", - " p2, _ = orbit.get_state_osc(t0_default+time)\n", - " p1vals.append(p1.value)\n", - " p2vals.append(p2.value)\n", - "p1vals = np.array(p1vals)\n", - "p2vals = np.array(p2vals)" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig = plt.figure(figsize=(8,10))\n", - "labels = [r\"$x$\", r\"$y$\", r\"$z$\"]\n", - "for i in range(3):\n", - " plt.subplot(3,1,i+1)\n", - " plt.plot(times, p1vals[:,i], 'o-', label='sgp4')\n", - " plt.plot(times, p2vals[:,i], 'o-', label='osc')\n", - " plt.legend()\n", - " plt.xlabel(\"times (sec)\")\n", - " plt.ylabel(labels[i] + \" (km)\")\n", - "plt.tight_layout()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now plot differences in predicted positions versus time." - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig = plt.figure(figsize=(8,10))\n", - "labels = [r\"$\\Delta x$\", r\"$\\Delta y$\", r\"$\\Delta z$\"]\n", - "for i in range(3):\n", - " plt.subplot(3,1,i+1)\n", - " plt.plot(times, p1vals[:,i] - p2vals[:,i], 'o-', label='sgp4')\n", - " plt.legend()\n", - " plt.xlabel(\"times (min)\")\n", - " plt.ylabel(labels[i] + \" (km)\")\n", - "plt.tight_layout()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## From TLE" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "temp = tempfile.NamedTemporaryFile('w')\n", - "temp.write('TEST\\n')\n", - "temp.write('1 88888U 80275.98708465 .00073094 13844-3 66816-4 0 8\\n')\n", - "temp.write('2 88888 72.8435 115.9689 0086731 52.6988 110.5714 16.05824518 105\\n')\n", - "temp.flush()\n", - "\n", - "orbit = orbits.Orbit(sat_name='TEST', tle_filename=temp.name)" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [], - "source": [ - "times = np.linspace(0., 150., num=20) * u.min" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "p1vals = []\n", - "p2vals = []\n", - "for i,time in enumerate(times):\n", - " p1, _ = orbit.get_state(orbit.t0+time)\n", - " p2, _ = orbit.get_state_osc(orbit.t0+time)\n", - " p1vals.append(p1.value)\n", - " p2vals.append(p2.value)\n", - "p1vals = np.array(p1vals)\n", - "p2vals = np.array(p2vals)" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig = plt.figure(figsize=(8,10))\n", - "labels = [r\"$x$\", r\"$y$\", r\"$z$\"]\n", - "for i in range(3):\n", - " plt.subplot(3,1,i+1)\n", - " plt.plot(times, p1vals[:,i], 'o-', label='sgp4')\n", - " plt.plot(times, p2vals[:,i], 'o-', label='osc')\n", - " plt.legend()\n", - " plt.xlabel(\"times (sec)\")\n", - " plt.ylabel(labels[i] + \" (km)\")\n", - "plt.tight_layout()" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig = plt.figure(figsize=(8,10))\n", - "labels = [r\"$\\Delta x$\", r\"$\\Delta y$\", r\"$\\Delta z$\"]\n", - "for i in range(3):\n", - " plt.subplot(3,1,i+1)\n", - " plt.plot(times, p1vals[:,i] - p2vals[:,i], 'o-', label='sgp4')\n", - " plt.legend()\n", - " plt.xlabel(\"times (min)\")\n", - " plt.ylabel(labels[i] + \" (km)\")\n", - "plt.tight_layout()" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.plot(p1vals[:,0], p1vals[:,1])\n", - "plt.plot(p2vals[:,0], p2vals[:,1])" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.plot(p1vals[:,0], p1vals[:,2])\n", - "plt.plot(p2vals[:,0], p2vals[:,2])" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.plot(p1vals[:,1], p1vals[:,2])\n", - "plt.plot(p2vals[:,1], p2vals[:,2])" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'error': 0,\n", - " 'whichconst': EarthGravity(tumin=13.446839696959309, mu=398600.8, radiusearthkm=6378.135, xke=0.07436691613317342, j2=0.001082616, j3=-2.53881e-06, j4=-1.65597e-06, j3oj2=-0.002345069720011528),\n", - " 'satnum': 88888,\n", - " 'epochdays': 275.98708465,\n", - " 'ndot': 2.2148107004387767e-09,\n", - " 'nddot': 2.913090538750181e-13,\n", - " 'bstar': 6.6816e-05,\n", - " 'inclo': 1.2713589136764896,\n", - " 'nodeo': 2.0240391349160523,\n", - " 'ecco': 0.0086731,\n", - " 'argpo': 0.9197675718499877,\n", - " 'mo': 1.929834988539658,\n", - " 'no': 0.07010615566652889,\n", - " 'a': 1.040501892439114,\n", - " 'alta': 0.04952626940242766,\n", - " 'altp': 0.031477515475800466,\n", - " 'epochyr': 1980,\n", - " 'jdsatepoch': 2444514.48708465,\n", - " 'epoch': datetime.datetime(1980, 10, 1, 23, 41, 24, 113759),\n", - " 'isimp': 1,\n", - " 'method': 'n',\n", - " 'aycof': 0.0011203600999678345,\n", - " 'con41': -0.7389556198424165,\n", - " 'cc1': 2.3338044021689716e-08,\n", - " 'cc4': 0.00037720111784279506,\n", - " 'cc5': 0.012334919185405555,\n", - " 'd2': 0.0,\n", - " 'd3': 0.0,\n", - " 'd4': 0.0,\n", - " 'delmo': 0.6963086753785733,\n", - " 'eta': 0.3234711971625582,\n", - " 'argpdot': -2.971792488744675e-05,\n", - " 'omgcof': 1.63483047508046e-07,\n", - " 'sinmao': 0.9362350458581234,\n", - " 't': 149.99999977648258,\n", - " 't2cof': 3.5007066032534573e-08,\n", - " 't3cof': 0.0,\n", - " 't4cof': 0.0,\n", - " 't5cof': 0.0,\n", - " 'x1mth2': 0.9129852066141388,\n", - " 'x7thm1': -0.3908964462989719,\n", - " 'mdot': 0.07006729343208126,\n", - " 'nodedot': -3.0963112416871014e-05,\n", - " 'xlcof': 0.0019357457580171985,\n", - " 'xmcof': -4.9353388108660396e-05,\n", - " 'nodecf': -2.535821868201215e-12,\n", - " 'irez': 0,\n", - " 'd2201': 0.0,\n", - " 'd2211': 0.0,\n", - " 'd3210': 0.0,\n", - " 'd3222': 0.0,\n", - " 'd4410': 0.0,\n", - " 'd4422': 0.0,\n", - " 'd5220': 0.0,\n", - " 'd5232': 0.0,\n", - " 'd5421': 0.0,\n", - " 'd5433': 0.0,\n", - " 'dedt': 0.0,\n", - " 'del1': 0.0,\n", - " 'del2': 0.0,\n", - " 'del3': 0.0,\n", - " 'didt': 0.0,\n", - " 'dmdt': 0.0,\n", - " 'dnodt': 0.0,\n", - " 'domdt': 0.0,\n", - " 'e3': 0.0,\n", - " 'ee2': 0.0,\n", - " 'peo': 0.0,\n", - " 'pgho': 0.0,\n", - " 'pho': 0.0,\n", - " 'pinco': 0.0,\n", - " 'plo': 0.0,\n", - " 'se2': 0.0,\n", - " 'se3': 0.0,\n", - " 'sgh2': 0.0,\n", - " 'sgh3': 0.0,\n", - " 'sgh4': 0.0,\n", - " 'sh2': 0.0,\n", - " 'sh3': 0.0,\n", - " 'si2': 0.0,\n", - " 'si3': 0.0,\n", - " 'sl2': 0.0,\n", - " 'sl3': 0.0,\n", - " 'sl4': 0.0,\n", - " 'gsto': 0.1082901416688955,\n", - " 'xfact': 0.0,\n", - " 'xgh2': 0.0,\n", - " 'xgh3': 0.0,\n", - " 'xgh4': 0.0,\n", - " 'xh2': 0.0,\n", - " 'xh3': 0.0,\n", - " 'xi2': 0.0,\n", - " 'xi3': 0.0,\n", - " 'xl2': 0.0,\n", - " 'xl3': 0.0,\n", - " 'xl4': 0.0,\n", - " 'xlamo': 0.0,\n", - " 'zmol': 0.0,\n", - " 'zmos': 0.0,\n", - " 'atime': 0.0,\n", - " 'xli': 0.0,\n", - " 'xni': 0.0,\n", - " 'operationmode': 'i',\n", - " 'init': 'n',\n", - " 'error_message': None}" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "orbit._orbit.__dict__" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.0011684359277754825 rad / s\n", - "0.0011684359277754814 rad / s\n" - ] - } - ], - "source": [ - "print(orbit.mean_motion)\n", - "n0 = orbit._orbit.no / 60. * (u.rad / u.s)\n", - "print(n0)" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'name': 'TEST',\n", - " '_orbit': ,\n", - " 'a_osc': ,\n", - " 'e_osc': 0.0086731,\n", - " 'arg_periapsis_osc': ,\n", - " 'laan_osc': ,\n", - " 'inclination_osc': ,\n", - " 'mean_anomaly_at_t0': ,\n", - " 't0':