How to derive latitude and longitude based on altitude, azimuth and distance towards a geo satelite?

[TimVonsee]

Hello,

I'd like to know if it's possible to derive the latitude and longitude based on altitude, azimuth and distance towards a geostationary satellite. My current attempt is way off;

# fetch TLE
stations_url = 'https://celestrak.org/NORAD/elements/gp.php?GROUP=geo&FORMAT=tle'
satellites = load.tle_file(stations_url)
by_name = {sat.name: sat for sat in satellites}

# specify geostationary sat.
sat_tle = by_name['ALPHASAT']

ts = load.timescale()
t_now = ts.now()

# compute alt and az between earth station and sat
original_lon, original_lat = +48.8566, +2.3522
earth_station = wgs84.latlon(original_lat, original_lon)

difference = sat_tle - earth_station
topocentric = difference.at(t_now)

alt, az, distance = topocentric.altaz()

# Use computed alt, az and distance to derive lat and lon
# Taken from: https://rhodesmill.org/skyfield/coordinates.html#turning-coordinates-into-a-position
b = earth_station.at(t_now)
apparent = b.from_altaz(alt=alt, az=az, distance=distance)
ra, dec, d = apparent.radec()

position = Apparent.from_radec(ra_hours=ra.hours, dec_degrees=dec.degrees)
lat, lon, distance = position.frame_latlon(galactic_frame)

print('original:', original_lon, original_lat)
print('new:', lon, lat)

Any help or suggested different approach would be greatly appreciated.

[brandon-rhodes]

Are you trying to determine the latitude and longitude of the ground station performing the observation? Or the latitude and longitude sitting below the satellite?

[TimVonsee]

Thanks for the quick reply. I'm trying to achieve the first. In this code snippet, I was expecting to get back the original longitude and latitude (+48.8566, +2.3522).

[brandon-rhodes]

I have not yet had time to take a closer look, but I am certain that one problem here is the use of galactic_frame—the numbers you are getting back will be galactic coordinates, relative to the plane and center of our galaxy.

https://en.wikipedia.org/wiki/Galactic_coordinate_system

[psbaltar]

b = earth_station.at(t_now)
apparent = b.from_altaz(alt=alt, az=az, distance=distance)

position = sat_tle.at(t_now)-apparent

lat, lon, distance = position.frame_latlon(itrs)

produces

original: 48.8566 2.3522
new: 48.856599999999936 2.3364709892536357

However, I wasn't actually expecting it to work, so I'm not sure why it does. I just tried it while "thinking out loud". My intention was to subtract the altaz vector from the satellite's position, then figure out where that new position was.

I was expecting to have to do some sort of rotation to the altaz vector so that it would be in the correct reference frame. But apparently not... The latitude is a little off, so I'm probably still missing something.

[brandon-rhodes]

I'll admit that the Skyfield API here confused even me, who wrote it, which means I should look at redesigning this. The big surprise for me is that the b.from_altaz() method does not in any way use the vector b! Instead, it simply asks b for the original earth_station object and asks that object how its horizon was oriented at time t_now. But the actual vector b that points from the geocenter to the station is ignored and forms no part of the return value, which is instead simply a vector from the station to the alt/az in the sky.

Thus:

• apparent is a vector: station → satellite
• sat_tle.at(t_now) is a vector: geocenter → satellite

And therefore we can simplify their difference using the following substitutions:

• sat_tle.at(t_now) - apparent
• (satellite - geocenter) - (satellite - observer) (substitution)
• satellite - geocenter - satellite + observer (remove parens)
• - geocenter + observer (satellite cancels out!)

Thus the difference is a vector pointing from the geocenter to the observer, which turns out to be exactly what you wanted.

You are getting the wrong latitude because of this difference:

https://en.wikipedia.org/wiki/Latitude#Geodetic_and_geocentric_latitudes

Because a call to frame_latlon() doesn't know anything about a planet's shape, but simply measures angles from the origin of the reference frame, you get geocentric latitude.

But what you doubtless want is geodetic latitude:

position.center = 399
lat, lon = wgs84.latlon_of(position)

See if that gives you the lat and lon you were looking for!

Obviously Skyfield needs some improvements here, both because of the API confusion I noted above, and also because it's hacky to have to set the .center manually here that's necessary to make latlon_of() happy.

Maybe later this weekend, or maybe this coming week, or failing that sometime in October, I'll sit down and work on how the API can be improved. Thanks so much for this real-world example problem: it's seeing a real example of a calculation someone needs to perform with Skyfield vectors that always drives improvements!

[brandon-rhodes]

(Oh, and: I'll note that the from_altaz() method contains the comment # TODO: should this method live on another class?, so apparently I knew this was a dodgy design back in late November 2015!)

[TimVonsee]

Thank you both for the great answers and providing context behind the solution. I got what I needed by setting center of mass manually;

position = sat_tle.at(t_now) - apparent
position.center = 399 # Earth's NAIF ID
lat, lon = wgs84.latlon_of(position)

[TimVonsee]

@brandon-rhodes et al. , also compliments on the package/library as a whole! I'll definitely be exploring more of its functionality.