brahe 1.5.2

Brahe is a modern satellite dynamics library for research and engineering applications designed to be easy-to-learn, high-performance, and quick-to-deploy. The north-star of the development is enabling users to solve meaningful problems and answer questions quickly, easily, and correctly.
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

"""
Python (Brahe) function-level force-model acceleration benchmarks.

Each task repeatedly evaluates a single acceleration term at a fixed state.
This isolates the force-model code from the propagator/integrator.
"""

import numpy as np

import brahe

from benchmarks.comparative.implementations.python.base import (
    ensure_eop,
    time_iterations,
)
from benchmarks.comparative.results import TaskResult


def _epoch_and_state(params: dict) -> tuple[brahe.Epoch, np.ndarray]:
    epc = brahe.Epoch.from_jd(params["jd"], brahe.TimeSystem.UTC)
    state = np.array(params["state_eci"])
    return epc, state


def _result(task_name: str, iterations: int, times, results) -> TaskResult:
    return TaskResult(
        task_name=task_name,
        language="python",
        library="brahe",
        iterations=iterations,
        times_seconds=times,
        results=results,
        metadata={
            "library": "brahe",
            "language": "python",
            "version": getattr(brahe, "__version__", "unknown"),
        },
    )


def accel_point_mass_gravity(params: dict, iterations: int) -> TaskResult:
    """Evaluate central-body point-mass gravity acceleration."""
    ensure_eop()
    _, state = _epoch_and_state(params)
    r = state[:3]
    r_cb = np.zeros(3)
    n_samples = params["n_samples"]

    def run():
        a = None
        for _ in range(n_samples):
            a = brahe.accel_point_mass_gravity(r, r_cb, brahe.GM_EARTH)
        # Return acceleration as the result so it can be compared across libraries.
        return [a.tolist()]

    times, results = time_iterations(run, iterations)
    return _result("force_model.accel_point_mass_gravity", iterations, times, results)


def _accel_spherical_harmonics(
    task_name: str, params: dict, iterations: int
) -> TaskResult:
    ensure_eop()
    epc, state = _epoch_and_state(params)
    r = state[:3]
    n = params["degree"]
    m = params["order"]
    n_samples = params["n_samples"]

    gravity_model = brahe.GravityModel.from_model_type(
        brahe.GravityModelType.EGM2008_360
    )

    def run():
        a = None
        for _ in range(n_samples):
            rot = brahe.rotation_eci_to_ecef(epc)
            a = brahe.accel_gravity_spherical_harmonics(r, rot, gravity_model, n, m)
        return [a.tolist()]

    times, results = time_iterations(run, iterations)
    return _result(task_name, iterations, times, results)


def accel_spherical_harmonics_20(params: dict, iterations: int) -> TaskResult:
    return _accel_spherical_harmonics(
        "force_model.accel_spherical_harmonics_20", params, iterations
    )


def accel_spherical_harmonics_80(params: dict, iterations: int) -> TaskResult:
    return _accel_spherical_harmonics(
        "force_model.accel_spherical_harmonics_80", params, iterations
    )


def accel_third_body_sun(params: dict, iterations: int) -> TaskResult:
    """Evaluate Sun third-body acceleration using DE440s ephemeris."""
    ensure_eop()
    epc, state = _epoch_and_state(params)
    r = state[:3]
    n_samples = params["n_samples"]

    def run():
        a = None
        for _ in range(n_samples):
            a = brahe.accel_third_body_sun_de(epc, r, brahe.EphemerisSource.DE440s)
        return [a.tolist()]

    times, results = time_iterations(run, iterations)
    return _result("force_model.accel_third_body_sun", iterations, times, results)


def accel_third_body_moon(params: dict, iterations: int) -> TaskResult:
    """Evaluate Moon third-body acceleration using DE440s ephemeris."""
    ensure_eop()
    epc, state = _epoch_and_state(params)
    r = state[:3]
    n_samples = params["n_samples"]

    def run():
        a = None
        for _ in range(n_samples):
            a = brahe.accel_third_body_moon_de(epc, r, brahe.EphemerisSource.DE440s)
        return [a.tolist()]

    times, results = time_iterations(run, iterations)
    return _result("force_model.accel_third_body_moon", iterations, times, results)