Skip to content

Keplerian Elements

Functions for working with Keplerian orbital elements and computing orbital properties.

Orbital Properties

semimajor_axis builtin 

semimajor_axis(n: Union[float, array], angle_format: AngleFormat) -> Union[float, ndarray]

Computes the semi-major axis of an astronomical object from Earth given the object's mean motion.

Parameters:

Name Type Description Default
n float or array

The mean motion of the astronomical object in radians or degrees. An array is evaluated element-wise.

 required
angle_format AngleFormat

Interpret mean motion as AngleFormat.DEGREES or AngleFormat.RADIANS.

 required

Returns:

Type Description
Union[float, ndarray]

float or numpy.ndarray: The semi-major axis of the astronomical object in meters. An array of the input shape is returned for array input.
Example 
1
2
3
4
5
6
import brahe as bh

# Calculate semi-major axis from mean motion (typical LEO satellite)
n = 0.001027  # radians/second (~15 revolutions/day)
a = bh.semimajor_axis(n, bh.AngleFormat.RADIANS)
print(f"Semi-major axis: {a/1000:.2f} km")

semimajor_axis_general builtin 

semimajor_axis_general(n: Union[float, array], gm: float, angle_format: AngleFormat) -> Union[float, ndarray]

Computes the semi-major axis of an astronomical object from a general body given the object's mean motion.

Parameters:

Name Type Description Default
n float or array

The mean motion of the astronomical object in radians or degrees. An array is evaluated element-wise.

 required
gm float

(keyword-only) The standard gravitational parameter of primary body in m³/s².

 required
angle_format AngleFormat

Interpret mean motion as AngleFormat.DEGREES or AngleFormat.RADIANS.

 required

Returns:

Type Description
Union[float, ndarray]

float or numpy.ndarray: The semi-major axis of the astronomical object in meters. An array of the input shape is returned for array input.
Example 
1
2
3
4
5
6
import brahe as bh

# Calculate semi-major axis for Jupiter orbiter
n = 0.0001  # radians/second
a = bh.semimajor_axis_general(n, bh.GM_JUPITER, bh.AngleFormat.RADIANS)
print(f"Semi-major axis: {a/1000:.2f} km")

semimajor_axis_from_orbital_period builtin 

semimajor_axis_from_orbital_period(period: Union[float, array]) -> Union[float, ndarray]

Computes the semi-major axis from orbital period around Earth.

Parameters:

Name Type Description Default
period float or array

The orbital period in seconds. An array is evaluated element-wise.

 required

Returns:

Type Description
Union[float, ndarray]

float or numpy.ndarray: The semi-major axis in meters. An array of the input shape is returned for array input.
Example 
1
2
3
4
5
6
import brahe as bh

# Calculate semi-major axis for a 90-minute orbit
period = 90 * 60.0  # 90 minutes in seconds
a = bh.semimajor_axis_from_orbital_period(period)
print(f"Semi-major axis: {a/1000:.2f} km")

semimajor_axis_from_orbital_period_general builtin 

semimajor_axis_from_orbital_period_general(period: Union[float, array], gm: float) -> Union[float, ndarray]

Computes the semi-major axis from orbital period for a general body.

Parameters:

Name Type Description Default
period float or array

The orbital period in seconds. An array is evaluated element-wise.

 required
gm float

(keyword-only) The standard gravitational parameter of primary body in m³/s².

 required

Returns:

Type Description
Union[float, ndarray]

float or numpy.ndarray: The semi-major axis in meters. An array of the input shape is returned for array input.
Example 
1
2
3
4
5
6
import brahe as bh

# Calculate semi-major axis for 2-hour Venus orbit
period = 2 * 3600.0  # 2 hours in seconds
a = bh.semimajor_axis_from_orbital_period_general(period, bh.GM_VENUS)
print(f"Semi-major axis: {a/1000:.2f} km")

mean_motion builtin 

mean_motion(a_or_oe: Union[float, array], angle_format: AngleFormat) -> Union[float, ndarray]

Computes the mean motion of an astronomical object around Earth.

Parameters:

