Gravitacijska frača

Eden izmed najbolj uporabnih manevrov v astrofiziki je tako imenovana gravitacijska frača, kjer lahko telo ob obletu nekega drugega telesa prevzame njegovo energijo v obliki kinetične energije. Da si problem poenostavimo, predpostavimo, da je telo, ki ga bomo obleteli, zelo bolj masivno od našega telesa (recimo planet) - v relativnem sistemu se bomo torej gibali po stožnici. V teoriji, če se telesu približujemo po elipsi lahko dosežemo, da svoji hitrosti prištejemo hitrost planeta:

da pridemo v relativni sistem moramo odšteti hitrost planeta,
upoštevamo gibanje po stožnici in ustrezno spremenimo relativno hitrost na nasprotni strani,
po preletu prištejemo hitrost planeta.

Kljub temu, da seveda ne želimo, da je telo vezano (ima $e<1$ ) je možno ekscentričnost spreminjati z raketnim pogonom (kot si bomo pogledali kasneje). Podobno smo na primer opazili komete, ki so pri preletu Sonca nevezani (imajo $e>1$ ) po preletu pa zaradi odmetavanja materiala ponovno postanejo vezani.

from simulatorv2 import *
import numpy as np

def setup_orbit(
    e,
    theta=np.pi * 0.9,
    rp=1.0,
    sun_velocity=Vec2.zero()
):
    sun = Presets.sun(Vec2)
    earth = Presets.earth(Vec2)

    G = NewtonianGravity().G
    mu = G * (sun.mass + earth.mass)

    p = rp * (1 + e)

    r = p / (1 + e * np.cos(theta))

    earth.position = Vec2(
        r * np.cos(theta),
        r * np.sin(theta)
    )

    h = np.sqrt(mu * p)

    vr = mu / h * e * np.sin(theta)
    vt = h / r

    er = Vec2(np.cos(theta), np.sin(theta))
    et = Vec2(-np.sin(theta), np.cos(theta))

    earth.velocity = vr * er + vt * et

    sun.velocity = sun_velocity.copy()
    earth.velocity += sun_velocity

    return sun, earth

results=[]
references=[]

for e, c in zip([0, 0.5, 1.0, 1.5], ["blue", "orange", "green", "red"]):
    sun, earth = setup_orbit(e=e, theta=-np.pi * 0.5, sun_velocity=Vec2(-4,0))
    
    sim = Simulator(
        bodies=[sun, earth],
        timestep=0.001,
        steps=643,
        diagnostics=[
            KineticEnergy(),
            TotalEnergy()
        ]
    )
    results.append(sim.run(name=e, run_color=c))
    references.append(ReferenceConic(e, opacity=0.5, follow_body="Sonce", t_0=-np.pi*0.5, t_1=np.pi*0.5))

viewer = SimulationViewer(
    results,
    ViewerConfig(
        fixed_center=(0, 0),
        trail_length=1000,
        view_size=2.5,
        references=references,
        diagnostics=[
            DiagnosticView(
                "Kinetična Energija",
                ["Zemlja"]
            ),
            DiagnosticView(
                "Celotna Energija",
                ["Zemlja"]
            ),
        ],
    )
)

viewer.show()

Oblet Venere¶

Da si malo bolj predstavljamo kako gravitacijska frača vpliva na gibanje telesa (rakete), rešimo nalogo Oblet Venere iz vaj predmeta Naša in druga Osončja. Satelit pošljemo proti Veneri iz Zemljine orbite. Srečanje se zgodi pri pravi anomaliji $\Theta_V = -50\ ^\circ$ . Satelit po hiperbolični orbiti na razdalji $300\ \text{km}$ potuje mimo Venere, zanima pa nas razlika v končni orbiti med primerom ko satelit Venero obleti po osvetljeni in po temni strani.

Prvo dobimo pozicijo Venere ob preletu, tako da uporabimo enačbo elipse v polarni obliki z enim od gorišč v izhodišču:

\begin{aligned} r(\Theta) &= \frac{a(1 - e^2)}{1 - e\cos(\Theta)}\to a(1 + e) = r_Z = 1,\\ r_V &= \frac{a(1-e)(1+e)}{1 - e\cos\Theta_V} = \frac{r_Z(1 - e)}{1 - e\cos\Theta_V}\to e=\frac{1 - \frac{r_V}{r_Z}}{1 - \frac{r_V}{r_Z}\cos\Theta_V} = 0.5175. \end{aligned}

from simulatorv2 import *
import numpy as np

referenceCircle = ReferenceConic(
    eccentricity=0,
    opacity=0.1,
    apoapsis=0.723,
    n=10000
)

sun = Presets.sun(Vec2)
venus = Presets.venus(Vec2)

"""
satellite = Body(
    name="Satelit",
    mass=500 / Units.SUN_MASS,
    radius=1e-6,
    color=(0,0,255),
    position=Vec2(1,0),
    velocity=referenceEllipse.velocityAtAngle(np.pi)
)
"""

initialize_binary(
    venus,
    sun,
    body1_position=Vec2(0.723, 0),
    center_position=Vec2.zero()
)

sim = Simulator(
    bodies=[sun, venus],
    timestep=0.0002,
    steps=2500
)
result = sim.run()

viewer = SimulationViewer(
    result,
    ViewerConfig(
        camera_mode="follow",
        follow_body="Venera",
        view_size=0.0001,
        references=[
            referenceCircle
        ]
    )
)

viewer.show()