Utilizzo di pyephem per calcolare quando un satellite attraversa una longitudine

Question

Ho difficoltà a capire come calcolare quando un satellite attraversa una specifica longitudine. Sarebbe bello poter fornire un periodo di tempo e un TLE ed essere in grado di restituire tutte le volte in cui il satellite attraversa una determinata longitudine durante il periodo di tempo specificato. Pyephem supporta qualcosa del genere?

Answer 1

Ci sono così tante possibili circostanze che gli utenti potrebbero chiedere - quando un satellite attraversa una specifica longitudine; quando raggiunge una latitudine specifica; quando raggiunge una certa altezza o scende alla sua minima altezza; quando la sua velocità è maggiore o minore, PyEphem non tenta di fornire funzioni integrate per tutti loro. Invece, fornisce una funzione newton() che ti consente di trovare lo zero-crossing del confronto che vuoi fare tra un attributo satellite e un valore predeterminato di quell'attributo che vuoi cercare.

Nota che la libreria SciPy Python contiene diverse funzioni di ricerca molto attenti che sono molto più sofisticati rispetto a funzione di PyEphem newton(), nel caso in cui si tratta di una funzione particolarmente mal-educati:

http://docs.scipy.org/doc/scipy/reference/optimize.html

Ecco come puoi cercare quando un satellite - in questo esempio, la ISS - passa una particolare longitudine, per mostrare la tecnica generale. Questo non è l'approccio più rapido possibile - la ricerca minuto per minuto, in particolare, potrebbe essere accelerata se siamo molto attenti - ma è scritto per essere molto generale e molto sicuro, nel caso in cui ci siano altri valori oltre alla longitudine che vuoi anche cercare. Ho provato ad aggiungere documentazione e commenti per spiegare cosa sta succedendo e perché uso znorm invece di restituire la semplice differenza. Fammi sapere se questo script funziona per te e spiega il suo approccio in modo abbastanza chiaro!

import ephem 

line0 = 'ISS (ZARYA)    ' 
line1 = '1 25544U 98067A 13110.27262069 .00008419 00000-0 14271-3 0 6447' 
line2 = '2 25544 51.6474 35.7007 0010356 160.4171 304.1803 15.52381363825715' 

sat = ephem.readtle(line0, line1, line2) 
target_long = ephem.degrees('-83.8889') 

def longitude_difference(t): 
    '''Return how far the satellite is from the target longitude. 

    Note carefully that this function does not simply return the 
    difference of the two longitudes, since that would produce a 
    terrible jagged discontinuity from 2pi to 0 when the satellite 
    crosses from -180 to 180 degrees longitude, which could happen to be 
    a point close to the target longitude. So after computing the 
    difference in the two angles we run degrees.znorm on it, so that the 
    result is smooth around the point of zero difference, and the 
    discontinuity sits as far away from the target position as possible. 

    ''' 
    sat.compute(t) 
    return ephem.degrees(sat.sublong - target_long).znorm 

t = ephem.date('2013/4/20') 

# How did I know to make jumps by minute here? I experimented: a 
# `print` statement in the loop showing the difference showed huge jumps 
# when looping by a day or hour at a time, but minute-by-minute results 
# were small enough steps to bring the satellite gradually closer to the 
# target longitude at a rate slow enough that we could stop near it. 
# 
# The direction that the ISS travels makes the longitude difference 
# increase with time; `print` statements at one-minute increments show a 
# series like this: 
# 
# -25:16:40.9 
# -19:47:17.3 
# -14:03:34.0 
# -8:09:21.0 
# -2:09:27.0 
# 3:50:44.9 
# 9:45:50.0 
# 15:30:54.7 
# 
# So the first `while` loop detects if we are in the rising, positive 
# region of this negative-positive pattern and skips the positive 
# region, since if the difference is positive then the ISS has already 
# passed the target longitude and is on its way around the rest of 
# the planet. 

d = longitude_difference(t) 

while d > 0: 
    t += ephem.minute 
    sat.compute(t) 
    d = longitude_difference(t) 

# We now know that we are on the negative-valued portion of the cycle, 
# and that the ISS is closing in on our longitude. So we keep going 
# only as long as the difference is negative, since once it jumps to 
# positive the ISS has passed the target longitude, as in the sample 
# data series above when the difference goes from -2:09:27.0 to 
# 3:50:44.9. 

while d < 0: 
    t += ephem.minute 
    sat.compute(t) 
    d = longitude_difference(t) 

# We are now sitting at a point in time when the ISS has just passed the 
# target longitude. The znorm of the longitude difference ought to be a 
# gently sloping zero-crossing curve in this region, so it should be 
# safe to set Newton's method to work on it! 

tn = ephem.newton(longitude_difference, t - ephem.minute, t) 

# This should be the answer! So we print it, and also double-check 
# ourselves by printing the longitude to see how closely it matches. 

print 'When did ISS cross this longitude?', target_long 
print 'At this specific date and time:', ephem.date(tn) 

sat.compute(tn) 

print 'To double-check, at that time, sublong =', sat.sublong 

L'output che ottengo quando si esegue lo script suggerisce che essa ha infatti trovato il momento (entro la tolleranza ragionevole) quando l'ISS raggiunge la longitudine di destinazione:

When did ISS cross this longitude? -83:53:20.0 
At this specific date and time: 2013/4/20 00:18:21 
To double-check, at that time, sublong = -83:53:20.1