Name Type Description Default
a_or_oe float or array

The semi-major axis in meters, as a scalar or an array evaluated element-wise; or a 2-D array of shape (n, 6) of Keplerian element sets [a, e, i, Ω, ω, ν] from which a is taken row by row.

 required
angle_format AngleFormat

(keyword-only) Return output in AngleFormat.DEGREES or AngleFormat.RADIANS.

 required

Returns:

Type Description
Union[float, ndarray]

float or numpy.ndarray: The mean motion of the astronomical object in radians or degrees. An array is returned for array input: shape (n,) for n element sets, or the input shape for element-wise input.
Example 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
import brahe as bh
import numpy as np

# Using scalar semi-major axis
a = bh.R_EARTH + 35786e3
n = bh.mean_motion(a, bh.AngleFormat.DEGREES)
print(f"Mean motion: {n:.6f} deg/s")

# Using a batch of Keplerian element sets, one result per row
oe = [bh.R_EARTH + 35786e3, 0.001, np.radians(0), 0, 0, 0]
n_rows = bh.mean_motion(np.array([oe, oe]), bh.AngleFormat.DEGREES)
print(f"Mean motion: (first row) {n_rows[0]:.6f} deg/s")

mean_motion_general builtin 

mean_motion_general(a_or_oe: Union[float, array], gm: float, angle_format: AngleFormat) -> Union[float, ndarray]

Computes the mean motion of an astronomical object around a general body given a semi-major axis.

Parameters:

Name Type Description Default
a_or_oe float or array

The semi-major axis in meters, as a scalar or an array evaluated element-wise; or a 2-D array of shape (n, 6) of Keplerian element sets [a, e, i, Ω, ω, ν] from which a is taken row by row.

 required
gm float

(keyword-only) The standard gravitational parameter of primary body in m³/s².

 required
angle_format AngleFormat

(keyword-only) Return output in AngleFormat.DEGREES or AngleFormat.RADIANS.

 required

Returns:

Type Description
Union[float, ndarray]

float or numpy.ndarray: The mean motion of the astronomical object in radians or degrees. An array is returned for array input: shape (n,) for n element sets, or the input shape for element-wise input.
Example 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
import brahe as bh
import numpy as np

# Using scalar semi-major axis
a = 4000000.0  # 4000 km semi-major axis
n = bh.mean_motion_general(a, bh.GM_MARS, bh.AngleFormat.RADIANS)
print(f"Mean motion: {n:.6f} rad/s")

# Using a batch of Keplerian element sets, one result per row
oe = [4000000.0, 0.01, np.radians(30), 0, 0, 0]
n_rows = bh.mean_motion_general(np.array([oe, oe]), bh.GM_MARS, bh.AngleFormat.RADIANS)
print(f"Mean motion: (first row) {n_rows[0]:.6f} rad/s")

orbital_period builtin 

orbital_period(a_or_oe: Union[float, array]) -> Union[float, ndarray]

Computes the orbital period of an object around Earth.

Uses rastro.constants.GM_EARTH as the standard gravitational parameter for the calculation.

Parameters:

Name Type Description Default
a_or_oe float or array

The semi-major axis in meters, as a scalar or an array evaluated element-wise; or a 2-D array of shape (n, 6) of Keplerian element sets [a, e, i, Ω, ω, ν] from which a is taken row by row.

 required

Returns:

Type Description
Union[float, ndarray]

float or numpy.ndarray: The orbital period of the astronomical object in seconds. An array is returned for array input: shape (n,) for n element sets, or the input shape for element-wise input.
Example 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
import brahe as bh
import numpy as np

# Using scalar semi-major axis
a = bh.R_EARTH + 400e3
period = bh.orbital_period(a)
print(f"Orbital period: {period/60:.2f} minutes")

# Using a batch of Keplerian element sets, one result per row
oe = [bh.R_EARTH + 400e3, 0.001, np.radians(51.6), 0, 0, 0]
period_rows = bh.orbital_period(np.array([oe, oe]))
print(f"Orbital period: (first row) {period_rows[0]/60:.2f} minutes")

orbital_period_general builtin 

