Mit pyephem berechnen, wann ein Satellit eine Länge kreuzt

Question

Ich habe es schwer herauszufinden, wie man berechnet, wenn ein Satellit eine bestimmte Länge durchquert. Es wäre schön, in der Lage zu sein, eine Zeitperiode und eine TLE bereitzustellen und in der Lage zu sein, alle Zeiten zurückzugeben, zu denen der Satellit eine gegebene Länge während der spezifizierten Zeitperiode kreuzt. Unterstützt pyephem so etwas?

Answer 1

Es gibt so viele mögliche Umstände, nach denen Benutzer fragen könnten - wenn ein Satellit eine bestimmte Länge kreuzt; wenn es einen bestimmten Breitengrad erreicht; wenn es eine bestimmte Höhe erreicht oder auf seine niedrigste Höhe absinkt; wenn seine Geschwindigkeit am größten oder am wenigsten ist - dass PyEphem nicht versucht, für alle von ihnen integrierte Funktionen bereitzustellen. Stattdessen bietet es eine newton()-Funktion, mit der Sie den Nulldurchgang eines Vergleichs finden können, den Sie zwischen einem Satellitenattribut und einem vorbestimmten Wert des Attributs, nach dem Sie suchen möchten, vornehmen möchten.

Beachten Sie, dass die SciPy Python-Bibliothek mehr sehr vorsichtig Suchfunktionen enthält, die viel anspruchsvoller sind als PyEphem des newton() Funktion, falls Sie mit einer besonders schlecht erzogene Funktion handeln:

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

Hier Wie könnte man suchen, wenn ein Satellit - in diesem Beispiel die ISS - eine bestimmte Länge durchläuft, um die allgemeine Technik zu zeigen. Dies ist nicht der schnellste Weg - die minutengenaue Suche könnte insbesondere beschleunigt werden, wenn wir sehr vorsichtig wären - aber es ist sehr allgemein und sehr sicher geschrieben, falls es außer dem Längengrad noch andere Werte gibt Sie möchten auch suchen. Ich habe versucht, Dokumentation und Kommentare hinzuzufügen, um zu erklären, was vor sich geht, und warum ich znorm verwende, anstatt den einfachen Unterschied zurückzugeben. Lassen Sie mich wissen, ob dieses Skript für Sie funktioniert, und erklärt seine Vorgehensweise klar genug!

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 

Die Ausgabe, die ich beim Laufen dieses Skript legt nahe, dass es in der Tat in dem Moment (innerhalb einer angemessenen Toleranz) gefunden hat, wenn die ISS die Ziel Länge erreicht:

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