¿Cómo calcular el ángulo de trayectoria de vuelo, γ, a partir de un vector de estado?

La excelente respuesta de @Julio describe un ángulo de trayectoria de vuelo y explica que es el ángulo entre la dirección tangencial (perpendicular al vector radial al cuerpo central) y el vector de velocidad actual.

Primero intenté obtener el ángulo de esta expresión, pero obviamente es incorrecto, ya que arccos es una función par y el ángulo puede ir de π / 2 a π / 2 :

arccos ( r v | r |   | v | ) π 2        (¡incorrecto!)

He integrado órbitas para GM ( m ) y SMA ( a ) de la unidad y distancias iniciales de 0,2 a 1,8. Eso hace que el período siempre 2 π . Cuando trazo el resultado de mi función, obtengo demasiados cambios.

¿Qué expresión puedo usar para obtener el ángulo gamma correcto de la ruta de vuelo a partir de los vectores de estado?

Se agradecería Python revisado por la parte errónea, pero ciertamente no es necesario para una respuesta.

parcelas de órbita

def deriv(X, t):
    x, v = X.reshape(2, -1)
    acc = -x * ((x**2).sum())**-1.5
    return np.hstack((v, acc))

import numpy as np
import matplotlib.pyplot as plt
from scipy.integrate import odeint as ODEint

halfpi, pi, twopi = [f*np.pi for f in (0.5, 1, 2)]

T    = twopi
time = np.linspace(0, twopi, 201)

a       = 1.0
rstarts = 0.2 * np.arange(1, 10)
vstarts = np.sqrt(2./rstarts - 1./a)  # from vis-viva equation

answers = []
for r, v in zip(rstarts, vstarts):
    X0 = np.array([r, 0, 0, v])
    answer, info = ODEint(deriv, X0, time, full_output= True)
    answers.append(answer.T)

gammas = []
for a in answers:
    xx, vv = a.reshape(2, 2, -1)
    dotted = ((xx*vv)**2).sum(axis=0)
    rabs, vabs = [np.sqrt((thing**2).sum(axis=0)) for thing in (xx, vv)]
    gamma = np.arccos(dotted/(rabs*vabs)) - halfpi
    gammas.append(gamma)

if True:

    plt.figure()
    plt.subplot(4, 1, 1)
    for x, y, vx, vy in answers:
        plt.plot(x, y)
        plt.plot(x[:1], y[:1], '.k')
    plt.plot([0], [0], 'ok')
    plt.title('y vs x')

    plt.subplot(4, 1, 2)
    for x, y, vx, vy in answers:
        plt.plot(time, x, '-b')
        plt.plot(time, y, '--r')
    plt.title('x (blue) y (red, dashed)')
    plt.xlim(0, twopi)

    plt.subplot(4, 1, 3)
    for x, y, vx, vy in answers:
        plt.plot(time, vx, '-b')
        plt.plot(time, vy, '--r')
    plt.title('vx (blue) vy (red), dashed')
    plt.xlim(0, twopi)

    plt.subplot(4, 1, 4)
    for gamma in gammas:
        plt.plot(time, gamma)
    plt.title('gamma?')
    plt.xlim(0, twopi)

    plt.show()
si esta pregunta debe ser TLDRed para indicar que fue un error de codificación, ya que todavía parece preguntar qué está mal con la fórmula

Respuestas (2)

Este es un problema que ha afectado a grupos de personas muy conocedoras de la dinámica orbital pero que aprendieron usando diferentes libros de texto: ¡hay dos definiciones diferentes de "ángulo de trayectoria de vuelo"!

Además de γ , el ángulo entre la dirección tangencial y el vector velocidad, hay β , el ángulo entre la dirección radial y el vector velocidad. La gente a menudo dice "ángulo de trayectoria de vuelo" sin decir qué definición están usando . ¡Confuso! (Acabo de notar que el diagrama en la respuesta de Julio también muestra β )

si trabajas con β en lugar de γ , β es dado por

(1) arccos ( r v | r |   | v | )

que va de 0 ("hacia arriba") a π ("hacia abajo"). Usando γ , "hacia arriba" es π / 2 y "hacia abajo" es π / 2 , por lo que convertir β a γ solo restas β de π / 2 :

(2) γ = π / 2 arccos ( r v | r |   | v | )

Esto es equivalente a

(3) γ = arcsen ( r v | r |   | v | )