orbital_period_general(a_or_oe: Union[float, array], gm: float) -> Union[float, ndarray]

Computes the orbital period of an astronomical object around a general body.

Parameters:

Name Type Description Default
a_or_oe float or array

The semi-major axis in meters, as a scalar or an array evaluated element-wise; or a 2-D array of shape (n, 6) of Keplerian element sets [a, e, i, Ω, ω, ν] from which a is taken row by row.

 required
gm float

(keyword-only) The standard gravitational parameter of primary body in m³/s².

 required

Returns:

Type Description
Union[float, ndarray]

float or numpy.ndarray: The orbital period of the astronomical object in seconds. An array is returned for array input: shape (n,) for n element sets, or the input shape for element-wise input.
Example 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
import brahe as bh
import numpy as np

# Using scalar semi-major axis
a = 1900000.0  # 1900 km semi-major axis
period = bh.orbital_period_general(a, bh.GM_MOON)
print(f"Lunar orbital period: {period/3600:.2f} hours")

# Using a batch of Keplerian element sets, one result per row
oe = [1900000.0, 0.01, np.radians(45), 0, 0, 0]
period_rows = bh.orbital_period_general(np.array([oe, oe]), bh.GM_MOON)
print(f"Lunar orbital period: (first row) {period_rows[0]/3600:.2f} hours")

periapsis_distance builtin 

periapsis_distance(a_or_oe: Union[float, array], e: Union[float, array] = None) -> Union[float, ndarray]

Calculate the distance of an object at its periapsis.

Parameters:

Name Type Description Default
a_or_oe float or array

The semi-major axis in meters, as a scalar or an array evaluated element-wise (broadcast against e); or, when e is omitted, a 2-D array of shape (n, 6) of Keplerian element sets [a, e, i, Ω, ω, ν] from which a and e are taken row by row.

 required
e float or array

The eccentricity, broadcast against a_or_oe when either is an array. Required unless a_or_oe is a 2-D element-set batch, where it is ignored.

 None

Returns:

Type Description
Union[float, ndarray]

float or numpy.ndarray: The distance of the object at periapsis in meters. An array is returned for array input: shape (n,) for n element sets, or the broadcast shape for element-wise input.
Example 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import brahe as bh
import numpy as np

# Using scalar parameters
a = 8000000.0  # 8000 km semi-major axis
e = 0.2  # moderate eccentricity
r_peri = bh.periapsis_distance(a, e)
print(f"Periapsis distance: {r_peri/1000:.2f} km")

# Using a batch of Keplerian element sets, one result per row
oe = [8000000.0, 0.2, np.radians(45), 0, 0, 0]
r_peri_rows = bh.periapsis_distance(np.array([oe, oe]))
print(f"Periapsis distance: (first row) {r_peri_rows[0]/1000:.2f} km")

apoapsis_distance builtin 

apoapsis_distance(a_or_oe: Union[float, array], e: Union[float, array] = None) -> Union[float, ndarray]

Calculate the distance of an object at its apoapsis.

Parameters:

Name Type Description Default
a_or_oe float or array

The semi-major axis in meters, as a scalar or an array evaluated element-wise (broadcast against e); or, when e is omitted, a 2-D array of shape (n, 6) of Keplerian element sets [a, e, i, Ω, ω, ν] from which a and e are taken row by row.

 required
e float or array

The eccentricity, broadcast against a_or_oe when either is an array. Required unless a_or_oe is a 2-D element-set batch, where it is ignored.

 None

Returns:

Type Description
Union[float, ndarray]

float or numpy.ndarray: The distance of the object at apoapsis in meters. An array is returned for array input: shape (n,) for n element sets, or the broadcast shape for element-wise input.
Example 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import brahe as bh
import numpy as np

# Using scalar parameters
a = 8000000.0  # 8000 km semi-major axis
e = 0.2  # moderate eccentricity
r_apo = bh.apoapsis_distance(a, e)
print(f"Apoapsis distance: {r_apo/1000:.2f} km")

