def test_dummy(ccsds_format):
with raises(TypeError):
dumps(None, fmt=ccsds_format)
with raises(CcsdsError):
loads("dummy text")
def test_load_omm_missing_sgp4(datafile):
list_omm = datafile("omm").splitlines()
for i, line in enumerate(list_omm):
if "MEAN_MOTION" in line:
list_omm.pop(i)
break
truncated_omm = "\n".join(list_omm)
with raises(CcsdsError) as e:
loads(truncated_omm)
assert str(e.value) == "Missing mandatory parameter 'MEAN_MOTION'"
def test_load_opm_truncated(datafile):
# One mandatory line is missing
list_opm = datafile("opm").splitlines()
for i, line in enumerate(list_opm):
if "EPOCH" in line:
list_opm.pop(i)
break
truncated_opm = "\n".join(list_opm)
with raises(CcsdsError) as e:
loads(truncated_opm)
assert str(e.value) == "Missing mandatory parameter 'EPOCH'"
def test_load_oem_interplanetary(jplfiles, ephem, datafile, helper):
ephem.frame = "MarsBarycenter"
data = loads(datafile("oem_interplanetary"))
helper.assert_ephem(ephem, data)
def test_load_interplanetary(jplfiles, orbit, datafile, helper):
orbit.frame = "MarsBarycenter"
data_opm = loads(datafile("opm_interplanetary"))
helper.assert_orbit(orbit, data_opm)
def loads(text):
"""Convert a string formatted along the CCSDS standard into an Orbit or
Ephem instance.
This function is a wrapper of :py:func:`beyond.io.ccsds.loads` and allows
to integrate some space-command specific fields
"""
orb = ccsds.loads(text)
if isinstance(orb,
StateVector) and "ccsds_user_defined" in orb.complements:
ud = orb.complements["ccsds_user_defined"]
name = ud["PROPAGATOR"]
if name == "KeplerNum":
kwargs = {
"step":
timedelta(seconds=float(ud["PROPAGATOR_STEP_SECONDS"])),
"bodies": [get_body(orb.frame.center.name)],
"frame": orb.frame,
"method": ud["PROPAGATOR_METHOD"],
}
else:
kwargs = {}
orb.as_orbit(get_propagator(name)(**kwargs))
return orb
def test_soi(jplfiles):
opm = ccsds.loads("""CCSDS_OPM_VERS = 2.0
CREATION_DATE = 2019-02-22T23:22:31
ORIGINATOR = N/A
META_START
OBJECT_NAME = N/A
OBJECT_ID = N/A
CENTER_NAME = EARTH
REF_FRAME = EME2000
TIME_SYSTEM = UTC
META_STOP
COMMENT State Vector
EPOCH = 2018-05-02T00:00:00.000000
X = 6678.000000 [km]
Y = 0.000000 [km]
Z = 0.000000 [km]
X_DOT = 0.000000 [km/s]
Y_DOT = 7.088481 [km/s]
Z_DOT = 3.072802 [km/s]
COMMENT Keplerian elements
SEMI_MAJOR_AXIS = 6678.000000 [km]
ECCENTRICITY = 0.000000
INCLINATION = 23.436363 [deg]
RA_OF_ASC_NODE = 0.000000 [deg]
ARG_OF_PERICENTER = 0.000000 [deg]
TRUE_ANOMALY = 0.000000 [deg]
COMMENT Escaping Earth
MAN_EPOCH_IGNITION = 2018-05-02T00:39:03.955092
MAN_DURATION = 0.000 [s]
MAN_DELTA_MASS = 0.000 [kg]
MAN_REF_FRAME = TNW
MAN_DV_1 = 3.456791 [km/s]
MAN_DV_2 = 0.000000 [km/s]
MAN_DV_3 = 0.000000 [km/s]
""")
planetary_step = timedelta(seconds=180)
solar_step = timedelta(hours=12)
jpl.create_frames()
central = jpl.get_body('Sun')
planets = jpl.get_body('Earth')
opm.propagator = SOIPropagator(solar_step, planetary_step, central, planets)
frames = set()
for orb in opm.iter(stop=timedelta(5)):
frames.add(orb.frame.name)
assert not frames.symmetric_difference(['Sun', 'EME2000'])
# Check if the last point is out of Earth sphere of influence
assert orb.copy(frame='EME2000', form="spherical").r > SOIPropagator.SOI['Earth'].radius
def test_load_interplanetary(jplfiles, orbit, datafile, helper):
create_frames(until="Mars")
orbit.frame = "Mars"
data_opm = loads(datafile("opm_interplanetary"))
helper.assert_orbit(orbit, data_opm)
def test_load_oem_interplanetary(jplfiles, ephem, datafile, helper):
create_frames(until="Mars")
ephem.frame = "Mars"
data = loads(datafile("oem_interplanetary"))
helper.assert_ephem(ephem, data)
def test_load(measureset, datafile):
data = loads(datafile("tdm"))
assert len(measureset) == len(data)
assert measureset.types == data.types
assert measureset.start == data.start
assert measureset.stop == data.stop
assert measureset.sources == data.sources
assert measureset.paths == data.paths
def test_load_user_defined(orbit, datafile, helper):
data_opm = loads(datafile("opm_user_defined"))
helper.assert_orbit(orbit, data_opm)
assert "ccsds_user_defined" in data_opm.complements
subdict = data_opm.complements["ccsds_user_defined"]
assert subdict["FOO"] == "foo enters"
assert subdict["BAR"] == "a bar"
def test_load_oem(ephem, datafile, helper):
data = loads(datafile("oem"))
helper.assert_ephem(ephem, data)
# with raises(CcsdsError):
# loads("\n".join(ref_oem.splitlines()[:15]))
truncated = datafile("oem").split()
for i, line in enumerate(truncated):
if "REF_FRAME" in line:
truncated.pop(i)
break
with raises(CcsdsError) as e:
loads("\n".join(truncated))
assert str(e.value) == "Missing mandatory parameter 'REF_FRAME'"
def test_load_user_defined(tle, datafile, helper):
data_omm = loads(datafile("omm_user_defined"))
helper.assert_orbit(tle, data_omm)
assert "ccsds_user_defined" in data_omm._data
subdict = data_omm._data["ccsds_user_defined"]
assert subdict["FOO"] == "foo enters"
assert subdict["BAR"] == "a bar"
def test_tle(tle, ccsds_format):
# Check that a TLE and its OMM representation are the same
txt = dumps(tle, fmt=ccsds_format)
orb = loads(txt)
new_tle = Tle.from_orbit(orb)
assert str(tle.tle) == str(new_tle)
assert all(tle == orb)
date = Date(2020, 9, 30)
assert all(tle.propagate(date) == orb.propagate(date))
def test_load_opm_man_impulsive(orbit_man, datafile, helper, ccsds_format):
str_data_opm_man = datafile("opm_impulsive_man")
data_opm_man = loads(str_data_opm_man)
helper.assert_orbit(orbit_man, data_opm_man)
list_data_opm_man = str_data_opm_man.splitlines()
if ccsds_format == "kvn":
number = 0
for i, line in enumerate(list_data_opm_man):
if ccsds_format == "kvn" and "MAN_EPOCH_IGNITION" in line:
if number:
list_data_opm_man = list_data_opm_man[:i]
break
else:
number += 1
data = "\n".join(list_data_opm_man)
else:
continue_flag = False
new_data = []
number = 0
for line in list_data_opm_man:
if continue_flag:
if "</maneuverParameters>" in line:
continue_flag = False
continue
if "<maneuverParameters>" in line:
if number:
continue_flag = True
continue
number += 1
new_data.append(line)
data = "\n".join(new_data)
orbit_man.maneuvers = orbit_man.maneuvers[0]
data = loads(data)
helper.assert_orbit(orbit_man, data)
def test_load_opm_man_continuous(orbit_continuous_man, datafile, ccsds_format, helper):
# Tweak the reference to convert impulsive maneuvers into continuous ones
data_continuous_man = datafile("opm_impulsive_man_tnw").splitlines()
for i, line in enumerate(data_continuous_man):
if "MAN_DURATION" in line:
if ccsds_format == "kvn":
data_continuous_man[i] = "MAN_DURATION = 180.000 [s]"
else:
data_continuous_man[i] = ' <MAN_DURATION units="s">180.000</MAN_DURATION>'
data_continuous_man = loads("\n".join(data_continuous_man))
helper.assert_orbit(orbit_continuous_man, data_continuous_man)
def from_text(cls, text):
"""This method is used to parse an orbit from stdin
"""
sats = [cls.from_orb(tle) for tle in Tle.from_string(text)]
if not sats:
try:
orb = ccsds.loads(text)
except ValueError:
raise ValueError("No valid TLE nor CCSDS")
else:
if isinstance(orb, (Ephem, Orbit)):
sats = [cls.from_orb(orb)]
else:
sats = [cls.from_orb(ephem) for ephem in orb]
return sats
def test_soi(jplfiles, method):
planetary_step = timedelta(seconds=180)
solar_step = timedelta(hours=12)
jpl.create_frames()
central = jpl.get_body('Sun')
planets = jpl.get_body('Earth')
if method == "numerical":
propagator = SoINumerical(solar_step, planetary_step, central, planets)
txt = opm_with_man
else:
propagator = SoIAnalytical(central, planets)
propagator.step = solar_step
txt = opm_without_man
opm = ccsds.loads(txt).as_orbit(propagator)
# d, r = [], []
frames = set()
for orb in opm.iter(stop=timedelta(5)):
frames.add(orb.frame.name)
# r.append(orb.copy(frame="EME2000", form="spherical").r)
# d.append(orb.date)
# import matplotlib.pyplot as plt
# plt.plot(d, r)
# plt.show()
assert not frames.symmetric_difference(['Sun', 'EME2000'])
# Check if the last point is out of Earth sphere of influence
assert orb.copy(frame='EME2000',
form="spherical").r > SoINumerical.SOIS['Earth'].radius
def test_load_oem_cov_qsw(ephem_cov, datafile, helper):
ephem_cov[0].cov.frame = "QSW"
data = loads(datafile("oem_cov_qsw"))
helper.assert_ephem(ephem_cov, data)
def test_load_omm(tle, datafile, helper):
data = loads(datafile("omm"))
helper.assert_orbit(tle, data, "TLE")
def test_load_omm_cov(orbit_cov, datafile, helper):
tle_cov = orbit_cov.copy(form="TLE")
data = loads(datafile("omm_cov"))
helper.assert_orbit(tle_cov, data)
def test_load_opm_cov(orbit_cov, datafile, helper):
data_opm = loads(datafile("opm_cov"))
helper.assert_orbit(orbit_cov, data_opm)
def test_load_double_oem(ephem, ephem2, datafile, helper):
data, data2 = loads(datafile("oem_double"))
helper.assert_ephem(ephem, data)
helper.assert_ephem(ephem2, data2)
def test_load_opm_cov_qsw(orbit_cov, datafile, helper):
data_opm = loads(datafile("opm_cov_qsw"))
orbit_cov.cov.frame = "QSW"
helper.assert_orbit(orbit_cov, data_opm, cov_eps=1e-12)
def test_load_oem_cov_tnw(ephem_cov, datafile, helper):
ephem_cov[0].cov.frame = "TNW"
data = loads(datafile("oem_cov_tnw"))
helper.assert_ephem(ephem_cov, data, cov_eps=1e-12)
def test_load_oem_cov(ephem_cov, datafile, helper):
data = loads(datafile("oem_cov"))
helper.assert_ephem(ephem_cov, data)
def test_load_opm_no_unit(orbit, datafile, helper):
data = loads(datafile("opm_no_unit"))
helper.assert_orbit(orbit, data)
def test_load_opm_strange_unit(datafile):
# Dummy units, that aren't specified as valid
with raises(CcsdsError) as e:
loads(datafile("opm_strange_units"))
assert str(e.value) == "Unknown unit 'm/s' for the field X_DOT"
