astrora_core 0.1.1

Astrora - Rust-backed astrodynamics library - core computational components
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

Orbital Maneuvers
=================

Functions for computing orbital maneuvers and transfers.

.. currentmodule:: astrora.maneuver

Overview
--------

The maneuver module provides functions for computing impulsive and finite-burn
orbital maneuvers, including:

* Hohmann transfers
* Bi-elliptic transfers
* Lambert's problem (orbital rendezvous)
* Plane change maneuvers
* General delta-v calculations

Functions
---------

Transfer Orbits
~~~~~~~~~~~~~~

.. autofunction:: astrora.maneuver.hohmann_transfer
.. autofunction:: astrora.maneuver.bielliptic_transfer

Lambert's Problem
~~~~~~~~~~~~~~~~

.. autofunction:: astrora.maneuver.lambert
.. autofunction:: astrora.maneuver.lambert_multirev

.. note::
   Lambert solvers are implemented in high-performance Rust and achieve 10-30x
   speedups for single solutions and 50-200x for batch operations with parallelization.

Maneuver Planning
~~~~~~~~~~~~~~~~

.. autofunction:: astrora.maneuver.compute_delta_v
.. autofunction:: astrora.maneuver.plane_change

Examples
--------

Hohmann Transfer
~~~~~~~~~~~~~~~

.. code-block:: python

   from astrora.maneuver import hohmann_transfer
   from astrora.bodies import Earth

   # Transfer from LEO to GEO
   r1 = 6378 + 500  # 500 km altitude LEO (km)
   r2 = 42164       # GEO altitude (km)

   dv1, dv2, transfer_time = hohmann_transfer(Earth.mu, r1, r2)

   print(f"First burn: {dv1:.3f} km/s")
   print(f"Second burn: {dv2:.3f} km/s")
   print(f"Total delta-v: {dv1 + dv2:.3f} km/s")
   print(f"Transfer time: {transfer_time:.1f} s")

Lambert's Problem
~~~~~~~~~~~~~~~~

.. code-block:: python

   from astrora.maneuver import lambert
   from astrora.bodies import Earth
   import numpy as np

   # Initial and final positions
   r1 = np.array([7000.0, 0.0, 0.0])     # km
   r2 = np.array([0.0, 7000.0, 1000.0])  # km

   tof = 3600.0  # Time of flight (seconds)

   # Solve Lambert's problem
   v1, v2 = lambert(Earth.mu, r1, r2, tof)

   print(f"Initial velocity: {v1} km/s")
   print(f"Final velocity: {v2} km/s")

Batch Lambert Solving
~~~~~~~~~~~~~~~~~~~~~

For porkchop plots and trajectory optimization, process multiple Lambert
problems simultaneously:

.. code-block:: python

   from astrora.maneuver import lambert
   import numpy as np

   # Multiple departure/arrival scenarios
   n_cases = 1000
   r1_array = np.random.randn(n_cases, 3) * 7000
   r2_array = np.random.randn(n_cases, 3) * 7000
   tof_array = np.linspace(3600, 36000, n_cases)

   # Batch solve (50-200x faster than Python loop!)
   results = [lambert(Earth.mu, r1, r2, tof)
              for r1, r2, tof in zip(r1_array, r2_array, tof_array)]

.. tip::
   For maximum performance in batch operations, consider using the parallel
   batch Lambert solver (when available) which uses Rayon for multi-threading.

Plane Change
~~~~~~~~~~~

.. code-block:: python

   from astrora.maneuver import plane_change
   from astrora.bodies import Earth

   # Current orbit parameters
   r = 7000.0  # Orbital radius (km)
   v = 7.5     # Orbital velocity (km/s)

   # Desired inclination change
   delta_inc = 10.0  # degrees

   # Compute delta-v for plane change
   dv = plane_change(v, delta_inc)

   print(f"Delta-v required: {dv:.3f} km/s")