# Using a batch of Keplerian element sets, one result per row
oe = [8000000.0, 0.2, np.radians(45), 0, 0, 0]
r_apo_rows = bh.apoapsis_distance(np.array([oe, oe]))
print(f"Apoapsis distance: (first row) {r_apo_rows[0]/1000:.2f} km")

periapsis_velocity builtin 

periapsis_velocity(a_or_oe: Union[float, array], e: Union[float, array] = None, *, gm: float) -> Union[float, ndarray]

Computes the periapsis velocity of an astronomical object around a general body.

Parameters:

Name Type Description Default
a_or_oe float or array

The semi-major axis in meters, as a scalar or an array evaluated element-wise (broadcast against e); or, when e is omitted, a 2-D array of shape (n, 6) of Keplerian element sets [a, e, i, Ω, ω, ν] from which a and e are taken row by row.

 required
e float or array

The eccentricity, broadcast against a_or_oe when either is an array. Required unless a_or_oe is a 2-D element-set batch, where it is ignored.

 None
gm float

(keyword-only) The standard gravitational parameter of primary body in m³/s².

 required

Returns:

Type Description
Union[float, ndarray]

float or numpy.ndarray: The magnitude of velocity of the object at periapsis in m/s. An array is returned for array input: shape (n,) for n element sets, or the broadcast shape for element-wise input.
Example 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import brahe as bh
import numpy as np

# Using scalar parameters
a = 5e11  # 5 AU semi-major axis (meters)
e = 0.95  # highly elliptical
v_peri = bh.periapsis_velocity(a, e, gm=bh.GM_SUN)
print(f"Periapsis velocity: {v_peri/1000:.2f} km/s")

# Using a batch of Keplerian element sets, one result per row
oe = [5e11, 0.95, np.radians(10), 0, 0, 0]
v_peri_rows = bh.periapsis_velocity(np.array([oe, oe]), gm=bh.GM_SUN)
print(f"Periapsis velocity: (first row) {v_peri_rows[0]/1000:.2f} km/s")

apoapsis_velocity builtin 

apoapsis_velocity(a_or_oe: Union[float, array], e: Union[float, array] = None, *, gm: float) -> Union[float, ndarray]

Computes the apoapsis velocity of an astronomical object around a general body.

Parameters:

Name Type Description Default
a_or_oe float or array

The semi-major axis in meters, as a scalar or an array evaluated element-wise (broadcast against e); or, when e is omitted, a 2-D array of shape (n, 6) of Keplerian element sets [a, e, i, Ω, ω, ν] from which a and e are taken row by row.

 required
e float or array

The eccentricity, broadcast against a_or_oe when either is an array. Required unless a_or_oe is a 2-D element-set batch, where it is ignored.

 None
gm float

(keyword-only) The standard gravitational parameter of primary body in m³/s².

 required

Returns:

Type Description
Union[float, ndarray]

float or numpy.ndarray: The magnitude of velocity of the object at apoapsis in m/s. An array is returned for array input: shape (n,) for n element sets, or the broadcast shape for element-wise input.
Example 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import brahe as bh
import numpy as np

# Using scalar parameters
a = 10000000.0  # 10000 km semi-major axis
e = 0.3
v_apo = bh.apoapsis_velocity(a, e, gm=bh.GM_MARS)
print(f"Apoapsis velocity: {v_apo/1000:.2f} km/s")

# Using a batch of Keplerian element sets, one result per row
oe = [10000000.0, 0.3, np.radians(30), 0, 0, 0]
v_apo_rows = bh.apoapsis_velocity(np.array([oe, oe]), gm=bh.GM_MARS)
print(f"Apoapsis velocity: (first row) {v_apo_rows[0]/1000:.2f} km/s")

perigee_velocity builtin 

perigee_velocity(a_or_oe: Union[float, array], e: Union[float, array] = None) -> Union[float, ndarray]

Computes the perigee velocity of an astronomical object around Earth.

Parameters:

Name Type Description Default
a_or_oe float or array

The semi-major axis in meters, as a scalar or an array evaluated element-wise (broadcast against e); or, when e is omitted, a 2-D array of shape (n, 6) of Keplerian element sets [a, e, i, Ω, ω, ν] from which a and e are taken row by row.

 required
