adam_core.dynamics.lambert module

Implementation of Lambert’s problem using Izzo’s method.

This implementation follows the algorithm described in: Izzo, D. (2015). Revisiting Lambert’s problem. Celestial Mechanics and Dynamical Astronomy, 121(1), 1-15.

Credits: Based on poliastro implementation by Juan Luis Cano Rodríguez and lamberthub by Jorge Martinez

adam_core.dynamics.lambert.izzo_lambert(r1: Array, r2: Array, tof: float, mu: float = 0.00029591220828411956, M: int = 0, prograde: bool = True, low_path: bool = True, maxiter: int = 35, atol: float = 1e-10, rtol: float = 1e-10) → Tuple[Array, Array][source]

Solves Lambert’s problem using Izzo’s devised algorithm.

Parameters:

  • r1 (jnp.ndarray) – Initial position vector.

  • r2 (jnp.ndarray) – Final position vector.

  • tof (float) – Time of flight.

  • mu (float) – Gravitational parameter, equivalent to GM of attractor body.

  • M (int) – Number of revolutions. Must be equal or greater than 0.

  • prograde (bool) – If True, specifies prograde motion. Otherwise, retrograde motion is imposed.

  • low_path (bool) – If two solutions are available, it selects between high or low path.

  • maxiter (int) – Maximum number of iterations.

  • atol (float) – Absolute tolerance.

  • rtol (float) – Relative tolerance.

Returns:

  • v1 (jnp.ndarray) – Initial velocity vector.

  • v2 (jnp.ndarray) – Final velocity vector.

adam_core.dynamics.lambert.solve_lambert(r1: ndarray | Array, r2: ndarray | Array, tof: ndarray | float, mu: float = 0.00029591220828411956, prograde: bool = True, max_iter: int = 35, tol: float = 1e-10) → Tuple[ndarray, ndarray][source]

Solve Lambert’s problem for multiple initial and final positions and times of flight.

This implementation uses Izzo’s method which is robust and handles all orbit types.

Parameters:

  • r1 (array_like (N, 3)) – Initial position vectors in au.

  • r2 (array_like (N, 3)) – Final position vectors in au.

  • tof (array_like (N) or float) – Times of flight in days.

  • mu (float, optional) – Gravitational parameter (GM) of the attracting body in units of au³/day².

  • prograde (bool, optional) – If True, assume prograde motion. If False, assume retrograde motion.

  • max_iter (int, optional) – Maximum number of iterations for convergence.

  • tol (float, optional) – Convergence tolerance.

Returns:

  • v1 (ndarray (N, 3)) – Initial velocity vectors in au/day with origin at the attractor

  • v2 (ndarray (N, 3)) – Final velocity vectors in au/day with origin at the attractor

adam_core.dynamics.lambert.calculate_c3(v1: ndarray | Array, body_v: ndarray | Array) → ndarray[tuple[Any, ...], dtype[float64]][source]

Calculate the C3 of a spacecraft given its velocity relative to a body.

Parameters:

  • v1 (array_like (N, 3)) – Velocity of the spacecraft in au/d.

  • body_v (array_like (N, 3)) – Velocity of the body in au/d.

Returns:

c3 – C3 of the spacecraft in au^2/d^2.

Return type:

array_like (N)