def test_from_horizons_scalar_epoch_uses_reshaped_epochs(horizons_mock): unused_name = "Strange Object" unused_id_type = "id_type" unused_plane = Planes.EARTH_EQUATOR unused_location_str = "500@399" unused_attractor = Earth expected_epochs = Time(["2020-03-01 12:00:00"], scale="tdb") epochs = expected_epochs[0] horizons_mock().vectors.return_value = { "x": [1] * u.au, "y": [0] * u.au, "z": [0] * u.au, "vx": [0] * (u.au / u.day), "vy": [1] * (u.au / u.day), "vz": [0] * (u.au / u.day), } Ephem.from_horizons( unused_name, epochs, attractor=unused_attractor, plane=unused_plane, id_type=unused_id_type, ) horizons_mock.assert_called_with( id=unused_name, location=unused_location_str, epochs=expected_epochs.jd, id_type=unused_id_type, )
def test_ephem_from_horizons_calls_horizons_with_correct_parameters( horizons_mock, attractor, location_str, plane, refplane_str ): unused_name = "Strange Object" unused_id_type = "id_type" epochs = Time(["2020-03-01 12:00:00"], scale="tdb") horizons_mock().vectors.return_value = { "x": [1] * u.au, "y": [0] * u.au, "z": [0] * u.au, "vx": [0] * (u.au / u.day), "vy": [1] * (u.au / u.day), "vz": [0] * (u.au / u.day), } expected_coordinates = CartesianRepresentation( [(1, 0, 0)] * u.au, xyz_axis=1, differentials=CartesianDifferential([(0, 1, 0)] * (u.au / u.day), xyz_axis=1), ) ephem = Ephem.from_horizons( unused_name, epochs, attractor=attractor, plane=plane, id_type=unused_id_type ) horizons_mock.assert_called_with( id=unused_name, location=location_str, epochs=epochs.jd, id_type=unused_id_type ) horizons_mock().vectors.assert_called_once_with(refplane=refplane_str) coordinates = ephem.sample() assert_coordinates_allclose(coordinates, expected_coordinates)
def test_can_set_iss_attractor_to_earth(): # See https://github.com/poliastro/poliastro/issues/798 epoch = Time("2019-11-10 12:00:00") ephem = Ephem.from_horizons( "International Space Station", epochs=epoch, attractor=Sun, id_type="majorbody" ) iss = Orbit.from_ephem(Sun, ephem, epoch) iss = iss.change_attractor(Earth) assert iss.attractor == Earth
def test_plot_ephem_no_epoch(): epoch = Time("2020-02-14 00:00:00") ephem = Ephem.from_horizons( "2020 CD3", time_range(Time("2020-02-13 12:00:00"), end=Time("2020-02-14 12:00:00")), attractor=Earth, ) fig, ax = plt.subplots() plotter = StaticOrbitPlotter(ax=ax) plotter.set_attractor(Earth) plotter.set_orbit_frame(Orbit.from_ephem(Earth, ephem, epoch)) plotter.plot_ephem(ephem, label="2020 CD3 Minimoon", color="k") return fig
def dist_chart(asteroid, date, timespan): solar_system_ephemeris.set('jpl') EPOCH = Time(date, scale="tdb") epochs = time_range(EPOCH - TimeDelta(timespan), end=EPOCH + TimeDelta(timespan)) epochs_moon = time_range(EPOCH - TimeDelta(15 * u.day), end=EPOCH + TimeDelta(15 * u.day)) moon = Ephem.from_body(Moon, epochs_moon, attractor=Earth) aster = Ephem.from_horizons(asteroid, epochs, attractor=Earth) plotter = StaticOrbitPlotter() plotter.set_attractor(Earth) plotter.set_body_frame(Moon) plotter.plot_ephem(moon, EPOCH, label=Moon) plotter.plot_ephem(aster, EPOCH, label=asteroid) return plotter
from poliastro.util import time_range EPOCH = Time("2018-02-18 12:00:00", scale="tdb") # In[2]: import plotly.io as pio pio.renderers.default = "notebook_connected" # In[3]: roadster = Ephem.from_horizons( "SpaceX Roadster", epochs=time_range(EPOCH, end=EPOCH + 360 * u.day), attractor=Sun, plane=Planes.EARTH_ECLIPTIC, id_type="majorbody", ) roadster # In[4]: from poliastro.plotting.misc import plot_solar_system # In[5]: frame = plot_solar_system(outer=False, epoch=EPOCH) frame.plot_ephem(roadster, EPOCH, label="SpaceX Roadster", color="black") # In[6]:
# Therefore, if we `propagate` this orbit to `EPOCH`, the results will be a bit different from the reality. Therefore, we need to find some other means. # # Let's use the `Ephem.from_horizons` method as an alternative, sampling over a period of 6 months: # In[8]: from poliastro.ephem import Ephem # In[9]: epochs = time_range(EPOCH - TimeDelta(3 * 30 * u.day), end=EPOCH + TimeDelta(3 * 30 * u.day)) # In[10]: florence = Ephem.from_horizons("Florence", epochs, plane=Planes.EARTH_ECLIPTIC) florence # In[11]: florence.plane # And now, let's compute the distance between Florence and the Earth at that epoch: # In[12]: earth = Ephem.from_body(Earth, epochs, plane=Planes.EARTH_ECLIPTIC) earth # In[13]:
def transfer_vel(body1, body2, attractor): """Returns transfer parameters for body1 (e.g. Earth) to body2 (e.g. Mars). Optionally, the main attractor can be specified. If omitted, Sun is assumed. Returns: helio1 - heliocentric velocity at departure (before Hohmann) (body1) helio2 - heliocentric velocity at arrival (body2) v1 - heliocentric velocity at departure (after Hohmann burn) v2 - heliocentric velocity at arrival (before Hohmann burn) tof - time of flight (in days) """ # How to obtain the orbit. The from_horisons method seems to be no longer supported # as of perylune 0.16.3. method = "ephem" # allowed values are ephem, horizons_orbit if attractor is None: attractor = Sun # Let's assume the calculations are done for 2020. date_start = time.Time("2020-01-01 00:00", scale="utc").tdb date_end = time.Time("2021-12-31 23:59", scale="utc").tdb name1, id_type1 = name_to_horizons_id(body1) name2, id_type2 = name_to_horizons_id(body2) if method == "ephem": # Get the ephemerides first and then contruct orbit based on them. This is the recommended # way. See warning in Orbit.from_horizons about deprecation. ephem1 = Ephem.from_horizons(name=name1, epochs=time_range(date_start, end=date_end), plane=Planes.EARTH_ECLIPTIC, id_type=id_type1) ephem2 = Ephem.from_horizons(name=name2, epochs=time_range(date_start, end=date_end), plane=Planes.EARTH_ECLIPTIC, id_type=id_type2) # Solve for departure and target orbits orb1 = Orbit.from_ephem(Sun, ephem1, date_start + 180 * u.day) orb2 = Orbit.from_ephem(Sun, ephem2, date_end) elif method == "horizons_orbit": # This is the old way. Sadly, it produces way better values. orb1 = Orbit.from_horizons(name=name1, attractor=attractor, plane=Planes.EARTH_ECLIPTIC, id_type=id_type1) orb2 = Orbit.from_horizons(name=name2, attractor=attractor, plane=Planes.EARTH_ECLIPTIC, id_type=id_type2) else: raise "Invalid method set." # The escape_delta_v returns a tuple of escape velocity at current, periapsis, apoapsis. helio1 = heliocentric_velocity(orb1) helio2 = heliocentric_velocity(orb2) #vesc1 = escape_vel(orb1, False)[1] #vesc2 = escape_vel(orb2, False)[1] hoh1, hoh2, tof = hohmann_velocity(orb1, orb2) return helio1, helio2, hoh1, hoh2, tof