e float or array

The eccentricity, broadcast against a_or_oe when either is an array. Required unless a_or_oe is a 2-D element-set batch, where it is ignored.

 None

Returns:

Type Description
Union[float, ndarray]

float or numpy.ndarray: The magnitude of velocity of the object at perigee in m/s. An array is returned for array input: shape (n,) for n element sets, or the broadcast shape for element-wise input.
Example 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import brahe as bh
import numpy as np

# Using scalar parameters
a = 26554000.0  # meters
e = 0.72  # high eccentricity
v_peri = bh.perigee_velocity(a, e)
print(f"Perigee velocity: {v_peri:.2f} m/s")

# Using a batch of Keplerian element sets, one result per row
oe = [26554000.0, 0.72, np.radians(63.4), 0, 0, 0]
v_peri_rows = bh.perigee_velocity(np.array([oe, oe]))
print(f"Perigee velocity: (first row) {v_peri_rows[0]:.2f} m/s")

apogee_velocity builtin 

apogee_velocity(a_or_oe: Union[float, array], e: Union[float, array] = None) -> Union[float, ndarray]

Computes the apogee velocity of an astronomical object around Earth.

Parameters:

Name Type Description Default
a_or_oe float or array

The semi-major axis in meters, as a scalar or an array evaluated element-wise (broadcast against e); or, when e is omitted, a 2-D array of shape (n, 6) of Keplerian element sets [a, e, i, Ω, ω, ν] from which a and e are taken row by row.

 required
e float or array

The eccentricity, broadcast against a_or_oe when either is an array. Required unless a_or_oe is a 2-D element-set batch, where it is ignored.

 None

Returns:

Type Description
Union[float, ndarray]

float or numpy.ndarray: The magnitude of velocity of the object at apogee in m/s. An array is returned for array input: shape (n,) for n element sets, or the broadcast shape for element-wise input.
Example 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import brahe as bh
import numpy as np

# Using scalar parameters
a = 24400000.0  # meters
e = 0.73  # high eccentricity
v_apo = bh.apogee_velocity(a, e)
print(f"Apogee velocity: {v_apo:.2f} m/s")

# Using a batch of Keplerian element sets, one result per row
oe = [24400000.0, 0.73, np.radians(7), 0, 0, 0]
v_apo_rows = bh.apogee_velocity(np.array([oe, oe]))
print(f"Apogee velocity: (first row) {v_apo_rows[0]:.2f} m/s")

sun_synchronous_inclination builtin 

sun_synchronous_inclination(a_or_oe: Union[float, array], e: Union[float, array] = None, *, angle_format: AngleFormat) -> Union[float, ndarray]

Computes the inclination for a Sun-synchronous orbit around Earth based on the J2 gravitational perturbation.

Parameters:

Name Type Description Default
a_or_oe float or array

The semi-major axis in meters, as a scalar or an array evaluated element-wise (broadcast against e); or, when e is omitted, a 2-D array of shape (n, 6) of Keplerian element sets [a, e, i, Ω, ω, ν] from which a and e are taken row by row.

 required
e float or array

The eccentricity, broadcast against a_or_oe when either is an array. Required unless a_or_oe is a 2-D element-set batch, where it is ignored.

 None
angle_format AngleFormat

(keyword-only) Return output in AngleFormat.DEGREES or AngleFormat.RADIANS.

 required

Returns:

Type Description
Union[float, ndarray]

float or numpy.ndarray: Inclination for a Sun synchronous orbit in degrees or radians. An array is returned for array input: shape (n,) for n element sets, or the broadcast shape for element-wise input.
Example 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import brahe as bh
import numpy as np

# Using scalar parameters
a = bh.R_EARTH + 600e3
e = 0.001  # nearly circular
inc = bh.sun_synchronous_inclination(a, e, angle_format=bh.AngleFormat.DEGREES)
print(f"Sun-synchronous inclination: {inc:.2f} degrees")

