TLETarget: support only astroplan Observer and use its properties for atmospheric refraction in ICRF.altaz()

- Update tests with an example without an observer and one with temperature and pressure. Also, use time above the horizon to test `TLETarget.altaz()`, and test `TLETarget.altaz()` with multiple times.
- Use `@pytest.mark.remote_data` for TLE tests since they use `Observer.at_site()`.

Author: michaelbaisch

astroplan/target.py

@@ -220,7 +220,7 @@ def __init__(self, line1, line2, name=None, observer=None, skip_tle_check=False)
             Name of the target, used for plotting and representing the target
             as a string
 
-        observer : `~astropy.coordinates.EarthLocation`, `~astroplan.Observer`, optional
+        observer : `~astroplan.Observer`, optional
             The location of observer.
             If `None`, the observer is assumed to be at sea level at the equator.
 
@@ -237,13 +237,16 @@ def __init__(self, line1, line2, name=None, observer=None, skip_tle_check=False)
         self.satellite = EarthSatellite(line1, line2, name, load.timescale())
 
         if observer is None:
-            self.observer = wgs84.latlon(0, 0, 0)
+            # Prevent circular import and usually not used
+            from .observer import Observer
+            self.observer = Observer(latitude=0*u.deg, longitude=0*u.deg, elevation=0*u.m)
         else:
-            observer = getattr(observer, 'location', observer)
-            longitude, latitude, height = observer.to_geodetic()
-            self.observer = wgs84.latlon(latitude.to(u.deg).value,
-                                         longitude.to(u.deg).value,
-                                         height.to(u.m).value)
+            self.observer = observer
+
+        longitude, latitude, height = self.observer.location.to_geodetic()
+        self.geographic_position = wgs84.latlon(latitude.to(u.deg).value,
+                                                longitude.to(u.deg).value,
+                                                height.to(u.m).value)
 
     @classmethod
     def from_string(cls, tle_string, name=None, *args, **kwargs):
@@ -300,7 +303,7 @@ def _compute_topocentric(self, time=None):
         ts = load.timescale()
         t = ts.from_astropy(time)
 
-        topocentric = (self.satellite - self.observer).at(t)
+        topocentric = (self.satellite - self.geographic_position).at(t)
 
         # Check for invalid TLE data. A non-None usually message means the computation went beyond
         # the physically sensible point. Details:
@@ -333,7 +336,13 @@ def coord(self, time=None):
         topocentric = self._compute_topocentric(time)
         ra, dec, distance = topocentric.radec()
         # No distance, in SkyCoord, distance is from frame origin, but here, it's from observer.
-        return SkyCoord(ra.hours*u.hourangle, dec.degrees*u.deg, obstime=time, frame='icrs')
+        return SkyCoord(
+            ra.hours*u.hourangle,
+            dec.degrees*u.deg,
+            obstime=time,
+            frame='icrs',
+            location=self.observer.location,
+        )
 
     def altaz(self, time=None):
         """
@@ -350,15 +359,28 @@ def altaz(self, time=None):
             SkyCoord object representing the target's altitude and azimuth at the specified time(s)
         """
         topocentric = self._compute_topocentric(time)
-        alt, az, distance = topocentric.altaz()
-
-        earth_location = EarthLocation(lat=self.observer.latitude.degrees*u.deg,
-                                       lon=self.observer.longitude.degrees*u.deg,
-                                       height=self.observer.elevation.m*u.m)
 
-        altaz = AltAz(alt=alt.degrees*u.deg, az=az.degrees*u.deg,
-                      obstime=time, location=earth_location)
-        return SkyCoord(altaz)
+        temperature_C = None
+        pressure_mbar = None
+        if self.observer.temperature is not None:
+            temperature_C = self.observer.temperature.to_value(u.deg_C)
+        if self.observer.pressure is not None:
+            pressure_mbar = self.observer.pressure.to_value(u.mbar)
+            
+        alt, az, distance = topocentric.altaz(
+            temperature_C=temperature_C,
+            pressure_mbar=pressure_mbar,
+        )
+        
+        # 'relative_humidity' and 'obswl' were not used in coordinate calculation
+        altaz_frame = AltAz(
+            location=self.observer.location,
+            obstime=time,
+            pressure=self.observer.pressure,
+            temperature=self.observer.temperature,
+        )
+
+        return SkyCoord(alt=alt.degrees*u.deg, az=az.degrees*u.deg, frame=altaz_frame)
 
     def __repr__(self):
         return f'<{self.__class__.__name__} "{self.name}">'

