def test_find_event_two_calls_bis(orbit): # This case, where we search for the 90 deg Argument of Latitude # does not crash unexpectedly. kwargs = { "start": Date(2018, 4, 5, 16, 50), "stop": timedelta(minutes=200), "step": timedelta(minutes=3), "listeners": AnomalyListener(np.pi / 2, "aol") } orb_iterator = orbit.iter(**kwargs) p1 = find_event(orb_iterator, "Argument of Latitude = 90.00") assert abs(p1.date - Date(2018, 4, 5, 17, 57, 7, 129464)).total_seconds() < 1.8e-5 assert p1.event.info == "Argument of Latitude = 90.00" orb_iterator2 = orbit.iter(**kwargs) p2 = find_event(orb_iterator2, "Argument of Latitude = 90.00", offset=1) assert abs(p2.date - Date(2018, 4, 5, 19, 29, 42, 991221)).total_seconds() < 1.8e-5 assert p2.event.info == "Argument of Latitude = 90.00" orb_iterator3 = orbit.iter(**kwargs) with raises(RuntimeError): find_event(orb_iterator3, "Argument of Latitude = 90.00", offset=2)
def test_duty_cycle(orbit_kepler): with mock_step(orbit_kepler) as mock: date = Date(2018, 5, 4, 15) orbit_kepler.propagate(date) assert mock.call_count == count_steps(orbit_kepler.date - date, orbit_kepler.propagator.step) assert mock.call_count == 100 with mock_step(orbit_kepler) as mock: date = orbit_kepler.date - timedelta(seconds=652) orbit_kepler.propagate(date) assert mock.call_count == count_steps(orbit_kepler.date - date, orbit_kepler.propagator.step) assert mock.call_count == 11 with mock_step(orbit_kepler) as mock: start = Date(2018, 5, 4, 13) stop = start + timedelta(minutes=90) data = [] for p in orbit_kepler.iter(start=start, stop=stop): data.append(p) assert len(data) == 91 assert data[0].date == start assert data[-1].date == stop assert mock.call_count == ( count_steps(orbit_kepler.date - start, orbit_kepler.propagator.step) + count_steps(stop - start, orbit_kepler.propagator.step, False) )
def test_propagate_rk4(orbit_kepler): orbit_kepler.propagator.method = KeplerNum.RK4 assert orbit_kepler.date == Date(2018, 5, 4, 13, 20, 47, 630976) # simple propagation with a Date object orb2 = orbit_kepler.propagate(orbit_kepler.date + timedelta(minutes=121, seconds=12)) assert orb2.date == Date(2018, 5, 4, 15, 21, 59, 630976) assert orb2.propagator.orbit is None # brand new propagator # simple propagation with a timedelta object orb3 = orb2.propagate(timedelta(minutes=12, seconds=5)) # Check if the propagator.orbit is initializd for orb2 # and not yet initialized for orb3 assert orb3.date == Date(2018, 5, 4, 15, 34, 4, 630976) assert orb2.propagator.orbit is not None assert orb3.propagator.orbit is None assert np.allclose( orb3, [-2267347.5906591383, 3865612.1569156954, -5093932.5567979375, -5238.634675262262, -5326.282920539333, -1708.6895889357945] ) # simple propagation with a negative step orb4 = orb3.propagate(timedelta(minutes=-15)) assert orb4.date == orb3.date - timedelta(minutes=15)
def test_light(orbit, mode): listeners = [LightListener(), LightListener('penumbra')] events = iter_listeners(orbit, listeners, mode) # Maybe the difference of date precision between 'exit' and 'entry' while computing from # a Ephem can be explained by the fact that the 'entry' events are further from # a point of the ephemeris than the 'exit' ones. p = next(events) assert abs(p.date - Date(2018, 4, 5, 17, 5, 57, 760757)).total_seconds() <= 8e-6 assert p.event.info == "Umbra exit" p = next(events) assert abs(p.date - Date(2018, 4, 5, 17, 6, 6, 20177)).total_seconds() <= 8e-6 assert p.event.info == "Penumbra exit" p = next(events) assert abs(p.date - Date(2018, 4, 5, 18, 2, 37, 568025)).total_seconds() <= 16e-6 assert p.event.info == "Penumbra entry" p = next(events) assert abs(p.date - Date(2018, 4, 5, 18, 2, 45, 814490)).total_seconds() <= 16e-6 assert p.event.info == "Umbra entry" with raises(StopIteration): next(events)
def test_true_anomaly(molniya, mode): if isinstance(molniya, Ephem): stop = molniya[0].infos.period else: stop = molniya.infos.period step = timedelta(minutes=10) events = iter_listeners(molniya, AnomalyListener(np.pi), mode, stop=stop, step=step) p = next(events) assert abs(p.date - Date(2018, 4, 5, 18, 14, 7, 743079)).total_seconds() < 3.7e-5 assert p.event.info == "True Anomaly = 180.00" with raises(StopIteration): p = next(events) events = iter_listeners(molniya, AnomalyListener(3 * np.pi / 2), mode, stop=stop, step=step) p = next(events) assert abs(p.date - Date(2018, 4, 5, 21, 33, 10, 712900)).total_seconds() < 3.7e-5 assert p.event.info == "True Anomaly = 270.00" with raises(StopIteration): p = next(events) events = iter_listeners(molniya, AnomalyListener(0), mode, stop=stop, step=step) p = next(events) assert abs(p.date - Date(2018, 4, 5, 22, 0, 2, 409409)).total_seconds() < 8e-6 assert p.event.info == "True Anomaly = 0.00" with raises(StopIteration): next(events) events = iter_listeners(molniya, AnomalyListener(np.pi / 2), mode, stop=stop, step=step) p = next(events) assert abs(p.date - Date(2018, 4, 5, 22, 26, 54, 209357)).total_seconds() < 3.7e-5 assert p.event.info == "True Anomaly = 90.00" with raises(StopIteration): p = next(events)
def test_mean_anomaly(molniya, mode): if isinstance(molniya, Ephem): stop = molniya[0].infos.period else: stop = molniya.infos.period step = timedelta(minutes=10) events = iter_listeners(molniya, AnomalyListener(np.pi, "mean"), mode, stop=stop, step=step) p = next(events) assert abs(p.date - Date(2018, 4, 5, 18, 14, 7, 743079)).total_seconds() < 3.7e-5 assert p.event.info == "Mean Anomaly = 180.00" with raises(StopIteration): p = next(events) events = iter_listeners(molniya, AnomalyListener(3 * np.pi / 2, "mean"), mode, stop=stop, step=step) p = next(events) assert abs(p.date - Date(2018, 4, 5, 20, 7, 5, 494487)).total_seconds() < 3.7e-5 assert p.event.info == "Mean Anomaly = 270.00" with raises(StopIteration): p = next(events) events = iter_listeners(molniya, AnomalyListener(0, "mean"), mode, stop=stop, step=step) p = next(events) assert abs(p.date - Date(2018, 4, 5, 22, 0, 2, 409409)).total_seconds() < 8e-6 assert p.event.info == "Mean Anomaly = 0.00" with raises(StopIteration): next(events) events = iter_listeners(molniya, AnomalyListener(np.pi / 2, "mean"), mode, stop=stop, step=step) p = next(events) assert abs(p.date - Date(2018, 4, 5, 23, 52, 59, 555389)).total_seconds() < 3.7e-5 assert p.event.info == "Mean Anomaly = 90.00" with raises(StopIteration): p = next(events)
def test_propagate(jplfiles): venus = get_orbit('VenusBarycenter', Date(2018, 1, 14)) venus = venus.propagate(Date(2018, 1, 15, 12, 27)) assert abs(32.18435609745404946124835987575 + venus.date._offset) <= np.finfo(float).eps assert str(venus.frame) == "SolarSystemBarycenter" assert str(venus.form) == "cartesian" assert np.allclose(venus, [ 5.23110445e+10, -8.51235950e+10, -4.16279990e+10, 3.05086795e+04, 1.58745616e+04, 5.21182159e+03 ])
def test_listener(orbit_kepler): with mock_step(orbit_kepler) as mock: start = Date(2018, 5, 4, 13) stop = start + timedelta(minutes=90) data = [] for p in orbit_kepler.iter(start=start, stop=stop, listeners=LightListener()): data.append(p) assert len(data) == 93 assert mock.call_count == ( count_steps(orbit_kepler.date - start, orbit_kepler.propagator.step) + count_steps(stop - start, orbit_kepler.propagator.step, False)) # assert mock.call_count == 111 events = [x for x in data if x.event] assert len(events) == 2 assert events[0].date == Date(2018, 5, 4, 13, 8, 38, 869126) assert events[0].event.info == "Umbra exit" assert events[1].date == Date(2018, 5, 4, 14, 5, 21, 256923) assert events[1].event.info == "Umbra entry" with mock_step(orbit_kepler) as mock: start = Date(2018, 5, 4, 13) stop = start + timedelta(minutes=90) data = [] for p in orbit_kepler.iter(start=start, stop=stop, listeners=ApsideListener()): data.append(p) assert len(data) == 93 assert mock.call_count == ( count_steps(orbit_kepler.date - start, orbit_kepler.propagator.step) + count_steps(stop - start, orbit_kepler.propagator.step, False)) # assert mock.call_count == 125 events = [x for x in data if x.event] assert len(events) == 2 assert str(events[0].date) == "2018-05-04T13:08:30.765145 UTC" assert events[0].event.info == "Periapsis" assert str(events[1].date) == "2018-05-04T13:54:50.178231 UTC" assert events[1].event.info == "Apoapsis"
def test_event_iterator(orbit): kwargs = { "start": Date(2018, 4, 5, 16, 50), "stop": timedelta(minutes=100), "step": timedelta(minutes=3), "listeners": [ AnomalyListener(3 * np.pi / 2, "aol"), AnomalyListener(np.pi / 2, "aol"), ApsideListener(), ] } # iterate over the orbit, but filter only the AoL events, leaving # apsides events out orb_iterator = orbit.iter(**kwargs) events = [ "Argument of Latitude = 270.00", "Argument of Latitude = 90.00", ] iterator = events_iterator(orb_iterator, *events) p = next(iterator) assert abs(p.date - Date(2018, 4, 5, 17, 10, 49, 816867)).total_seconds() < 1.8e-5 assert p.event.info == "Argument of Latitude = 270.00" p = next(iterator) assert abs(p.date - Date(2018, 4, 5, 17, 57, 7, 129464)).total_seconds() < 1.8e-5 assert p.event.info == "Argument of Latitude = 90.00" # No more events to filter in the iterator with raises(StopIteration): p = next(iterator) # Same iterator construction, but this time we filter only apsudes events iterator = events_iterator(orbit.iter(**kwargs), "Apoapsis") p = next(iterator) assert abs(p.date - Date(2018, 4, 5, 16, 58, 54, 546919)).total_seconds() < 4e-5 assert p.event.info == "Apoapsis" # No more events to filter in the iterator with raises(StopIteration): p = next(iterator)
def test_terminator(orbit, mode): events = iter_listeners(orbit, TerminatorListener(), mode) p = next(events) assert abs(p.date - Date(2018, 4, 5, 17, 11, 13, 908911)).total_seconds() <= 2e-5 assert p.event.info == "Day Terminator" p = next(events) assert abs(p.date - Date(2018, 4, 5, 17, 57, 33, 123730)).total_seconds() <= 2.5e-5 assert p.event.info == "Night Terminator"
def orbit_man(orbit): orbit = orbit.copy() orbit.propagator = KeplerNum(get_body("Earth"), timedelta(seconds=60)) orbit.maneuvers = [ ImpulsiveMan( Date(2008, 9, 20, 12, 41, 9, 984493), [280, 0, 0], frame="TNW", comment="Maneuver 1", ), ImpulsiveMan(Date(2008, 9, 20, 13, 33, 11, 374985), [270, 0, 0], frame="TNW"), ] return orbit
def test_units(): ephem1 = load(folder.joinpath("tess_kms.txt").open()) assert ephem1.start == Date(2019, 4, 29, scale="TDB") assert ephem1.stop == Date(2019, 5, 29, scale="TDB") assert len(ephem1) == 31 ephem2 = load(folder.joinpath("tess_kmd.txt").open()) assert ephem2.start == Date(2019, 4, 29, scale="TDB") assert ephem2.stop == Date(2019, 5, 29, scale="TDB") assert len(ephem2) == 31 assert np.allclose(ephem1, ephem2)
def test_find_event_offset(orbit): kwargs = { "start": Date(2018, 4, 5, 16, 50), "stop": timedelta(minutes=200), "step": timedelta(minutes=3), "listeners": AnomalyListener(3 * np.pi / 2, "aol") } orb_iterator = orbit.iter(**kwargs) p = find_event(orb_iterator, "Argument of Latitude = 270.00", offset=1) assert abs(p.date - Date(2018, 4, 5, 18, 43, 25, 683360)).total_seconds() < 1.8e-5 assert p.event.info == "Argument of Latitude = 270.00"
def measureset(orbit, station): path = "{0} {1} {0}".format(station.name, orbit.cospar_id).split() aos = Date(2008, 9, 20, 18, 16, 3, 690790) los = Date(2008, 9, 20, 18, 24, 58, 852563) measures = MeasureSet([]) for orb in orbit.iter(start=aos, stop=los, step=timedelta(seconds=5)): sph = orb.copy(frame=station, form='spherical') measures.append(Range(path, orb.date, sph.r * 2)) measures.append(Azimut(path, orb.date, sph.theta)) measures.append(Elevation(path, orb.date, sph.phi)) return measures
def test_station_no_mask(orbit, station): station.mask = np.array([[ 1.97222205, 2.11184839, 2.53072742, 2.74016693, 3.00196631, 3.42084533, 3.71755131, 4.15388362, 4.71238898, 6.28318531 ], [ 0.35255651, 0.34906585, 0.27401669, 0.18675023, 0.28099801, 0.16580628, 0.12915436, 0.03490659, 0.62831853, 1.3962634 ]]) listeners = stations_listeners(station) station.mask = None points = station.visibility( orbit, start=Date(2018, 4, 5, 21), stop=timedelta(minutes=30), step=timedelta(seconds=30), events=listeners, ) with raises(ValueError): points = list(points)
def test_node(orbit, mode): events = iter_listeners(orbit, NodeListener(), mode) p = next(events) assert abs(p.date - Date(2018, 4, 5, 17, 33, 59, 488549)).total_seconds() <= 20e-6 assert p.event.info == "Asc Node" p = next(events) assert abs(p.date - Date(2018, 4, 5, 18, 20, 15, 389928)).total_seconds() <= 17e-6 assert p.event.info == "Desc Node" with raises(StopIteration): next(events)
def test_iter_on_dates(orb): # Generate a free step ephemeris start = orb.date stop1 = start + timedelta(hours=3) step1 = timedelta(seconds=10) stop2 = stop1 + timedelta(hours=3) step2 = timedelta(seconds=120) dates = list(Date.range(start, stop1, step1)) + list(Date.range(stop1, stop2, step2, inclusive=True)) ephem = orb.ephem(dates=dates) assert ephem.start == start assert ephem.stop == stop2 assert ephem[1].date - ephem[0].date == step1 assert ephem[-1].date - ephem[-2].date == step2
def test_apside(orbit, mode): events = iter_listeners(orbit, ApsideListener(), mode) p = next(events) assert abs(p.date - Date(2018, 4, 5, 16, 58, 54, 546919)).total_seconds() <= 37e-6 assert p.event.info == "Apoapsis" p = next(events) assert abs(p.date - Date(2018, 4, 5, 17, 54, 54, 87860)).total_seconds() <= 13e-6 assert p.event.info == "Periapsis" with raises(StopIteration): next(events)
def test_tolerant(ephem): # Test for out of range starting and stoping points start = Date(2008, 9, 20, 12, 15) stop = timedelta(minutes=24) with raises(ValueError): ephem.ephem(start=start, stop=stop) with raises(ValueError): ephem.ephem(stop=timedelta(hours=2)) subephem = ephem.ephem(start=start, stop=stop, strict=False) assert subephem.start == ephem.start assert subephem.stop == start + stop subephem = ephem.ephem(stop=timedelta(hours=2), strict=False) assert subephem.start == ephem.start assert subephem.stop == ephem.stop # Case where both start and stop are BEFORE the first date of the initial ephem subephem = ephem.ephem(start=start, stop=timedelta(minutes=6), strict=False) assert len(subephem) == 0 # Case where both start and stop are AFTER the last date of the initial ephem subephem = ephem.ephem(start=ephem.start + timedelta(hours=2), stop=timedelta(minutes=6), strict=False) assert len(subephem) == 0 # Case where start is before and stop is after subephem = ephem.ephem(start=start, stop=timedelta(hours=1, minutes=45), strict=False) assert subephem.start == ephem.start assert subephem.stop == ephem.stop
def test_station(station, helper): # lines = """ISS (ZARYA) # 1 25544U 98067A 16038.20499631 .00009950 00000-0 15531-3 0 9993 # 2 25544 51.6445 351.2284 0006997 89.9621 48.8570 15.54478078984606""" # orb = Tle(lines).orbit() # orb = orb.propagate(Date(2016, 2, 7, 16, 55)) # from beyond.dates.eop import get_pole # print(get_pole(Date(2016, 2, 7, 16, 55).mjd)) # assert False orb = Orbit([ 4225679.11976, 2789527.13836, 4497182.71156, -5887.93077439, 3748.50929999, 3194.45322378 ], Date(2016, 2, 7, 16, 55), 'cartesian', 'TEME', 'Sgp4') archive = orb.copy() assert station.orientation.name == "Toulouse" orb.frame = station orb.form = 'spherical' # azimuth assert np.isclose(-np.degrees(orb.theta), 159.75001561831209) # elevation assert np.isclose(np.degrees(orb.phi), 57.894234049230583) # range assert np.isclose(orb.r, 471467.65510239213) orb.frame = archive.frame orb.form = archive.form helper.assert_vector(archive, orb)
def test_ltan2raan(common_env): date = Date(2020, 1, 29, 18, 27) assert abs(ltan.ltan2raan(date, 22.5 * 3600) - 1.8496591694176407) < eps assert abs(ltan.ltan2raan(date, 22.5 * 3600, "true") - 1.901700132311372) < eps
def tangential(propagator): return Orbit( propagator._mat6 @ [0, -100, 0, 0, 0, 0], Date(2020, 5, 24), "cartesian", "Hill", propagator, )
def test_ecliptic(): ref_ephem = load(folder.joinpath("mro_equatorial.txt").open()) assert ref_ephem.start == Date(2019, 4, 29, scale="TDB") assert ref_ephem.stop == Date(2019, 5, 29, scale="TDB") assert len(ref_ephem) == 31 ephem = load(folder.joinpath("mro_ecliptic.txt").open()) # Identical values along X, because the X axis (the vernal point) # is the same in equatorial and equatorial representation assert np.allclose(ref_ephem[:, 0], ephem[:, 0]) # There is slight differences between how the Horizon's # conversion and our own, but it is globally consistent assert np.allclose(ref_ephem[:, 1], ephem[:, 1], rtol=1e-4) assert np.allclose(ref_ephem[:, 2], ephem[:, 2], rtol=1e-3)
def space_clock(*argv): """Time control Usage: space-clock space-clock sync space-clock set-date <date> [<ref>] space-clock set-offset <offset> Options: sync Set the time to be the same as the system set-date Define the date set-offset Define offset <date> New date to set (%Y-%m-%dT%H:%M:%S.%f) <ref> Date at witch the new date is set (same format as <date>). If absent, the current system time is used <offset> Offset in seconds """ from space.utils import docopt args = docopt(space_clock.__doc__, options_first=True) if args["sync"]: sync() print(file=sys.stderr) elif args["set-date"]: if args["<ref>"] is None: ref = LegacyDate.now() else: ref = LegacyDate.strptime(args["<ref>"], "%Y-%m-%dT%H:%M:%S.%f") date = LegacyDate.strptime(args["<date>"], "%Y-%m-%dT%H:%M:%S.%f") set_date(date, ref) print(file=sys.stderr) elif args["set-offset"]: offset = parse_timedelta(args["<offset>"], negative=True) set_offset(offset) print(file=sys.stderr) now = Date.now() print("System Date : {}".format(now - Date._clock_offset())) print("Clock Date : {}".format(now)) print("Offset : {}".format(now._clock_offset()))
def test_iter_on_dates(ephem): # Generate a free step ephemeris start = ephem.start stop1 = start + (ephem.stop - ephem.start) / 2 step1 = timedelta(seconds=60) stop2 = ephem.stop step2 = timedelta(seconds=120) dates = list(Date.range(start, stop1, step1)) + list(Date.range(stop1, stop2, step2, inclusive=True)) subephem = ephem.ephem(dates=dates) assert subephem.start == ephem.start assert subephem.stop == ephem.stop assert subephem[1].date - subephem[0].date == step1 assert subephem[-1].date - subephem[-2].date == step2
def test_iter_on_dates(ephem): # Generate a free step ephemeris start = ephem.start stop1 = start + timedelta(hours=1, minutes=10) step1 = timedelta(seconds=60) stop2 = ephem.stop step2 = timedelta(seconds=120) dates = list(Date.range(start, stop1, step1)) + list(Date.range(stop1, stop2, step2, inclusive=True)) subephem = ephem.ephem(dates=dates) assert subephem.start == ephem.start assert subephem.stop == ephem.stop assert subephem[1].date - subephem[0].date == step1 assert subephem[-1].date - subephem[-2].date == step2
def test_iter_on_dates(orbit): # Generate a free step ephemeris start = orbit.date if isinstance(orbit, Orbit) else orbit.start stop1 = start + timedelta(hours=3) step1 = timedelta(seconds=10) stop2 = stop1 + timedelta(hours=3) step2 = timedelta(seconds=120) dates = list(Date.range(start, stop1, step1)) + list( Date.range(stop1, stop2, step2, inclusive=True)) ephem = orbit.ephem(dates=dates) assert ephem.start == start assert ephem.stop == stop2 assert ephem[1].date - ephem[0].date == step1 assert ephem[-1].date - ephem[-2].date == step2
def test_station_visibility(orbit, station): station.mask = np.array([ [1.97222205, 2.11184839, 2.53072742, 2.74016693, 3.00196631, 3.42084533, 3.71755131, 4.15388362, 4.71238898, 6.28318531], [0.35255651, 0.34906585, 0.27401669, 0.18675023, 0.28099801, 0.16580628, 0.12915436, 0.03490659, 0.62831853, 1.3962634]]) points = list(station.visibility(orbit, start=Date(2018, 4, 5, 21), stop=timedelta(minutes=30), step=timedelta(seconds=30))) assert len(points) == 21 points = list(station.visibility(orbit, start=Date(2018, 4, 5, 21), stop=Date(2018, 4, 5, 21, 30), step=timedelta(seconds=30))) assert len(points) == 21 # Events (AOS, MAX and LOS) points = list(station.visibility(orbit, start=Date(2018, 4, 5, 21), stop=timedelta(minutes=70), step=timedelta(seconds=30), events=True)) # Three more points than precedently, due to the events computation assert len(points) == 26 assert isinstance(points[0].event, SignalEvent) assert points[0].event.info == 'AOS' assert points[0].event.elev == 0 assert abs(points[0].phi) < 1e-5 assert points[0].event.station == station assert (points[0].date - Date(2018, 4, 5, 21, 4, 41, 789681)).total_seconds() <= 1e-5 assert isinstance(points[10].event, MaskEvent) assert points[10].event.info == "AOS" assert points[10].event.elev == "Mask" assert points[10].event.station == station assert (points[10].date - Date(2018, 4, 5, 21, 9, 4, 977230)).total_seconds() <= 1e-5 assert isinstance(points[13].event, MaxEvent) assert points[13].event.info == "MAX" assert points[13].event.station == station assert (points[13].date - Date(2018, 4, 5, 21, 10, 2, 884540)).total_seconds() <= 1e-5 assert isinstance(points[23].event, MaskEvent) assert points[23].event.info == "LOS" assert points[23].event.elev == "Mask" assert points[23].event.station == station assert (points[23].date - Date(2018, 4, 5, 21, 14, 33, 978945)).total_seconds() <= 5e-5 assert isinstance(points[-1].event, SignalEvent) assert points[-1].event.info == 'LOS' assert points[-1].event.elev == 0 assert abs(points[-1].phi) < 1e-5 assert points[-1].event.station == station assert (points[-1].date - Date(2018, 4, 5, 21, 15, 25, 169655)).total_seconds() <= 1e-5
def test_station_signal(station, orbit, mode): listeners = stations_listeners(station) events = iter_listeners(orbit, listeners, mode) p = next(events) assert abs(p.date - Date(2018, 4, 5, 17, 51, 6, 475978)).total_seconds() <= 502e-6 assert p.event.info == "AOS" p = next(events) assert abs(p.date - Date(2018, 4, 5, 17, 56, 5, 542270)).total_seconds() <= 715e-6 assert p.event.info == "MAX" p = next(events) assert abs(p.date - Date(2018, 4, 5, 18, 1, 4, 828355)).total_seconds() <= 859e-6 assert p.event.info == "LOS"
def orbit_continuous_man(orbit): orbit = orbit.copy() orbit.propagator = KeplerNum(get_body("Earth"), timedelta(seconds=60)) orbit.maneuvers = [ ContinuousMan( Date(2008, 9, 20, 12, 41, 9, 984493), timedelta(minutes=3), dv=[280, 0, 0], frame="TNW", comment="Maneuver 1", ), ContinuousMan( Date(2008, 9, 20, 13, 33, 11, 374985), timedelta(minutes=3), dv=[270, 0, 0], frame="TNW", ), ] return orbit
def test_transform(jplfiles): mars = get_orbit('Mars', Date(2018, 2, 25)) mars.frame = "SolarSystemBarycenter" mars.form = "keplerian" assert mars.frame.center.name == "Sun" assert mars.frame.center.m > 1.9e30 assert 1.3 * AU <= mars.a <= 1.7 * AU
def test_radial_velocity(station, orbit, mode): events = iter_listeners(orbit, RadialVelocityListener(station), mode) p = next(events) assert abs(p.date - Date(2018, 4, 5, 17, 7, 29, 581221)).total_seconds() <= 2e-5 assert p.event.info == "Radial Velocity" p = next(events) assert abs(p.date - Date(2018, 4, 5, 17, 56, 5, 511934)).total_seconds() <= 3.5e-5 assert p.event.info == "Radial Velocity" # Test for RadialVelocity triggered only when in sight of the station events = list( iter_listeners(orbit, RadialVelocityListener(station, sight=True), mode)) assert len(events) == 1
def iter_listeners(orb, listeners, mode): start = Date(2018, 4, 5, 16, 50) stop = timedelta(minutes=100) step = timedelta(minutes=3) kwargs = {} if mode == 'range-nostep': kwargs['start'] = start kwargs['stop'] = stop if not isinstance(orb, Ephem): kwargs['step'] = step elif mode == 'range': kwargs['start'] = start kwargs['stop'] = stop kwargs['step'] = step else: kwargs['dates'] = Date.range(start, stop, step) for orb in orb.iter(listeners=listeners, **kwargs): if orb.event: yield orb
from beyond.frames import create_station from beyond.config import config tle = Tle("""ISS (ZARYA) 1 25544U 98067A 16086.49419020 .00003976 00000-0 66962-4 0 9998 2 25544 51.6423 110.4590 0001967 0.7896 153.8407 15.54256299992114""").orbit() # Station definition station = create_station('TLS', (43.428889, 1.497778, 178.0)) azims, elevs = [], [] print(" Time Azim Elev Distance Radial Velocity") print("=========================================================") for orb in station.visibility(tle, start=Date.now(), stop=timedelta(hours=24), step=timedelta(seconds=30), events=True): elev = np.degrees(orb.phi) # Radians are counterclockwise and azimuth is clockwise azim = np.degrees(-orb.theta) % 360 # Archive for plotting azims.append(azim) # Matplotlib actually force 0 to be at the center of the polar plot, # so we trick it by inverting the values elevs.append(90 - elev) r = orb.r / 1000. print("{event:7} {orb.date:%H:%M:%S} {azim:7.2f} {elev:7.2f} {r:10.2f} {orb.r_dot:10.2f}".format( orb=orb, r=r, azim=azim, elev=elev, event=orb.event.info if orb.event is not None else "" ))
from beyond.dates import Date from beyond.env.jpl import get_orbit from beyond.frames import create_station from beyond.config import config # Load the ".bsp" file config.update({ "env": { "jpl": [ "/home/jules/.space/jpl/jup310.bsp" ] } }) date = Date.now() # Definition of the location of observation station = create_station('TLS', (43.428889, 1.497778, 178.0)) # Retrieve Jupiter and its moons state-vectors jupiter = get_orbit('Jupiter', date) io = get_orbit('Io', date) europa = get_orbit('Europa', date) ganymede = get_orbit('Ganymede', date) callisto = get_orbit('Callisto', date) # Convert them to the observer frame jupiter.frame = station io.frame = station europa.frame = station
#!/usr/bin/env python from beyond.dates import Date, timedelta from beyond.orbits import Tle from beyond.frames import create_station from beyond.orbits.listeners import stations_listeners, NodeListener, ApsideListener, LightListener tle = Tle("""ISS (ZARYA) 1 25544U 98067A 17153.89608442 .00001425 00000-0 28940-4 0 9997 2 25544 51.6419 109.5559 0004850 223.1783 180.8272 15.53969766 59532""").orbit() # Station definition station = create_station('TLS', (43.428889, 1.497778, 178.0)) # Listeners declaration listeners = stations_listeners(station) # AOS, LOS and MAX elevation listeners.append(NodeListener()) # Ascending and Descending Node listeners.append(ApsideListener()) # Apogee and Perigee listeners.append(LightListener()) # Illumination events start = Date.now() stop = timedelta(minutes=100) step = timedelta(seconds=180) for orb in tle.iter(start=start, stop=stop, step=step, listeners=listeners): event = orb.event if orb.event is not None else "" print("{orb.date:%Y-%m-%d %H:%M:%S} {event}".format(orb=orb, event=event))