# Using a batch of Keplerian element sets, one result per row
oe = [bh.R_EARTH + 600e3, 0.001, np.radians(97.8), 0, 0, 0]
inc_rows = bh.sun_synchronous_inclination(np.array([oe, oe]), angle_format=bh.AngleFormat.DEGREES)
print(f"Sun-synchronous inclination: (first row) {inc_rows[0]:.2f} degrees")

geo_sma builtin 

geo_sma() -> float

Returns the geostationary orbit semi-major axis around Earth.

Returns:

Name Type Description
float float

The semi-major axis in meters.
Example 
1
2
3
import brahe as bh
a_geo = bh.geo_sma()
print(f"Geostationary semi-major axis: {a_geo/1000:.2f} km")

Anomaly Conversions

anomaly_eccentric_to_mean builtin 

anomaly_eccentric_to_mean(anm_ecc_or_oe: Union[float, array], e: Union[float, array] = None, *, angle_format: AngleFormat) -> Union[float, ndarray]

Converts eccentric anomaly into mean anomaly.

Parameters:

Name Type Description Default
anm_ecc_or_oe float or array

The eccentric anomaly, as a scalar or an array evaluated element-wise (broadcast against e); or, when e is omitted, a 2-D array of shape (n, 6) of Keplerian element sets [a, e, i, Ω, ω, M] from which e and the anomaly (index 5) are taken row by row. The anomaly must match the angle_format.

 required
e float or array

The eccentricity, broadcast against anm_ecc_or_oe when either is an array. Required unless anm_ecc_or_oe is a 2-D element-set batch, where it is ignored.

 None
angle_format AngleFormat

(keyword-only) Interprets input and returns output in AngleFormat.DEGREES or AngleFormat.RADIANS.

 required

Returns:

Type Description
Union[float, ndarray]

float or numpy.ndarray: Mean anomaly in radians or degrees. An array is returned for array input: shape (n,) for n element sets, or the broadcast shape for element-wise input.
Example 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import brahe as bh
import numpy as np

# Using scalar parameters
E = np.pi / 4  # 45 degrees eccentric anomaly
e = 0.1  # eccentricity
M = bh.anomaly_eccentric_to_mean(E, e, angle_format=bh.AngleFormat.RADIANS)
print(f"Mean anomaly: {M:.4f} radians")

# Using a batch of Keplerian element sets (eccentric anomaly at index 5), one result per row
oe = [bh.R_EARTH + 500e3, 0.1, np.radians(45), 0, 0, np.pi/4]
M_rows = bh.anomaly_eccentric_to_mean(np.array([oe, oe]), angle_format=bh.AngleFormat.RADIANS)
print(f"Mean anomaly: (first row) {M_rows[0]:.4f} radians")

anomaly_eccentric_to_true builtin 

anomaly_eccentric_to_true(anm_ecc_or_oe: Union[float, array], e: Union[float, array] = None, *, angle_format: AngleFormat) -> Union[float, ndarray]

Converts eccentric anomaly into true anomaly.

Parameters:

Name Type Description Default
anm_ecc_or_oe float or array

The eccentric anomaly, as a scalar or an array evaluated element-wise (broadcast against e); or, when e is omitted, a 2-D array of shape (n, 6) of Keplerian element sets [a, e, i, Ω, ω, M] from which e and the anomaly (index 5) are taken row by row. The anomaly must match the angle_format.

 required
e float or array

The eccentricity, broadcast against anm_ecc_or_oe when either is an array. Required unless anm_ecc_or_oe is a 2-D element-set batch, where it is ignored.

 None
angle_format AngleFormat

(keyword-only) Interprets input and returns output in AngleFormat.DEGREES or AngleFormat.RADIANS.

 required

Returns:

Type Description
Union[float, ndarray]

float or numpy.ndarray: True anomaly in radians or degrees. An array is returned for array input: shape (n,) for n element sets, or the broadcast shape for element-wise input.
Example 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import brahe as bh
import numpy as np

# Using scalar parameters
E = np.pi / 4  # 45 degrees eccentric anomaly
e = 0.4  # eccentricity
nu = bh.anomaly_eccentric_to_true(E, e, angle_format=bh.AngleFormat.RADIANS)
print(f"True anomaly: {nu:.4f} radians")