astroplan/tests/test_target.py

@@ -54,6 +54,7 @@ def test_FixedTarget_ra_dec():
                                                            'SkyCoord')
 
 
+@pytest.mark.remote_data
 @pytest.mark.skipif('not HAS_SKYFIELD')
 def test_TLETarget():
     tle_string = ("ISS (ZARYA)\n"
@@ -62,18 +63,27 @@ def test_TLETarget():
     line1 = "1 25544U 98067A   23215.27256123  .00041610  00000-0  73103-3 0  9990"
     line2 = "2 25544  51.6403  95.2411 0000623 157.9606 345.0624 15.50085581409092"
     subaru = Observer.at_site('subaru')  # (lon, lat, el)=(-155.476111 deg, 19.825555 deg, 4139.0 m)
+    subaru_temp_pressure = Observer.at_site('subaru', temperature=-10*u.Celsius, pressure=0.9*u.bar)
     time = Time("2023-08-02 10:00", scale='utc')
     times = time_grid_from_range([time, time + 3.1*u.hour],
                                  time_resolution=1 * u.hour)
 
     tle_target1 = TLETarget(name="ISS (ZARYA)", line1=line1, line2=line2, observer=subaru)
     tle_target2 = TLETarget.from_string(tle_string=tle_string, observer=subaru)
+    tle_target_no_observer = TLETarget(name="ISS (ZARYA)", line1=line1, line2=line2, observer=None)
+    tle_target_temp_pressure = TLETarget(
+        name="ISS (ZARYA)", line1=line1, line2=line2, observer=subaru_temp_pressure
+    )
 
     assert tle_target1.name == "ISS (ZARYA)"
     assert tle_target2.name == "ISS (ZARYA)"
     assert repr(tle_target1) == repr(tle_target2)
     assert str(tle_target1) == str(tle_target2)
 
+    assert isinstance(tle_target_no_observer.observer, Observer)
+    assert abs(tle_target_no_observer.observer.location.lat) < 0.001*u.deg
+    tle_target_no_observer.coord(time)  # Just needs to work
+
     # Single time (Below Horizon)
     ra_dec1 = tle_target1.coord(time)   # '08h29m26.00003243s +07d31m36.65950907s'
     ra_dec2 = tle_target2.coord(time)
@@ -145,10 +155,21 @@ def test_TLETarget():
         TLETarget.from_string(tle_string=tle_string, observer=subaru)
 
     # AltAz (This is slow)
-    altaz_observer = subaru.altaz(time, tle_target1)
-    altaz_skyfield = tle_target1.altaz(time)
+    altaz_observer = subaru.altaz(time_ah, tle_target1)
+    altaz_skyfield = tle_target1.altaz(time_ah)
+
+    assert altaz_observer.separation(altaz_skyfield) < 21*u.arcsec
 
-    assert altaz_observer.separation(altaz_skyfield) < 20*u.arcsec
+    # AltAz with atmospheric refraction (temperature and pressure)
+    altaz_observer = subaru_temp_pressure.altaz(time_ah, tle_target_temp_pressure)
+    altaz_skyfield = tle_target_temp_pressure.altaz(time_ah)
+
+    assert altaz_observer.separation(altaz_skyfield) < 26*u.arcsec
+
+    # AltAz with multiple times
+    #subaru.altaz(times, tle_target1)
+    altaz_multiple = tle_target1.altaz(times)
+    assert len(altaz_multiple.obstime) == len(altaz_multiple) == len(times)
 
     # Time too far in the future where elements stop making physical sense
     with pytest.warns():  # ErfaWarning: ERFA function "dtf2d" yielded 1 of "dubious year (Note 6)
@@ -203,6 +224,7 @@ def test_get_skycoord():
     assert len(coo) == 2
 
 
+@pytest.mark.remote_data
 @pytest.mark.skipif('not HAS_SKYFIELD')
 def test_get_skycoord_with_TLETarget():
     skycoord_targed = SkyCoord(10.6847083*u.deg, 41.26875*u.deg)