open-space-toolkit-astrodynamics 11.1.0__py38-none-manylinux2014_x86_64.whl → 12.0.0__py38-none-manylinux2014_x86_64.whl

{open_space_toolkit_astrodynamics-11.1.0.dist-info → open_space_toolkit_astrodynamics-12.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: open-space-toolkit-astrodynamics
-Version: 11.1.0
+Version: 12.0.0
 Summary: Orbit, attitude, access.
 Author: Open Space Collective
 Author-email: contact@open-space-collective.org

{open_space_toolkit_astrodynamics-11.1.0.dist-info → open_space_toolkit_astrodynamics-12.0.0.dist-info}/RECORD

@@ -1,25 +1,25 @@
 ostk/__init__.py,sha256=epnVn2PwdQkUDZ1msqBRO5nEZIOUBIq-IfK3IlNPijE,21
-ostk/astrodynamics/OpenSpaceToolkitAstrodynamicsPy.cpython-38-x86_64-linux-gnu.so,sha256=3bvj1fIMXdepvj34w1YeTpe6TOXiVrxnYBjw3321T_Y,2320224
+ostk/astrodynamics/OpenSpaceToolkitAstrodynamicsPy.cpython-38-x86_64-linux-gnu.so,sha256=1Mx9mtNqk9Pzghl93sq0b7eeNT-wuBhF_qjzqF1jloE,2422656
 ostk/astrodynamics/__init__.py,sha256=3gWyqFIbhAfcdeMhmfBPQPlPQTmaOzm-6flkJe745Zk,251
-ostk/astrodynamics/converters.py,sha256=xr1BDaY2od8IsNq-3isubaxainncgH8_yihZ6Mf38n4,2697
+ostk/astrodynamics/converters.py,sha256=Ld-DLTaqg7pBkIJAcYeoaA-sDOQbR_uksRR-lg9dfXo,3278
 ostk/astrodynamics/dataframe.py,sha256=njimcfT2cvnSOp9eBR1Ej-LuYpXbVieAVEBk2tYW4Vg,18761
 ostk/astrodynamics/display.py,sha256=KiEGsjNftQfoUe-HfZeYpQQQ4TkaEnxtEl6p5_LX5f0,6303
-ostk/astrodynamics/libopen-space-toolkit-astrodynamics.so.11,sha256=AWsoHlLV00oLzGFj4rOY2FyTM71N-GMn7ZLV6ChYlbk,81607000
-ostk/astrodynamics/utilities.py,sha256=Yu5Yydq22gNIHi6ylqeujDENcueb1JfUE6d93h1m9XE,4795
+ostk/astrodynamics/libopen-space-toolkit-astrodynamics.so.12,sha256=Z614bFw3ulUzM58S9gKVtCeYeINU2wMuWNfb_O8qpfk,84586128
+ostk/astrodynamics/utilities.py,sha256=f0ySFhD6X9jhAZW1hLnbLVEOuy3QgVq2C6k4m8MFGYA,6963
 ostk/astrodynamics/viewer.py,sha256=8UxqsvU5wui7gPUwxXaKcIB-509NJiih9Df3mQgXyXY,11776
 ostk/astrodynamics/pytrajectory/__init__.py,sha256=epnVn2PwdQkUDZ1msqBRO5nEZIOUBIq-IfK3IlNPijE,21
-ostk/astrodynamics/pytrajectory/pystate.py,sha256=ByOq8szit74xQ-pnLz0uGGxM6Jqfa17dFJyFB8qIXUg,1033
+ostk/astrodynamics/pytrajectory/pystate.py,sha256=qtGofajIODveyy_g_lEeBqJQ1GddqmzRBVNCExF8pdk,5734
 ostk/astrodynamics/test/__init__.py,sha256=epnVn2PwdQkUDZ1msqBRO5nEZIOUBIq-IfK3IlNPijE,21
 ostk/astrodynamics/test/conftest.py,sha256=fsdUQnLxyfvBzfaSCkgipkPIhkPHchQqbeAro1pF648,2717
 ostk/astrodynamics/test/test_access.py,sha256=MCBsUPtuVm7NgHZR0z0DpWnPZ_qBu4aRhLI2PnRNUYs,3940
-ostk/astrodynamics/test/test_converters.py,sha256=ommyONkpTnhm3GHtCRe_NMtD-SBtb0vD4LGXK6nhNuU,9098
+ostk/astrodynamics/test/test_converters.py,sha256=mFpDD0YM8o356lj91GGIwYdMk2ut6xZFV3uYcgZepMY,8744
 ostk/astrodynamics/test/test_dataframe.py,sha256=IJMOODzTVYtiPxekmltH6lOMArPXbHwSEAl-jg0Ab2g,28414
 ostk/astrodynamics/test/test_display.py,sha256=Ykvw2rUWWw8jsX0Suy11X27bHjwm_ira__xj0ZyHHxw,3672
 ostk/astrodynamics/test/test_event_condition.py,sha256=mhMTH7wAoYFWRYt_8l2d1vjNPrFhVjMAEET4INLCVXY,1472
 ostk/astrodynamics/test/test_import.py,sha256=py_hALBR0IYuUzv9dfgQZzrrLHJIpnyKvt3Oi1XBqCg,1251
 ostk/astrodynamics/test/test_root_solver.py,sha256=hQ8O6g-WP49gZH_H3Rdufv0F0gQorpzJyIcjBGGUQ34,1831
 ostk/astrodynamics/test/test_trajectory.py,sha256=WC9X-O_prHeVLIZlmmYzgkskrs5ZwvmOfhz8yth2lgI,1345
-ostk/astrodynamics/test/test_utilities.py,sha256=kw8quvFTRuoXTbdNdac6IWrjnmA897btNntTMBn-30Q,3614
+ostk/astrodynamics/test/test_utilities.py,sha256=xmRt-5z9-FFYTMQxBpjGrcKP39trbOiH-NLxGcTWOJE,3048
 ostk/astrodynamics/test/test_viewer.py,sha256=rbVAiclzBZ1bS4Zdh4xUNJ-STCN4G0O7Gr8suSPJrSc,3986
 ostk/astrodynamics/test/access/__init__.py,sha256=epnVn2PwdQkUDZ1msqBRO5nEZIOUBIq-IfK3IlNPijE,21
 ostk/astrodynamics/test/access/test_generator.py,sha256=7l_MJCZIhWIyPpZ-XouBXlSd5-BfqFDGVOMMxjoRIHA,8032
@@ -45,7 +45,7 @@ ostk/astrodynamics/test/event_condition/test_logical_condition.py,sha256=09h5TYW
 ostk/astrodynamics/test/event_condition/test_real_condition.py,sha256=tle6HVzMFMIIkfRY7CuaA0mPtw3riJBG_JQkc1L0dpk,1374
 ostk/astrodynamics/test/flight/__init__.py,sha256=epnVn2PwdQkUDZ1msqBRO5nEZIOUBIq-IfK3IlNPijE,21
 ostk/astrodynamics/test/flight/test_maneuver.py,sha256=6LhnNhaiwId-IveUraHnhx8dYxeOgzntP_WPtv9GFjQ,6197
-ostk/astrodynamics/test/flight/test_profile.py,sha256=FOYo-GXGTCtXhKQosXqX6hhrkXPrSyenPkM1lazyEEc,4819
+ostk/astrodynamics/test/flight/test_profile.py,sha256=ZuK2FWWnFzvnJsMgZYeQyG6G0yolUihL4TjGt0BMrZI,7518
 ostk/astrodynamics/test/flight/test_system.py,sha256=MVaE7lJYisH4vmJPD-G-Hw4wNj-Xe8yMksgu8IXCLvg,1322
 ostk/astrodynamics/test/flight/system/__init__.py,sha256=epnVn2PwdQkUDZ1msqBRO5nEZIOUBIq-IfK3IlNPijE,21
 ostk/astrodynamics/test/flight/system/test_propulsion_system.py,sha256=jLUC74YjIQz7APr-kQcdYRYiKm8lfequjosptG29kmI,1964
@@ -58,13 +58,13 @@ ostk/astrodynamics/test/solvers/test_finite_difference_solver.py,sha256=49hS9EF7
 ostk/astrodynamics/test/solvers/test_temporal_condition_solver.py,sha256=ukDuIiEbBBvfqbHfiMIsPk5eyeRsWywCvNT1A3YnmIQ,4862
 ostk/astrodynamics/test/trajectory/__init__.py,sha256=epnVn2PwdQkUDZ1msqBRO5nEZIOUBIq-IfK3IlNPijE,21
 ostk/astrodynamics/test/trajectory/test_local_orbital_frame_direction.py,sha256=d72J50UGG9m0Atei0UQ8sITU1WdJmws5xgUiacLZMbw,2515
-ostk/astrodynamics/test/trajectory/test_local_orbital_frame_factory.py,sha256=33SuZgkXEgYwXhFftRBaSr9Vv60DDJBi5MiXD5H-n6A,2173
+ostk/astrodynamics/test/trajectory/test_local_orbital_frame_factory.py,sha256=hXA23AFZ9RFroBZiGZMxTWGCFJ4fxQpYx50eml1WFjI,3116
 ostk/astrodynamics/test/trajectory/test_model.py,sha256=epnVn2PwdQkUDZ1msqBRO5nEZIOUBIq-IfK3IlNPijE,21
 ostk/astrodynamics/test/trajectory/test_orbit.py,sha256=iKVgScEo1osMIXjON4ToURCgp2LDZV18fKQuy49RktI,6484
 ostk/astrodynamics/test/trajectory/test_propagator.py,sha256=dG31S5FY0NjJ5bnisqJ_HdL7amj_AZAWWLiOmdHfJAc,14233
 ostk/astrodynamics/test/trajectory/test_segment.py,sha256=ACVMYvjlTyCQHZ2-hFEurK08-LQxt6VlcGTMOrgDHaE,9333
 ostk/astrodynamics/test/trajectory/test_sequence.py,sha256=gswWqEBTYvbi5TQjF0DNPkAj5COo9Nb9IK7TdwJ_5C0,12882
-ostk/astrodynamics/test/trajectory/test_state.py,sha256=PZUpGZKMFRDIyDAfKvSMmmOkiFqkquMz8Hgn_nK_SvI,6878
+ostk/astrodynamics/test/trajectory/test_state.py,sha256=IRtdEyiYHCdBXSRmNEKZy355s7i8STYddOzQAMXh5EY,10805
 ostk/astrodynamics/test/trajectory/test_state_builder.py,sha256=PSlXtmGURCrlf0w50tn3dEBRo6p0x4NmIF9gJsNOR3k,4782
 ostk/astrodynamics/test/trajectory/orbit/__init__.py,sha256=epnVn2PwdQkUDZ1msqBRO5nEZIOUBIq-IfK3IlNPijE,21
 ostk/astrodynamics/test/trajectory/orbit/test_model.py,sha256=epnVn2PwdQkUDZ1msqBRO5nEZIOUBIq-IfK3IlNPijE,21
@@ -93,8 +93,8 @@ ostk/astrodynamics/test/trajectory/state/coordinate_subset/test_angular_velocity
 ostk/astrodynamics/test/trajectory/state/coordinate_subset/test_attitude_quaternion.py,sha256=UEu9ApzQLmT87eeISw6_gcHTlX-4b2scIvHz-uE1p_c,393
 ostk/astrodynamics/test/trajectory/state/coordinate_subset/test_cartesian_position.py,sha256=XvHdk1KjacTwtkgx2jUAc9I9N3nvjPDv03FAanpv8jQ,2702
 ostk/astrodynamics/test/trajectory/state/coordinate_subset/test_cartesian_velocity.py,sha256=-kd5TZO5TICihbkqDTew2i_tDpggdpe3Yf23046FATM,3057
-open_space_toolkit_astrodynamics-11.1.0.dist-info/METADATA,sha256=yYiRpTugeOyvQWU2cK_8raeWP7cLw3GtemFlFxudmqU,1916
-open_space_toolkit_astrodynamics-11.1.0.dist-info/WHEEL,sha256=q7bGkHj5-uO8ZVDbDA9JExe7sSDQsY_6S4LJ3oOcV_Y,109
-open_space_toolkit_astrodynamics-11.1.0.dist-info/top_level.txt,sha256=zOR18699uDYnafgarhL8WU_LmTZY_5NVqutv-flp_x4,5
-open_space_toolkit_astrodynamics-11.1.0.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-open_space_toolkit_astrodynamics-11.1.0.dist-info/RECORD,,
+open_space_toolkit_astrodynamics-12.0.0.dist-info/METADATA,sha256=CLVAoU2IU_TzyOATZkppzbeCyWXNA81cWvySMniQCa4,1916
+open_space_toolkit_astrodynamics-12.0.0.dist-info/WHEEL,sha256=q7bGkHj5-uO8ZVDbDA9JExe7sSDQsY_6S4LJ3oOcV_Y,109
+open_space_toolkit_astrodynamics-12.0.0.dist-info/top_level.txt,sha256=zOR18699uDYnafgarhL8WU_LmTZY_5NVqutv-flp_x4,5
+open_space_toolkit_astrodynamics-12.0.0.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+open_space_toolkit_astrodynamics-12.0.0.dist-info/RECORD,,

ostk/astrodynamics/converters.py

@@ -1,5 +1,7 @@
 # Apache License 2.0
 
+import re
+
 from datetime import datetime, timezone
 
 from ostk.physics.time import Instant
@@ -30,7 +32,9 @@ def coerce_to_datetime(value: Instant | datetime | str) -> datetime:
 
         return datetime.fromisoformat(value)
 
-    raise TypeError("Argument must be a datetime, an Instant, or a str.")
+    raise TypeError(
+        f"Argument is of type [{type(value)}]. Must be a datetime, an Instant, or a str."
+    )
 
 
 def coerce_to_instant(value: Instant | datetime | str) -> Instant:
@@ -53,7 +57,9 @@ def coerce_to_instant(value: Instant | datetime | str) -> Instant:
     if isinstance(value, str):
         return coerce_to_instant(coerce_to_datetime(value))
 
-    raise TypeError("Argument must be a datetime, an Instant, or a str.")
+    raise TypeError(
+        f"Argument is of type [{type(value)}]. Must be a datetime, an Instant, or a str."
+    )
 
 
 def coerce_to_iso(value: Instant | datetime | str, timespec: str = "microseconds") -> str:
@@ -77,12 +83,18 @@ def coerce_to_iso(value: Instant | datetime | str, timespec: str = "microseconds
     if isinstance(value, Instant):
         return coerce_to_iso(coerce_to_datetime(value), timespec=timespec)
 
-    raise TypeError("Argument must be a datetime, an Instant, or a str.")
+    raise TypeError(
+        f"Argument is of type [{type(value)}]. Must be a datetime, an Instant, or a str."
+    )
 
 
 def coerce_to_interval(
     value: (
-        Interval | tuple[Instant, Instant] | tuple[datetime, datetime] | tuple[str, str]
+        Interval
+        | tuple[Instant, Instant]
+        | tuple[datetime, datetime]
+        | tuple[str, str]
+        | str
     ),
 ) -> Interval:
     """
@@ -98,6 +110,18 @@ def coerce_to_interval(
     if isinstance(value, Interval):
         return value
 
+    if isinstance(value, str):
+        regex = r"\[(.*) - (.*)\] \[UTC\]"
+        matches = re.search(regex, value)
+
+        if matches:
+            return Interval.closed(
+                start_instant=coerce_to_instant(matches.group(1)),
+                end_instant=coerce_to_instant(matches.group(2)),
+            )
+
+        raise ValueError(f"String [{value}] does not match the expected format.")
+
     return Interval.closed(
         start_instant=coerce_to_instant(value[0]),
         end_instant=coerce_to_instant(value[1]),

ostk/astrodynamics/pytrajectory/pystate.py

@@ -8,6 +8,14 @@ from ostk.physics.coordinate import Frame
 from ostk.physics.time import Instant
 
 from ostk.astrodynamics.trajectory import State, StateBuilder
+from ostk.astrodynamics.trajectory.state import CoordinateSubset
+from ostk.astrodynamics.converters import coerce_to_instant
+from ostk.astrodynamics.trajectory.state.coordinate_subset import (
+    CartesianPosition,
+    CartesianVelocity,
+    AttitudeQuaternion,
+    AngularVelocity,
+)
 
 
 @staticmethod
@@ -33,4 +41,156 @@ def custom_class_generator(frame: Frame, coordinate_subsets: list) -> type:
     return StateTemplateType
 
 
+@staticmethod
+def from_dict(data: dict) -> State:
+    """
+    Create a State from a dictionary.
+    The dictionary must contain the following:
+    - 'timestamp': The timestamp of the state.
+    - 'rx'/'x_eci'/'x_ecef': The x-coordinate of the position.
+    - 'ry'/'y_eci'/'y_ecef': The y-coordinate of the position.
+    - 'rz'/'z_eci'/'z_ecef': The z-coordinate of the position.
+    - 'vx'/'vx_eci'/'vx_ecef': The x-coordinate of the velocity.
+    - 'vy'/'vy_eci'/'vy_ecef': The y-coordinate of the velocity.
+    - 'vz'/'vz_eci'/'vz_ecef': The z-coordinate of the velocity.
+    - 'frame': The frame of the state. Required if 'rx', 'ry', 'rz', 'vx', 'vy', 'vz' are provided.
+    - 'q_B_ECI_x': The x-coordinate of the quaternion.
+    - 'q_B_ECI_y': The y-coordinate of the quaternion.
+    - 'q_B_ECI_z': The z-coordinate of the quaternion.
+    - 'q_B_ECI_s': The s-coordinate of the quaternion.
+    - 'w_B_ECI_in_B_x': The x-coordinate of the angular velocity.
+    - 'w_B_ECI_in_B_y': The y-coordinate of the angular velocity.
+    - 'w_B_ECI_in_B_z': The z-coordinate of the angular velocity.
+
+
+    Args:
+        data (dict): The dictionary.
+
+    Returns:
+        State: The State.
+    """
+
+    instant: Instant = coerce_to_instant(data["timestamp"])
+
+    eci_columns: list[str] = [
+        "rx_eci",
+        "ry_eci",
+        "rz_eci",
+        "vx_eci",
+        "vy_eci",
+        "vz_eci",
+    ]
+    ecef_columns: list[str] = [
+        "rx_ecef",
+        "ry_ecef",
+        "rz_ecef",
+        "vx_ecef",
+        "vy_ecef",
+        "vz_ecef",
+    ]
+    generic_columns: list[str] = [
+        "rx",
+        "ry",
+        "rz",
+        "vx",
+        "vy",
+        "vz",
+    ]
+
+    frame: Frame
+    coordinates: np.ndarray
+
+    coordinate_subsets: list[CoordinateSubset] = [
+        CartesianPosition.default(),
+        CartesianVelocity.default(),
+    ]
+
+    if all(column in data for column in eci_columns):
+        frame = Frame.GCRF()
+        coordinates = np.array(
+            [
+                data["rx_eci"],
+                data["ry_eci"],
+                data["rz_eci"],
+                data["vx_eci"],
+                data["vy_eci"],
+                data["vz_eci"],
+            ]
+        )
+    elif all(column in data for column in ecef_columns):
+        frame = Frame.ITRF()
+        coordinates = np.array(
+            [
+                data["rx_ecef"],
+                data["ry_ecef"],
+                data["rz_ecef"],
+                data["vx_ecef"],
+                data["vy_ecef"],
+                data["vz_ecef"],
+            ]
+        )
+    elif all(column in data for column in generic_columns):
+        if "frame" not in data:
+            raise ValueError("Frame must be provided for generic columns.")
+
+        if isinstance(data["frame"], str):
+            if Frame.exists(data["frame"]):
+                frame = Frame.with_name(data["frame"])
+            else:
+                raise ValueError(f"No frame exists with name [{data['frame']}].")
+        elif isinstance(data["frame"], Frame):
+            frame = data["frame"]
+        else:
+            raise ValueError(f"Invalid frame data [{data['frame']}].")
+
+        coordinates = np.array(
+            [
+                data["rx"],
+                data["ry"],
+                data["rz"],
+                data["vx"],
+                data["vy"],
+                data["vz"],
+            ]
+        )
+    else:
+        raise ValueError("Invalid state data.")
+
+    if all(
+        column in data for column in ["q_B_ECI_x", "q_B_ECI_y", "q_B_ECI_z", "q_B_ECI_s"]
+    ):
+        coordinate_subsets.append(AttitudeQuaternion.default())
+        coordinates = np.append(
+            coordinates,
+            [
+                data["q_B_ECI_x"],
+                data["q_B_ECI_y"],
+                data["q_B_ECI_z"],
+                data["q_B_ECI_s"],
+            ],
+        )
+
+    if all(
+        column in data
+        for column in ["w_B_ECI_in_B_x", "w_B_ECI_in_B_y", "w_B_ECI_in_B_z"]
+    ):
+        coordinate_subsets.append(AngularVelocity.default())
+        coordinates = np.append(
+            coordinates,
+            [
+                data["w_B_ECI_in_B_x"],
+                data["w_B_ECI_in_B_y"],
+                data["w_B_ECI_in_B_z"],
+            ],
+        )
+
+    return State(
+        instant=instant,
+        coordinates=coordinates,
+        frame=frame,
+        coordinate_subsets=coordinate_subsets,
+    )
+
+
+State.from_dict = from_dict
 State.template = custom_class_generator

ostk/astrodynamics/test/flight/test_profile.py

@@ -8,6 +8,7 @@ from ostk.mathematics.geometry.d3.transformation.rotation import Quaternion
 
 from ostk.physics import Environment
 from ostk.physics.time import DateTime
+from ostk.physics.time import Duration
 from ostk.physics.time import Time
 from ostk.physics.time import Scale
 from ostk.physics.time import Instant
@@ -32,6 +33,21 @@ def instant() -> Instant:
     return Instant.date_time(DateTime(2020, 1, 1, 0, 0, 30), Scale.UTC)
 
 
+@pytest.fixture
+def environment() -> Environment:
+    return Environment.default()
+
+
+@pytest.fixture
+def orbit(instant: Instant, environment: Environment) -> Orbit:
+    return Orbit.sun_synchronous(
+        epoch=instant,
+        altitude=Length.kilometers(500.0),
+        local_time_at_descending_node=Time(14, 0, 0),
+        celestial_object=environment.access_celestial_object_with_name("Earth"),
+    )
+
+
 @pytest.fixture
 def transform_model() -> TransformModel:
     def dynamic_provider_generator(instant: Instant):
@@ -78,11 +94,46 @@ def profile(request) -> Profile:
     return Profile(model=model)
 
 
+@pytest.fixture(
+    params=[
+        Profile.Target(Profile.TargetType.GeocentricNadir, Profile.Axis.X),
+        Profile.TrajectoryTarget(
+            Trajectory.position(Position.meters((0.0, 0.0, 0.0), Frame.ITRF())),
+            Profile.Axis.X,
+        ),
+        Profile.OrientationProfileTarget(
+            [
+                (Instant.J2000(), [1.0, 0.0, 0.0]),
+                (Instant.J2000() + Duration.minutes(1.0), [1.0, 0.0, 0.0]),
+                (Instant.J2000() + Duration.minutes(2.0), [1.0, 0.0, 0.0]),
+                (Instant.J2000() + Duration.minutes(3.0), [1.0, 0.0, 0.0]),
+            ],
+            Profile.Axis.X,
+        ),
+        Profile.CustomTarget(
+            lambda state: [1.0, 0.0, 0.0],
+            Profile.Axis.X,
+        ),
+    ]
+)
+def alignment_target() -> Profile.Target:
+    return Profile.Target(Profile.TargetType.GeocentricNadir, Profile.Axis.X)
+
+
+@pytest.fixture
+def clocking_target() -> Profile.Target:
+    return Profile.Target(Profile.TargetType.VelocityECI, Profile.Axis.Y)
+
+
 class TestProfile:
     def test_constructors(self, profile: Profile):
         assert profile is not None
         assert isinstance(profile, Profile)
 
+    def test_profile_target(self, alignment_target: Profile.Target):
+        assert alignment_target is not None
+        assert isinstance(alignment_target, Profile.Target)
+
     def test_get_state_at(self, profile: Profile, instant: Instant):
         state: State = profile.get_state_at(instant)
 
@@ -130,18 +181,62 @@ class TestProfile:
         assert isinstance(profile, Profile)
         assert profile.is_defined()
 
-    def test_nadir_pointing(self):
-        environment = Environment.default()
+    def test_nadir_pointing(
+        self,
+        orbit: Orbit,
+    ):
+        profile: Profile = Profile.nadir_pointing(orbit, Orbit.FrameType.VVLH)
 
-        orbit = Orbit.sun_synchronous(
-            epoch=Instant.date_time(datetime(2020, 1, 1, 0, 0, 0), Scale.UTC),
-            altitude=Length.kilometers(500.0),
-            local_time_at_descending_node=Time(14, 0, 0),
-            celestial_object=environment.access_celestial_object_with_name("Earth"),
+        assert profile is not None
+        assert isinstance(profile, Profile)
+        assert profile.is_defined()
+
+    def test_custom_pointing(
+        self,
+        orbit: Orbit,
+        alignment_target: Profile.Target,
+        clocking_target: Profile.Target,
+    ):
+        profile = Profile.custom_pointing(
+            orbit, Profile.align_and_constrain(alignment_target, clocking_target)
         )
 
-        profile: Profile = Profile.nadir_pointing(orbit, Orbit.FrameType.VVLH)
+        assert profile is not None
+        assert profile.is_defined()
+
+    def test_align_and_constrain(
+        self,
+        orbit: Orbit,
+        instant: Instant,
+        alignment_target: Profile.Target,
+        clocking_target: Profile.Target,
+    ):
+        orientation = Profile.align_and_constrain(
+            alignment_target=alignment_target,
+            clocking_target=clocking_target,
+        )
+
+        assert orientation is not None
+        assert orientation(orbit.get_state_at(instant)) is not None
+
+    def test_custom_pointing(
+        self,
+        orbit: Orbit,
+        alignment_target: Profile.Target,
+        clocking_target: Profile.Target,
+    ):
+        profile = Profile.custom_pointing(
+            orbit, Profile.align_and_constrain(alignment_target, clocking_target)
+        )
+
+        assert profile is not None
+        assert profile.is_defined()
+
+        profile = Profile.custom_pointing(
+            orbit,
+            alignment_target,
+            clocking_target,
+        )
 
         assert profile is not None
-        assert isinstance(profile, Profile)
         assert profile.is_defined()

ostk/astrodynamics/test/test_converters.py

@@ -241,52 +241,49 @@ def test_coerce_to_iso_failure():
         coerce_to_iso("some_ill_formed_iso")
 
 
-def test_coerce_to_interval_success_interval():
-    value = Interval.closed(
-        Instant.date_time(DateTime(2020, 1, 1), Scale.UTC),
-        Instant.date_time(DateTime(2020, 1, 2), Scale.UTC),
-    )
-    assert coerce_to_interval(value) == value
-
-
-def test_coerce_to_interval_success_tuple_instant():
-    value = (
-        Instant.date_time(DateTime(2020, 1, 1), Scale.UTC),
-        Instant.date_time(DateTime(2020, 1, 2), Scale.UTC),
-    )
-    assert coerce_to_interval(value) == Interval.closed(
-        Instant.date_time(DateTime(2020, 1, 1), Scale.UTC),
-        Instant.date_time(DateTime(2020, 1, 2), Scale.UTC),
-    )
-
-
-def test_coerce_to_interval_success_list_instant():
-    value = [
-        Instant.date_time(DateTime(2020, 1, 1), Scale.UTC),
-        Instant.date_time(DateTime(2020, 1, 2), Scale.UTC),
-    ]
-    assert coerce_to_interval(value) == Interval.closed(
-        Instant.date_time(DateTime(2020, 1, 1), Scale.UTC),
-        Instant.date_time(DateTime(2020, 1, 2), Scale.UTC),
-    )
-
-
-def test_coerce_to_interval_success_tuple_datetime():
-    value = (
-        datetime(2020, 1, 1, tzinfo=timezone.utc),
-        datetime(2020, 1, 2, tzinfo=timezone.utc),
-    )
-    assert coerce_to_interval(value) == Interval.closed(
-        Instant.date_time(DateTime(2020, 1, 1), Scale.UTC),
-        Instant.date_time(DateTime(2020, 1, 2), Scale.UTC),
-    )
-
-
-def test_coerce_to_interval_success_list_datetime():
-    value = [
-        datetime(2020, 1, 1, tzinfo=timezone.utc),
-        datetime(2020, 1, 2, tzinfo=timezone.utc),
-    ]
+@pytest.mark.parametrize(
+    "value",
+    [
+        (
+            Interval.closed(
+                Instant.date_time(DateTime(2020, 1, 1), Scale.UTC),
+                Instant.date_time(DateTime(2020, 1, 2), Scale.UTC),
+            )
+        ),
+        (
+            (
+                Instant.date_time(DateTime(2020, 1, 1), Scale.UTC),
+                Instant.date_time(DateTime(2020, 1, 2), Scale.UTC),
+            )
+        ),
+        (
+            [
+                Instant.date_time(DateTime(2020, 1, 1), Scale.UTC),
+                Instant.date_time(DateTime(2020, 1, 2), Scale.UTC),
+            ]
+        ),
+        (
+            (
+                datetime(2020, 1, 1, tzinfo=timezone.utc),
+                datetime(2020, 1, 2, tzinfo=timezone.utc),
+            )
+        ),
+        (
+            [
+                datetime(2020, 1, 1, tzinfo=timezone.utc),
+                datetime(2020, 1, 2, tzinfo=timezone.utc),
+            ]
+        ),
+        (
+            [
+                "2020-01-01T00:00:00Z",
+                "2020-01-02T00:00:00Z",
+            ]
+        ),
+        ("[2020-01-01T00:00:00Z - 2020-01-02T00:00:00Z] [UTC]"),
+    ],
+)
+def test_coerce_to_interval(value):
     assert coerce_to_interval(value) == Interval.closed(
         Instant.date_time(DateTime(2020, 1, 1), Scale.UTC),
         Instant.date_time(DateTime(2020, 1, 2), Scale.UTC),

ostk/astrodynamics/test/test_utilities.py

@@ -1,25 +1,15 @@
 # Apache License 2.0
 
-import pytest
+from datetime import datetime
 
-import ostk.physics as physics
-import ostk.astrodynamics as astrodynamics
-from ostk.astrodynamics import utilities
+from ostk.physics import Environment
+from ostk.physics.time import Instant, Interval
+from ostk.physics.coordinate import Position
+from ostk.physics.coordinate.spherical import LLA, AER
 
-Length = physics.unit.Length
-Angle = physics.unit.Angle
-DateTime = physics.time.DateTime
-Scale = physics.time.Scale
-Instant = physics.time.Instant
-Interval = physics.time.Interval
-Position = physics.coordinate.Position
-Velocity = physics.coordinate.Velocity
-Frame = physics.coordinate.Frame
-LLA = physics.coordinate.spherical.LLA
-AER = physics.coordinate.spherical.AER
-Environment = physics.Environment
-Trajectory = astrodynamics.Trajectory
-State = astrodynamics.trajectory.State
+from ostk.astrodynamics import utilities
+from ostk.astrodynamics import Trajectory
+from ostk.astrodynamics.trajectory import State
 
 
 class TestUtility:
@@ -27,22 +17,16 @@ class TestUtility:
         self,
         state: State,
     ):
-        lla: tuple[float, float, float] = utilities.lla_from_state(state)
+        lla: LLA = utilities.lla_from_state(state)
 
         assert lla is not None
-        assert len(lla) == 3
-        assert isinstance(lla, tuple)
-        assert isinstance(lla[0], float)
-        assert lla[0] >= -90.0 and lla[0] <= 90.0
-        assert isinstance(lla[1], float)
-        assert lla[0] >= -180.0 and lla[0] <= 180.0
-        assert isinstance(lla[2], float)
+        assert isinstance(lla, LLA)
+        assert lla.is_defined()
 
     def test_lla_from_position(
         self,
         instant: Instant,
         position: Position,
-        state: State,
     ):
         lla: LLA = utilities.lla_from_position(position, instant)
 
@@ -50,12 +34,6 @@ class TestUtility:
         assert isinstance(lla, LLA)
         assert lla.is_defined()
 
-        lla_from_state: tuple[float, float, float] = utilities.lla_from_state(state)
-
-        assert lla.get_latitude().in_degrees() == lla_from_state[0]
-        assert lla.get_longitude().in_degrees() == lla_from_state[1]
-        assert lla.get_altitude().in_meters() == lla_from_state[2]
-
     def test_position_from_lla(
         self,
         lla: LLA,
@@ -72,28 +50,24 @@ class TestUtility:
         position: Position,
         environment: Environment,
     ):
-        aer: tuple[float, float, float] = utilities.compute_aer(
-            instant, position, position, environment
-        )
+        aer: AER = utilities.compute_aer(instant, position, position, environment)
 
         assert aer is not None
-        assert len(aer) == 3
-        assert aer[2] == 0.0
+        assert isinstance(aer, AER)
 
-    def test_compute_time_lla_aer_state(
+    def test_compute_time_lla_aer_coordinates(
         self,
         state: State,
         position: Position,
         environment: Environment,
     ):
-        time_lla_aer: float[Instant, float, float, float, float, float, float] = (
-            utilities.compute_time_lla_aer_state(state, position, environment)
+        time_lla_aer: float[datetime, float, float, float, float, float, float] = (
+            utilities.compute_time_lla_aer_coordinates(state, position, environment)
         )
 
         assert time_lla_aer is not None
         assert len(time_lla_aer) == 7
-        assert isinstance(time_lla_aer[0], Instant)
-        assert time_lla_aer[0] == state.get_instant()
+        assert isinstance(time_lla_aer[0], datetime)
         for i in range(1, 7):
             assert isinstance(time_lla_aer[i], float)
 
@@ -102,12 +76,23 @@ class TestUtility:
         interval: Interval,
         trajectory: Trajectory,
     ):
-        output: list[tuple[float, float, float]] = utilities.compute_trajectory_geometry(
-            trajectory, interval
-        )
+        output: list[LLA] = utilities.compute_trajectory_geometry(trajectory, interval)
+
+        assert output is not None
+        assert len(output) == 2
+        assert isinstance(output[0], LLA)
+
+    def test_compute_ground_track(
+        self,
+        interval: Interval,
+        trajectory: Trajectory,
+    ):
+        output: list[LLA] = utilities.compute_ground_track(trajectory, interval)
 
         assert output is not None
         assert len(output) == 2
+        assert isinstance(output[0], LLA)
+        assert output[0].get_altitude().in_meters() <= 15.0
 
     def test_convert_state(self, state: State):
         output: tuple[

ostk/astrodynamics/test/trajectory/test_local_orbital_frame_factory.py

@@ -5,11 +5,11 @@ import pytest
 from ostk.physics.time import Instant
 from ostk.physics.time import DateTime
 from ostk.physics.time import Scale
-from ostk.physics.coordinate import Position
-from ostk.physics.coordinate import Velocity
 from ostk.physics.coordinate import Frame
+from ostk.physics.coordinate import Transform
 
 from ostk.astrodynamics.trajectory import LocalOrbitalFrameFactory
+from ostk.astrodynamics.trajectory import LocalOrbitalFrameTransformProvider
 
 
 @pytest.fixture
@@ -17,6 +17,16 @@ def parent_frame() -> Frame:
     return Frame.GCRF()
 
 
+@pytest.fixture
+def local_orbital_transform_provider_type() -> LocalOrbitalFrameTransformProvider.Type:
+    return LocalOrbitalFrameTransformProvider.Type.VNC
+
+
+@pytest.fixture
+def transform_generator() -> callable:
+    return lambda instant, position, velocity: Transform.identity(Transform.Type.passive)
+
+
 @pytest.fixture
 def local_orbital_frame_factory(parent_frame: Frame) -> LocalOrbitalFrameFactory:
     return LocalOrbitalFrameFactory.VNC(parent_frame)
@@ -74,3 +84,25 @@ class TestLocalOrbitalFrameFactory:
         local_orbital_frame_factory: LocalOrbitalFrameFactory,
     ):
         assert local_orbital_frame_factory.is_defined()
+
+    def test_constructor(
+        self,
+        local_orbital_transform_provider_type: LocalOrbitalFrameTransformProvider.Type,
+        parent_frame: Frame,
+    ):
+        assert (
+            LocalOrbitalFrameFactory.construct(
+                local_orbital_transform_provider_type, parent_frame
+            )
+            is not None
+        )
+
+    def test_custom_constructor(
+        self,
+        transform_generator: callable,
+        parent_frame: Frame,
+    ):
+        assert (
+            LocalOrbitalFrameFactory.construct(transform_generator, parent_frame)
+            is not None
+        )

ostk/astrodynamics/test/trajectory/test_state.py

@@ -2,6 +2,8 @@
 
 import pytest
 
+from datetime import datetime, timezone
+
 import numpy as np
 
 from ostk.mathematics.geometry.d3.transformation.rotation import Quaternion
@@ -177,6 +179,142 @@ class TestState:
         assert custom_state == state
         assert custom_state is not state
 
+    def test_from_dict_with_eci_coordinates(self):
+        data = {
+            "timestamp": datetime.now(timezone.utc),
+            "rx_eci": 7000.0,
+            "ry_eci": 0.0,
+            "rz_eci": 0.0,
+            "vx_eci": 0.0,
+            "vy_eci": 7.5,
+            "vz_eci": 0.0,
+        }
+
+        state: State = State.from_dict(data)
+
+        assert state is not None
+        assert isinstance(state, State)
+        assert state.get_frame() == Frame.GCRF()
+
+    def test_from_dict_with_ecef_coordinates(self):
+        data = {
+            "timestamp": datetime.now(timezone.utc).isoformat(),
+            "rx_ecef": 7000.0,
+            "ry_ecef": 0.0,
+            "rz_ecef": 0.0,
+            "vx_ecef": 0.0,
+            "vy_ecef": 7.5,
+            "vz_ecef": 0.0,
+        }
+
+        state: State = State.from_dict(data)
+
+        assert state is not None
+        assert isinstance(state, State)
+        assert state.get_frame() == Frame.ITRF()
+
+    def test_from_dict_with_generic_coordinates(self):
+        data = {
+            "timestamp": datetime.now(timezone.utc).isoformat(),
+            "rx": 7000.0,
+            "ry": 0.0,
+            "rz": 0.0,
+            "vx": 0.0,
+            "vy": 7.5,
+            "vz": 0.0,
+            "frame": "GCRF",
+        }
+
+        state: State = State.from_dict(data)
+
+        assert state is not None
+        assert isinstance(state, State)
+        assert state.get_frame() == Frame.GCRF()
+
+        with pytest.raises(
+            ValueError, match="Frame must be provided for generic columns."
+        ):
+            data = {
+                "timestamp": datetime.now(timezone.utc).isoformat(),
+                "rx": 7000.0,
+                "ry": 0.0,
+                "rz": 0.0,
+                "vx": 0.0,
+                "vy": 7.5,
+                "vz": 0.0,
+            }
+
+            State.from_dict(data)
+
+        with pytest.raises(ValueError, match="No frame exists with name \\[RANDOM\\]."):
+            data = {
+                "timestamp": datetime.now(timezone.utc).isoformat(),
+                "rx": 7000.0,
+                "ry": 0.0,
+                "rz": 0.0,
+                "vx": 0.0,
+                "vy": 7.5,
+                "vz": 0.0,
+                "frame": "RANDOM",
+            }
+
+            State.from_dict(data)
+
+        with pytest.raises(ValueError, match="Invalid frame data \\[123\\]"):
+            data = {
+                "timestamp": datetime.now(timezone.utc).isoformat(),
+                "rx": 7000.0,
+                "ry": 0.0,
+                "rz": 0.0,
+                "vx": 0.0,
+                "vy": 7.5,
+                "vz": 0.0,
+                "frame": 123,
+            }
+
+            State.from_dict(data)
+
+    def test_from_dict_with_attitude_quaternion(self):
+        data = {
+            "timestamp": datetime.now(timezone.utc).isoformat(),
+            "rx_eci": 7000.0,
+            "ry_eci": 0.0,
+            "rz_eci": 0.0,
+            "vx_eci": 0.0,
+            "vy_eci": 7.5,
+            "vz_eci": 0.0,
+            "q_B_ECI_x": 0.0,
+            "q_B_ECI_y": 0.0,
+            "q_B_ECI_z": 0.0,
+            "q_B_ECI_s": 1.0,
+        }
+
+        state: State = State.from_dict(data)
+
+        assert state is not None
+        assert isinstance(state, State)
+        assert state.get_frame() == Frame.GCRF()
+
+    def test_from_dict_with_angular_velocity(self):
+        data = {
+            "timestamp": datetime.now(timezone.utc).isoformat(),
+            "rx_eci": 7000.0,
+            "ry_eci": 0.0,
+            "rz_eci": 0.0,
+            "vx_eci": 0.0,
+            "vy_eci": 7.5,
+            "vz_eci": 0.0,
+            "w_B_ECI_in_B_x": 0.1,
+            "w_B_ECI_in_B_y": 0.2,
+            "w_B_ECI_in_B_z": 0.3,
+        }
+
+        state: State = State.from_dict(data)
+
+        assert state is not None
+        assert isinstance(state, State)
+        assert state.get_frame() == Frame.GCRF()
+
     def test_comparators(self, state: State):
         assert (state == state) is True
         assert (state != state) is False

ostk/astrodynamics/utilities.py

@@ -1,5 +1,8 @@
 # Apache License 2.0
 
+from datetime import datetime
+from datetime import timezone
+
 from .OpenSpaceToolkitAstrodynamicsPy import *
 
 from ostk.physics import Environment
@@ -7,6 +10,7 @@ from ostk.physics.time import Scale
 from ostk.physics.time import Instant
 from ostk.physics.time import Duration
 from ostk.physics.time import Interval
+from ostk.physics.unit import Length
 from ostk.physics.coordinate.spherical import LLA
 from ostk.physics.coordinate.spherical import AER
 from ostk.physics.coordinate import Position
@@ -15,18 +19,18 @@ from ostk.physics.environment.object.celestial import Earth
 from ostk.physics.environment.gravitational import Earth as EarthGravitationalModel
 
 
-def lla_from_state(state: trajectory.State) -> tuple[float, float, float]:
+def lla_from_state(state: trajectory.State) -> LLA:
     """
     Return latitude (degrees), longitude (degrees), altitude (meters) float list from a state.
-    """
 
-    lla: LLA = lla_from_position(state.get_position(), state.get_instant())
+    Args:
+        state (trajectory.State): A state.
 
-    return (
-        float(lla.get_latitude().in_degrees()),
-        float(lla.get_longitude().in_degrees()),
-        float(lla.get_altitude().in_meters()),
-    )
+    Returns:
+        LLA: The LLA.
+    """
+
+    return lla_from_position(state.get_position(), state.get_instant())
 
 
 def lla_from_position(
@@ -35,6 +39,13 @@ def lla_from_position(
 ) -> LLA:
     """
     Return LLA from position and instant.
+
+    Args:
+        position (Position): A position.
+        instant (Instant): An instant.
+
+    Returns:
+        LLA: The LLA.
     """
 
     if position.access_frame() != Frame.ITRF():
@@ -54,6 +65,12 @@ def lla_from_position(
 def position_from_lla(lla: LLA) -> Position:
     """
     Return position from lla.
+
+    Args:
+        lla (LLA): A LLA.
+
+    Returns:
+        Position: The position.
     """
 
     return Position.meters(
@@ -70,9 +87,18 @@ def compute_aer(
     from_position: Position,
     to_position: Position,
     environment: Environment,
-) -> tuple[float, float, float]:
+) -> AER:
     """
-    Return [azimuth (degrees), elevation (degrees), range (meters)] from Instant and Positions (observer, target).
+    Return AER from Instant and Positions (observer, target).
+
+    Args:
+        instant (Instant): An instant.
+        from_position (Position): An observer position.
+        to_position (Position): A target position.
+        environment (Environment): An environment.
+
+    Returns:
+        AER: The AER.
     """
 
     from_lla: LLA = lla_from_position(from_position, instant)
@@ -83,27 +109,30 @@ def compute_aer(
     from_position_NED: Position = from_position.in_frame(ned_frame, instant)
     to_position_NED: Position = to_position.in_frame(ned_frame, instant)
 
-    aer: AER = AER.from_position_to_position(from_position_NED, to_position_NED, True)
+    return AER.from_position_to_position(from_position_NED, to_position_NED, True)
 
-    return (
-        float(aer.get_azimuth().in_degrees()),
-        float(aer.get_elevation().in_degrees()),
-        float(aer.get_range().in_meters()),
-    )
 
-
-def compute_time_lla_aer_state(
+def compute_time_lla_aer_coordinates(
     state: trajectory.State,
     from_position: Position,
     environment: Environment,
-) -> tuple[Instant, float, float, float, float, float, float]:
+) -> tuple[datetime, float, float, float, float, float, float]:
     """
-    Return [instant, latitude, longitude, altitude, azimuth, elevation, range] from State and observer Position.
+    Return [datetime, latitude, longitude, altitude, azimuth, elevation, range] from State and observer Position.
+
+    Args:
+        state (trajectory.State): A state.
+        from_position (Position): An observer position.
+        environment (Environment): An environment.
+
+    Returns:
+        tuple[datetime, float, float, float, float, float, float]: The [datetime, latitude, longitude, altitude, azimuth, elevation, range].
     """
 
     instant: Instant = state.get_instant()
 
-    lla: tuple[float, float, float] = lla_from_state(state)
+    lla: LLA = lla_from_state(state)
+
     aer: AER = compute_aer(
         instant,
         from_position,
@@ -111,44 +140,102 @@ def compute_time_lla_aer_state(
         environment,
     )
 
-    return (instant, lla[0], lla[1], lla[2], aer[0], aer[1], aer[2])
+    return (
+        instant.get_date_time(Scale.UTC).replace(tzinfo=timezone.utc),
+        float(lla.get_latitude().in_degrees()),
+        float(lla.get_longitude().in_degrees()),
+        float(lla.get_altitude().in_meters()),
+        float(aer.get_azimuth().in_degrees()),
+        float(aer.get_elevation().in_degrees()),
+        float(aer.get_range().in_meters()),
+    )
 
 
 def compute_trajectory_geometry(
     trajectory: Trajectory,
     interval: Interval,
-) -> list[tuple[float, float, float]]:
+    step: Duration = Duration.minutes(1.0),
+) -> list[LLA]:
     """
-    Return [latitude (degrees), longitude (degrees), altitude (meters)] values along a Trajectory during Interval.
+    Return list of LLA along a Trajectory during the Interval at the provided step.
+
+    Args:
+        trajectory (Trajectory): A trajectory.
+        interval (Interval): An interval.
+        step (Duration): A step. Defaults to 1.0 minutes.
+
+    Returns:
+        list[LLA]: The list of LLA.
     """
 
     return [
         lla_from_state(state)
-        for state in trajectory.get_states_at(
-            interval.generate_grid(Duration.minutes(1.0))
-        )
+        for state in trajectory.get_states_at(interval.generate_grid(step))
     ]
 
 
+def compute_ground_track(
+    trajectory: Trajectory,
+    interval: Interval,
+    step: Duration = Duration.minutes(1.0),
+) -> list[LLA]:
+    """
+    Return list of LLA along a Trajectory ground track (altitude set to 10.0 meters) during the Interval at the provided step.
+
+    Args:
+        trajectory (Trajectory): A trajectory.
+        interval (Interval): An interval.
+        step (Duration): A step. Defaults to 1.0 minutes.
+
+    Returns:
+        list[LLA]: The list of LLA.
+    """
+
+    ground_llas: list[LLA] = []
+    for state in trajectory.get_states_at(interval.generate_grid(step)):
+        lla: LLA = lla_from_state(state)
+
+        ground_lla: LLA = LLA(
+            lla.get_latitude(),
+            lla.get_longitude(),
+            Length.meters(10.0),
+        )
+
+        ground_llas.append(ground_lla)
+
+    return ground_llas
+
+
 def convert_state(
     state: trajectory.State,
 ) -> tuple[str, float, float, float, float, float, float, float, float, float]:
     """
     Convert a State into dataframe-ready values.
+    - Instant (str)
+    - Modified Julian Date (float)
+    - Position X [meters] (float)
+    - Position Y [meters] (float)
+    - Position Z [meters] (float)
+    - Velocity X [meters/second] (float)
+    - Velocity Y [meters/second] (float)
+    - Velocity Z [meters/second] (float)
+    - Latitude [degrees] (float)
+    - Longitude [degrees] (float)
+    - Altitude [meters] (float)
+
+    Args:
+        state (trajectory.State): A state.
+
+    Returns:
+        tuple[str, float, float, float, float, float, float, float, float, float]: The dataframe-ready values.
     """
 
-    lla: LLA = LLA.cartesian(
-        state.get_position()
-        .in_frame(Frame.ITRF(), state.get_instant())
-        .get_coordinates(),
-        EarthGravitationalModel.EGM2008.equatorial_radius,
-        EarthGravitationalModel.EGM2008.flattening,
-    )
+    lla: LLA = lla_from_state(state)
 
     instant: Instant = state.get_instant()
 
     return (
-        repr(instant),
+        str(instant.to_string()),
         float(instant.get_modified_julian_date(Scale.UTC)),
         *state.get_position().get_coordinates().transpose().tolist(),
         *state.get_velocity().get_coordinates().transpose().tolist(),