No estoy familiarizado con el lenguaje que usó para sus cálculos y gráficos, por lo que no he mirado su algoritmo para ver por qué hay "demasiadas oscilaciones".

¡Gracias! He agregado etiquetas (números) a las ecuaciones. ¿Diría que hay demasiados movimientos, o ese comportamiento de movimiento es de hecho razonable? Desde tu β (eq 1) es lo mismo que mi erróneo γ excepto por una compensación de medio pi, entonces las ondulaciones en mi gráfico deberían ser las mismas que las de un gráfico adecuado de su β (ecuación 1).
A mí me parecen demasiadas travesuras. Lo comprobaré más tarde.
@uhoh, en realidad, mi eq 1 es solo el negativo de tu ecuación. Algo más está mal. Por supuesto que sabes que algo anda mal porque todo lo trazado γ s son negativos o cero, lo que no puede ser excepto por una espiral hacia adentro. Para una órbita excéntrica Kepleriana γ debe cruzar cero exactamente dos veces, en el periapsis y en la apoapsis, y ser monótono entre los extremos, tanto para el segmento corto (extremo a través del periapsis al otro extremo) como largo (extremo a través de la apoapsis al otro extremo). Veré si puedo dibujar un ejemplo de lo que γ debería verse la curva.
@uhoh, Oh, sí: de hecho, demasiados movimientos. A eso se refiere el "monótono". De alguna manera el γ se arruinó el cálculo. Verifique para asegurarse de que el argumento de los arccos es lo que pretende que sea.
Bien gracias. Espero que alguien sea capaz de averiguar qué está realmente mal. Puede resultar ser yo, volveré a esto más tarde hoy.
Vaya, debería haber dicho anteriormente: "Mi ecuación 2 es solo el negativo de la tuya". ¡Debería desconectarme e irme a la cama!
¡Gracias por toda tu ayuda! Encontré el error , además tengo una mejor comprensión de β y γ .
Lo he citado aquí , eche un vistazo y vea si lo he hecho bien, o si tiene más para agregar. ¡Gracias!
@uhoh "tangencial" a una esfera centrada en el primario, no en la órbita. Personalmente, preferiría decir "velocidad lateral", pero mi primer profesor de Orbital Dynamics en Stanford usó "tangencial".
Eso es lo que he estado empezando a sospechar .

Encontré el error en el script, se debió a mi producto de punto "homebrew". Tuve un cuadrado extra:

dotted = ((xx*vv)**2).sum(axis=0)     # WRONG

dotted = (xx*vv).sum(axis=0)          # Correct

Entonces, usando esto más las excelentes aclaraciones de @TomSpilker, he usado los siguientes dos métodos para calcular gamma:

Método 1:

(3) γ 1 = arcsen ( r v | r |   | v | )

Método 2:

Un método alternativo de fuerza bruta para verificar dos veces:

θ r = arcán 2 ( y , X )

θ v = arcán 2 ( v y , X )

θ t a norte j = θ r + π 2

γ 2 = θ t a norte j θ v

γ 2 metro o d = modificación ( γ 2 + π , 2 π ) π

La operación de módulo solo es realmente necesaria en el programa de computadora, ya que cada theta proviene de una operación arctan2 separada:

ingrese la descripción de la imagen aquí

gammas_1, gammas_2 = [], []
for a in answers:

    xx, vv = a.reshape(2, 2, -1)

    dotted = (xx*vv).sum(axis=0)
    rabs, vabs = [np.sqrt((thing**2).sum(axis=0)) for thing in (xx, vv)]
    gamma_1 = np.arcsin(dotted/(rabs*vabs))   # Per Tom Spilker's answer Eq. 3

    theta_r = np.arctan2(xx[1], xx[0])
    theta_v = np.arctan2(vv[1], vv[0])
    theta_tanj = theta_r + halfpi

    gamma_2 = theta_tanj - theta_v
    gamma_2 = np.mod(gamma_2 + pi, twopi) - pi

    gammas_1.append(gamma_1)
    gammas_2.append(gamma_2)

plt.figure()
plt.subplot(2, 1, 1)
for gamma_1 in gammas_1:
    plt.plot(time, gamma_1)
plt.title('gammas_1', fontsize=16)

plt.subplot(2, 1, 2)
for gamma_2 in gammas_2:
    plt.plot(time, gamma_2)
plt.title('gammas_2', fontsize=16)
Efectivamente el nuevo γ La trama es lo que esperaba. ¡Hurra! Buena investigación.