# Using a batch of Keplerian element sets (eccentric anomaly at index 5), one result per row
oe = [bh.R_EARTH + 500e3, 0.4, np.radians(45), 0, 0, np.pi/4]
nu_rows = bh.anomaly_eccentric_to_true(np.array([oe, oe]), angle_format=bh.AngleFormat.RADIANS)
print(f"True anomaly: (first row) {nu_rows[0]:.4f} radians")

anomaly_mean_to_eccentric builtin 

anomaly_mean_to_eccentric(anm_mean_or_oe: Union[float, array], e: Union[float, array] = None, *, angle_format: AngleFormat) -> Union[float, ndarray]

Converts mean anomaly into eccentric anomaly.

Parameters:

Name Type Description Default
anm_mean_or_oe float or array

The mean anomaly, as a scalar or an array evaluated element-wise (broadcast against e); or, when e is omitted, a 2-D array of shape (n, 6) of Keplerian element sets [a, e, i, Ω, ω, M] from which e and the anomaly (index 5) are taken row by row. The anomaly must match the angle_format.

 required
e float or array

The eccentricity, broadcast against anm_mean_or_oe when either is an array. Required unless anm_mean_or_oe is a 2-D element-set batch, where it is ignored.

 None
angle_format AngleFormat

(keyword-only) Interprets input and returns output in AngleFormat.DEGREES or AngleFormat.RADIANS.

 required

Returns:

Type Description
Union[float, ndarray]

float or numpy.ndarray: Eccentric anomaly in radians or degrees. An array is returned for array input: shape (n,) for n element sets, or the broadcast shape for element-wise input.
Example 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import brahe as bh
import numpy as np

# Using scalar parameters
M = 1.5  # mean anomaly in radians
e = 0.3  # eccentricity
E = bh.anomaly_mean_to_eccentric(M, e, angle_format=bh.AngleFormat.RADIANS)
print(f"Eccentric anomaly: {E:.4f} radians")

# Using a batch of Keplerian element sets (mean anomaly at index 5), one result per row
oe = [bh.R_EARTH + 500e3, 0.3, np.radians(45), 0, 0, 1.5]
E_rows = bh.anomaly_mean_to_eccentric(np.array([oe, oe]), angle_format=bh.AngleFormat.RADIANS)
print(f"Eccentric anomaly: (first row) {E_rows[0]:.4f} radians")

anomaly_mean_to_true builtin 

anomaly_mean_to_true(anm_mean_or_oe: Union[float, array], e: Union[float, array] = None, *, angle_format: AngleFormat) -> Union[float, ndarray]

Converts mean anomaly into true anomaly.

Parameters:

Name Type Description Default
anm_mean_or_oe float or array

The mean anomaly, as a scalar or an array evaluated element-wise (broadcast against e); or, when e is omitted, a 2-D array of shape (n, 6) of Keplerian element sets [a, e, i, Ω, ω, M] from which e and the anomaly (index 5) are taken row by row. The anomaly must match the angle_format.

 required
e float or array

The eccentricity, broadcast against anm_mean_or_oe when either is an array. Required unless anm_mean_or_oe is a 2-D element-set batch, where it is ignored.

 None
angle_format AngleFormat

(keyword-only) Interprets input and returns output in AngleFormat.DEGREES or AngleFormat.RADIANS.

 required

Returns:

Type Description
Union[float, ndarray]

float or numpy.ndarray: True anomaly in radians or degrees. An array is returned for array input: shape (n,) for n element sets, or the broadcast shape for element-wise input.
Example 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import brahe as bh
import numpy as np

# Using scalar parameters
M = 2.0  # mean anomaly in radians
e = 0.25  # eccentricity
nu = bh.anomaly_mean_to_true(M, e, angle_format=bh.AngleFormat.RADIANS)
print(f"True anomaly: {nu:.4f} radians")

# Using a batch of Keplerian element sets (mean anomaly at index 5), one result per row
oe = [bh.R_EARTH + 500e3, 0.25, np.radians(45), 0, 0, 2.0]
nu_rows = bh.anomaly_mean_to_true(np.array([oe, oe]), angle_format=bh.AngleFormat.RADIANS)
print(f"True anomaly: (first row) {nu_rows[0]:.4f} radians")

anomaly_true_to_eccentric builtin 

anomaly_true_to_eccentric(anm_true_or_oe: Union[float, array], e: Union[float, array] = None, *, angle_format: AngleFormat) -> Union[float, ndarray]

Converts true anomaly into eccentric anomaly.

Parameters:

Name Type Description Default
anm_true_or_oe float or array

The true anomaly, as a scalar or an array evaluated element-wise (broadcast against e); or, when e is omitted, a 2-D array of shape (n, 6) of Keplerian element sets [a, e, i, Ω, ω, M] from which e and the anomaly (index 5) are taken row by row. The anomaly must match the angle_format.

 required
e float or array

The eccentricity, broadcast against anm_true_or_oe when either is an array. Required unless anm_true_or_oe is a 2-D element-set batch, where it is ignored.

 None
angle_format AngleFormat

(keyword-only) Interprets input and returns output in AngleFormat.DEGREES or AngleFormat.RADIANS.

 required

Returns:

Type Description
Union[float, ndarray]

float or numpy.ndarray: Eccentric anomaly in radians or degrees. An array is returned for array input: shape (n,) for n element sets, or the broadcast shape for element-wise input.
Example 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import brahe as bh
import numpy as np

# Using scalar parameters
nu = np.pi / 3  # 60 degrees true anomaly
e = 0.2  # eccentricity
E = bh.anomaly_true_to_eccentric(nu, e, angle_format=bh.AngleFormat.RADIANS)
print(f"Eccentric anomaly: {E:.4f} radians")

# Using a batch of Keplerian element sets (true anomaly at index 5), one result per row
oe = [bh.R_EARTH + 500e3, 0.2, np.radians(45), 0, 0, np.pi/3]
E_rows = bh.anomaly_true_to_eccentric(np.array([oe, oe]), angle_format=bh.AngleFormat.RADIANS)
print(f"Eccentric anomaly: (first row) {E_rows[0]:.4f} radians")

anomaly_true_to_mean builtin 

anomaly_true_to_mean(anm_true_or_oe: Union[float, array], e: Union[float, array] = None, *, angle_format: AngleFormat) -> Union[float, ndarray]

Converts true anomaly into mean anomaly.

Parameters:

Name Type Description Default
anm_true_or_oe float or array

The true anomaly, as a scalar or an array evaluated element-wise (broadcast against e); or, when e is omitted, a 2-D array of shape (n, 6) of Keplerian element sets [a, e, i, Ω, ω, M] from which e and the anomaly (index 5) are taken row by row. The anomaly must match the angle_format.

 required
e float or array

The eccentricity, broadcast against anm_true_or_oe when either is an array. Required unless anm_true_or_oe is a 2-D element-set batch, where it is ignored.

 None
angle_format AngleFormat

(keyword-only) Interprets input and returns output in AngleFormat.DEGREES or AngleFormat.RADIANS.

 required

Returns:

Type Description
Union[float, ndarray]

float or numpy.ndarray: Mean anomaly in radians or degrees. An array is returned for array input: shape (n,) for n element sets, or the broadcast shape for element-wise input.
Example 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import brahe as bh
import numpy as np

# Using scalar parameters
nu = np.pi / 2  # 90 degrees true anomaly
e = 0.15  # eccentricity
M = bh.anomaly_true_to_mean(nu, e, angle_format=bh.AngleFormat.RADIANS)
print(f"Mean anomaly: {M:.4f} radians")

# Using a batch of Keplerian element sets (true anomaly at index 5), one result per row
oe = [bh.R_EARTH + 500e3, 0.15, np.radians(45), 0, 0, np.pi/2]
M_rows = bh.anomaly_true_to_mean(np.array([oe, oe]), angle_format=bh.AngleFormat.RADIANS)
print(f"Mean anomaly: (first row) {M_rows[0]:.4f} radians")