`propagator`¶

This module contains a set of functions for setting up the propagator settings and associated termination conditions in a propagation.

The propagator settings object(s) (derived classed of PropagatorSettings) defined through this module are the container through which all information on the numerical propagation is communicated to the propagation of dynamics (through the create_dynamics_simulator() function), the propagation of variational equations (through the create_variational_equations_solver() function) or an estimation (through the Estimator class constructor).

The propagator settings defined here can be used for propagating single- and multi-arc dynamics, translational dynamics, rotational dynamics, multi-type dynamics, etc. with a large diversity of termination settings options, dependent variables to save and many more options. The full options and structure are described on a dedicated page

In addition to settings for the full propagation, this module also contains function to create settings for the termination of a propagation (stored in instances of PropagationTerminationSettings and its derived class). These objects are passed to the propagator settings function in this module to define the propagation termination.

Functions¶

`translational`(central_bodies, ...)	Function to create translational state propagator settings with stopping condition at given final time.
`rotational`(torque_models, dict[str, ...)	Function to create rotational state propagator settings.
`mass`(bodies_with_mass_to_propagate, ...)	Function to create mass propagator settings
`custom_state`(state_derivative_function, ...)	Function to create custom propagator settings.
`multitype`(propagator_settings_list, ...[, ...])	Function to create multitype propagator settings.
`multi_arc`(single_arc_settings[, ...])	Function to create multi-arc propagator settings.
`hybrid_arc`(single_arc_settings, ...[, ...])	Function to create hybrid-arc propagator settings.
`time_termination`(termination_time[, ...])	Function to create time termination settings for the propagation.
`cpu_time_termination`(cpu_termination_time)	Function to create CPU time termination settings for the propagation.
`dependent_variable_termination`(...[, ...])	Function to create termination settings for the propagation based on a dependent variable.
`custom_termination`(custom_condition)	Function to create custom termination settings for the propagation.
`hybrid_termination`(termination_settings, ...)	Function to create hybrid termination settings for the propagation.
`non_sequential_termination`(...)	Function to create non-sequential termination settings for the propagation.
`first_order_bodycentric_relativistic_time_settings`(...)	Creates settings for first-order barycentric↔body-centered relativistic time conversion.
`bodycentered_to_topocentric_time_settings`(...)	Creates settings for body-centered↔topocentric relativistic time conversion.
`direct_relativistic_time_settings`(...[, ...])	Creates settings for direct metric-based relativistic time conversion.
`add_dependent_variable_settings`(...)	Function to add dependent variables to existing propagator settings.
`custom_termination_with_state_input`(...)	No propagator documentation found.

translational(central_bodies: list[str], acceleration_models: dict[str, dict[str, list[tudat::basic_astrodynamics::AccelerationModel<Eigen::Matrix<double, 3, 1, 0, 3, 1> >]]], bodies_to_integrate: list[str], initial_states: numpy.ndarray[numpy.float64[m, 1]], initial_time: tudatpy.kernel.astro.time_representation.Time, integrator_settings: tudatpy.kernel.dynamics.propagation_setup.integrator.IntegratorSettings, termination_settings: tudatpy.kernel.dynamics.propagation_setup.propagator.PropagationTerminationSettings, propagator: tudatpy.kernel.dynamics.propagation_setup.propagator.TranslationalPropagatorType = <TranslationalPropagatorType.cowell: 0>, output_variables: list[tudatpy.kernel.dynamics.propagation_setup.dependent_variable.SingleDependentVariableSaveSettings] = [], processing_settings: tudatpy.kernel.dynamics.propagation_setup.propagator.SingleArcPropagatorProcessingSettings = None) → tudatpy.kernel.dynamics.propagation_setup.propagator.TranslationalStatePropagatorSettings¶

Function to create translational state propagator settings with stopping condition at given final time.

Function to create translational state propagator settings for N bodies. The propagated state vector is defined by the combination of integrated bodies, and their central body, the combination of which define the relative translational states for which a differential equation is to be solved. The propagator input defines the formulation in which the differential equations are set up The dynamical models are defined by an AccelerationMap (dict[str, list[AccelerationModel]]), as created by create_acceleration_models() function. Details on the usage of this function are discussed in more detail in the user guide.

Parameters:

central_bodies (list[str]) – List of central bodies with respect to which the bodies to be integrated are propagated.
acceleration_models (dict[str, list[AccelerationModel]]) – Set of accelerations acting on the bodies to propagate, provided as acceleration models.
bodies_to_integrate (list[str]) – List of bodies to be numerically propagated, whose order reflects the order of the central bodies.
initial_states (numpy.ndarray) – Initial states of the bodies to integrate (one initial state for each body, concatenated into a single array), provided in the same order as the bodies to integrate. The initial states must be expressed in Cartesian elements, w.r.t. the central body of each integrated body. The states must be defined with the same frame orientation as the global frame orientation of the environment (specified when creating a system of bodies, see for instance get_default_body_settings() and create_system_of_bodies()). Consequently, for N integrated bodies, this input is a vector with size size 6N.
initial_time (astro.time_representation.Time) – Initial epoch of the numerical propagation
integrator_settings (IntegratorSettings) –
Settings defining the numerical integrator that is to be used for the propagation

Note

The sign of the initial time step in the integrator settings defines whether the propagation will be forward or backward in time
termination_settings (PropagationTerminationSettings) – Generic termination settings object to check whether the propagation should be ended.
propagator (TranslationalPropagatorType, default=cowell) – Type of translational propagator to be used (see TranslationalPropagatorType enum).
output_variables (list[SingleDependentVariableSaveSettings], default=[]) – Object to define settings on how the numerical results are to be used, both during the propagation (printing to console) and after propagation (resetting environment)
processing_settings (SingleArcPropagatorProcessingSettings, default=[]) – Object to define how the numerical results are to be processed after the propagation terminates, and which information to print to the console during the propagation. See our user guide for details on all options. If this object is left empty default settings of the SingleArcPropagatorProcessingSettings class are used.

Returns:

Translational state propagator settings object.

Return type:

TranslationalStatePropagatorSettings

rotational(torque_models: dict[str, dict[str, list[tudat::basic_astrodynamics::TorqueModel]]], bodies_to_integrate: list[str], initial_states: numpy.ndarray[numpy.float64[m, 1]], initial_time: tudatpy.kernel.astro.time_representation.Time, integrator_settings: tudatpy.kernel.dynamics.propagation_setup.integrator.IntegratorSettings, termination_settings: tudatpy.kernel.dynamics.propagation_setup.propagator.PropagationTerminationSettings, propagator: tudatpy.kernel.dynamics.propagation_setup.propagator.RotationalPropagatorType = <RotationalPropagatorType.quaternions: 0>, output_variables: list[tudatpy.kernel.dynamics.propagation_setup.dependent_variable.SingleDependentVariableSaveSettings] = [], processing_settings: tudatpy.kernel.dynamics.propagation_setup.propagator.SingleArcPropagatorProcessingSettings = None) → tudatpy.kernel.dynamics.propagation_setup.propagator.RotationalStatePropagatorSettings¶

Function to create rotational state propagator settings.

Function to create rotational state propagator settings for N bodies. The propagated state vector is defined by the integrated bodies, which defines the bodies for which the differential equation defining the evolution of the rotational state between an inertial and body-fixed frame are to be solved. The propagator input defines the formulation in which the differential equations are set up. The dynamical models are defined by a TorqueModelMap, as created by create_torque_models() function. Details on the usage of this function are discussed in more detail in the user guide

Parameters:

torque_models (TorqueModelMap) – Set of torques acting on the bodies to propagate, provided as torque models.
bodies_to_integrate (list[str]) – List of bodies to be numerically propagated, whose order reflects the order of the central bodies.
initial_states (numpy.ndarray) – Initial rotational states of the bodies to integrate (one initial state for each body), provided in the same order as the bodies to integrate. Regardless of the propagator that is selected, the initial rotational state is always defined as four quaternion entries, and the angular velocity of the body, as defined in more detail here.
initial_time (astro.time_representation.Time) – Initial epoch of the numerical propagation
integrator_settings (IntegratorSettings) –
Settings defining the numerical integrator that is to be used for the propagation

Note

The sign of the initial time step in the integrator settings defines whether the propagation will be forward or backward in time
termination_settings (PropagationTerminationSettings) – Generic termination settings object to check whether the propagation should be ended.
propagator (RotationalPropagatorType, default=quaternions) – Type of rotational propagator to be used (see RotationalPropagatorType enum).
output_variables (list[SingleDependentVariableSaveSettings], default=[]) – Object to define settings on how the numerical results are to be used, both during the propagation (printing to console) and after propagation (resetting environment)
processing_settings (SingleArcPropagatorProcessingSettings, default=[]) – Object to define how the numerical results are to be processed after the propagation terminates, and which information to print to the console during the propagation. See our user guide for details on all options. If this object is left empty default settings of the SingleArcPropagatorProcessingSettings class are used.

Returns:

Rotational state propagator settings object.

Return type:

RotationalStatePropagatorSettings

mass(bodies_with_mass_to_propagate: list[str], mass_rate_models: dict[str, list[tudat::basic_astrodynamics::MassRateModel]], initial_body_masses: numpy.ndarray[numpy.float64[m, 1]], initial_time: tudatpy.kernel.astro.time_representation.Time, integrator_settings: tudatpy.kernel.dynamics.propagation_setup.integrator.IntegratorSettings, termination_settings: tudatpy.kernel.dynamics.propagation_setup.propagator.PropagationTerminationSettings, output_variables: list[tudatpy.kernel.dynamics.propagation_setup.dependent_variable.SingleDependentVariableSaveSettings] = [], processing_settings: tudatpy.kernel.dynamics.propagation_setup.propagator.SingleArcPropagatorProcessingSettings = None) → tudatpy.kernel.dynamics.propagation_setup.propagator.MassPropagatorSettings¶

Function to create mass propagator settings

Function to create mass propagator settings It works by providing a key-value mass rate container, containing the list of mass rate settings objects associated to each body. In this function, the dependent variables to save are provided as a list of SingleDependentVariableSaveSettings objects. In this function, the termination conditions are set through the termination settings object provided. Details on the usage of this function are discussed in more detail in the user guide

Parameters:

bodies_with_mass_to_propagate (list[str]) – List of bodies whose mass should be numerically propagated.
mass_rate_models (SelectedMassRateModelMap) – Mass rates associated to each body, provided as a mass rate settings object.
initial_body_masses (numpy.ndarray) – Initial masses of the bodies to integrate (one initial mass for each body), provided in the same order as the bodies to integrate.
initial_time (astro.time_representation.Time) – Initial epoch of the numerical propagation
integrator_settings (IntegratorSettings) –
Settings defining the numerical integrator that is to be used for the propagation

Note

The sign of the initial time step in the integrator settings defines whether the propagation will be forward or backward in time
termination_settings (PropagationTerminationSettings) – Generic termination settings object to check whether the propagation should be ended.
output_variables (list[SingleDependentVariableSaveSettings], default=[]) – Object to define settings on how the numerical results are to be used, both during the propagation (printing to console) and after propagation (resetting environment)
processing_settings (SingleArcPropagatorProcessingSettings, default=[]) – Object to define how the numerical results are to be processed after the propagation terminates, and which information to print to the console during the propagation. See our user guide for details on all options. If this object is left empty default settings of the SingleArcPropagatorProcessingSettings class are used.

Returns:

Mass propagator settings object.

Return type:

SingleArcPropagatorSettings

custom_state(state_derivative_function: Callable[[tudatpy.kernel.astro.time_representation.Time, numpy.ndarray[numpy.float64[m, 1]]], numpy.ndarray[numpy.float64[m, 1]]], initial_state: numpy.ndarray[numpy.float64[m, 1]], initial_time: tudatpy.kernel.astro.time_representation.Time, integrator_settings: tudatpy.kernel.dynamics.propagation_setup.integrator.IntegratorSettings, termination_settings: tudatpy.kernel.dynamics.propagation_setup.propagator.PropagationTerminationSettings, output_variables: list[tudatpy.kernel.dynamics.propagation_setup.dependent_variable.SingleDependentVariableSaveSettings] = [], processing_settings: tudatpy.kernel.dynamics.propagation_setup.propagator.SingleArcPropagatorProcessingSettings = None) → tudatpy.kernel.dynamics.propagation_setup.propagator.CustomStatePropagatorSettings¶

Function to create custom propagator settings.

Function to create custom propagator settings. By using this propagator, the user can define their own differential equation to be solved, rather than have the differential equation be defined by accelerations (as is the case for translational state) or torques (as is the case for rotational state). This permits the user additional flexibility to define their own model by adding (for instance) the integration of co-states to the propagation without having to implement the governing dynamics into Tudat. This propagator requires a function of the form \(\frac{d\mathbf{x}}{dt}=\mathbf{f}(t,\mathbf{x})\), with \(t\) the current time, \(\mathbf{x}\) the current state, and \(\mathbf{f}\) the state derivative function. This function can depend on any quantities of the user’s choosing, for details on how to link the properties of the environment to this function, see our user guide.

Parameters:

state_derivative_function (callable[[astro.time_representation.Time, numpy.ndarray[numpy.float64[m, 1]]], numpy.ndarray[numpy.float64[m, 1]]])) – Function \(\mathbf{f}\) (ser above) to compute the derivative of the current custom state
initial_state (numpy.ndarray) – Initial value of the propagated custom state
initial_time (astro.time_representation.Time) – Initial epoch of the numerical propagation
integrator_settings (IntegratorSettings) –
Settings defining the numerical integrator that is to be used for the propagation

Note

The sign of the initial time step in the integrator settings defines whether the propagation will be forward or backward in time
termination_settings (PropagationTerminationSettings) – Generic termination settings object to check whether the propagation should be ended.
output_variables (list[SingleDependentVariableSaveSettings], default=[]) – Object to define settings on how the numerical results are to be used, both during the propagation (printing to console) and after propagation (resetting environment)
processing_settings (SingleArcPropagatorProcessingSettings, default=[]) – Object to define how the numerical results are to be processed after the propagation terminates, and which information to print to the console during the propagation. See our user guide for details on all options. If this object is left empty default settings of the SingleArcPropagatorProcessingSettings class are used.

Returns:

Custom propagator settings object.

Return type:

SingleArcPropagatorSettings

multitype(propagator_settings_list: list[tudatpy.kernel.dynamics.propagation_setup.propagator.SingleArcPropagatorSettings], integrator_settings: tudatpy.kernel.dynamics.propagation_setup.integrator.IntegratorSettings, initial_time: tudatpy.kernel.astro.time_representation.Time, termination_settings: tudatpy.kernel.dynamics.propagation_setup.propagator.PropagationTerminationSettings, output_variables: list[tudatpy.kernel.dynamics.propagation_setup.dependent_variable.SingleDependentVariableSaveSettings] = [], processing_settings: tudatpy.kernel.dynamics.propagation_setup.propagator.SingleArcPropagatorProcessingSettings = None) → tudatpy.kernel.dynamics.propagation_setup.propagator.MultiTypePropagatorSettings¶

Function to create multitype propagator settings.

Function to create multitype propagator settings. It works by providing a list of SingleArcPropagatorSettings objects. When using this function, only the termination and output settings provided here are used, any such settings in the constituent propagator settings are ignored Details on the usage of this function are discussed in more detail in the user guide

Note

The propagated state contains the state types in the following order: Translational ( C ), Rotational ( R ), Mass ( M ), and Custom ( C ). When propagating two bodies, an example of what the output state would look like is for instance: [ T Body 1, T Body 2, R Body 1, R Body 2, M Body 1, M Body 2 ]

Parameters:

propagator_settings_list (list[SingleArcPropagatorSettings]) – List of SingleArcPropagatorSettings objects to use.
integrator_settings (IntegratorSettings) –
Settings defining the numerical integrator that is to be used for the propagation

Note

The sign of the initial time step in the integrator settings defines whether the propagation will be forward or backward in time
initial_time (float) – Initial epoch of the numerical propagation
termination_settings (PropagationTerminationSettings) – Generic termination settings object to check whether the propagation should be ended.
output_variables (list[SingleDependentVariableSaveSettings], default=[]) – Object to define settings on how the numerical results are to be used, both during the propagation (printing to console) and after propagation (resetting environment)
processing_settings (SingleArcPropagatorProcessingSettings, default=[]) – Object to define how the numerical results are to be processed after the propagation terminates, and which information to print to the console during the propagation. See our user guide for details on all options. If this object is left empty default settings of the SingleArcPropagatorProcessingSettings class are used.

Returns:

Multi-type propagator settings object.

Return type:

MultiTypePropagatorSettings

multi_arc(single_arc_settings: list[tudatpy.kernel.dynamics.propagation_setup.propagator.SingleArcPropagatorSettings], transfer_state_to_next_arc: bool = False, processing_settings: tudatpy.kernel.dynamics.propagation_setup.propagator.MultiArcPropagatorProcessingSettings = None) → tudatpy.kernel.dynamics.propagation_setup.propagator.MultiArcPropagatorSettings¶

Function to create multi-arc propagator settings.

Function to create multi-arc propagator settings. It works by providing separate settings for each arc in a list.

Parameters:

single_arc_settings (list[SingleArcPropagatorSettings]) – List of SingleArcPropagatorSettings objects to use, one for each arc.
transfer_state_to_next_arc (bool, default=False) – Object to define settings on how the numerical results are to be used, both during the propagation (printing to console) and after propagation (resetting environment)

Returns:

Multi-arc propagator settings object.

Return type:

MultiArcPropagatorSettings

hybrid_arc(single_arc_settings: tudatpy.kernel.dynamics.propagation_setup.propagator.SingleArcPropagatorSettings, multi_arc_settings: tudatpy.kernel.dynamics.propagation_setup.propagator.MultiArcPropagatorSettings, processing_settings: tudatpy.kernel.dynamics.propagation_setup.propagator.HybridArcPropagatorProcessingSettings = None) → tudatpy.kernel.dynamics.propagation_setup.propagator.HybridArcPropagatorSettings¶

Function to create hybrid-arc propagator settings.

Function to create hybrid-arc propagator settings (i.e., a combination of single- and multi-arc dynamics).

Parameters:

single_arc_settings (SingleArcPropagatorSettings) – SingleArcPropagatorSettings object to use for the propagation.
multi_arc_settings (MultiArcPropagatorSettings) – Object to define settings on how the numerical results are to be used, both during the propagation (printing to console) and after propagation (resetting environment)

Returns:

Hybrid-arc propagator settings object.

Return type:

HybridArcPropagatorSettings

time_termination(termination_time: float | SupportsIndex, terminate_exactly_on_final_condition: bool = False) → tudatpy.kernel.dynamics.propagation_setup.propagator.PropagationTerminationSettings¶

Function to create time termination settings for the propagation.

Function to create time termination settings for the propagation. The propagation is stopped when the final time provided is reached. Note that the termination time is set as the absolute time (in seconds since J2000), not the time since the start of the propagation. Depending on the sign of the time step of the numerical integrator, the termination time will be treated as an upper bound (for positive time step) or lower bound (for negative time step). The simulator will normally finish the final time-step, which may cause the termination time to be slightly exceeded. This behaviour can be suppressed by providing the optional input argument terminate_exactly_on_final_condition=True, in which case the final propagation step will be exactly on the specified time.

Parameters:

termination_time (float) – Final time of the propagation.
terminate_exactly_on_final_condition (bool, default=False) – Denotes whether the propagation is to terminate exactly on the final condition, or whether it is to terminate on the first step where it is violated.

Returns:

Time termination settings object.

Return type:

PropagationTimeTerminationSettings

Notes

To reach exactly the final time, state derivative function evaluations beyond the final time may be required by the propagator. Reaching the final condition exactly is an iterative process and very minor deviations from the specified final condition can occur.

Examples

In this example, we set the termination time of the propagation equal to one day (86400 s).

# Set termination time (in seconds since J2000)
termination_time = simulation_start_epoch + 86400.0
# Create time termination settings
termination_settings = propagation_setup.propagator.time_termination( termination_time )

cpu_time_termination(cpu_termination_time: float | SupportsIndex) → tudatpy.kernel.dynamics.propagation_setup.propagator.PropagationTerminationSettings¶

Function to create CPU time termination settings for the propagation.

Function to create CPU time termination settings for the propagation. The propagation is stopped when the final CPU time provided is reached.

Parameters:: cpu_termination_time (float) – Maximum CPU time for the propagation.
Returns:: CPU time termination settings object.
Return type:: PropagationCPUTimeTerminationSettings

Examples

In this case, we set a CPU time termination setting so that the propagation stops once your computer has run it for 120 seconds.

# Set CPU time to 120 seconds
cpu_termination_time = 120.0
# Create termination settings
termination_settings = propagation_setup.propagator.cpu_time_termination( cpu_termination_time )

dependent_variable_termination(dependent_variable_settings: tudatpy.kernel.dynamics.propagation_setup.dependent_variable.SingleDependentVariableSaveSettings, limit_value: float | SupportsIndex, use_as_lower_limit: bool, terminate_exactly_on_final_condition: bool = False, termination_root_finder_settings: tudatpy.kernel.math.root_finders.RootFinderSettings = None) → tudatpy.kernel.dynamics.propagation_setup.propagator.PropagationTerminationSettings¶

Function to create termination settings for the propagation based on a dependent variable.

Function to create termination settings for the propagation based on the value of a dependent variable. The propagation is stopped when a provided upper or lower limit value is reached. The simulator will normally finish the final time-step, which may cause the dependent variable to be slightly exceeded. This behaviour can be suppressed by providing the optional input argument terminate_exactly_on_final_condition=True, in which case the final propagation step will be exactly on the specified dependent variable value.

Parameters:

dependent_variable_settings (SingleDependentVariableSaveSettings) – Dependent variable object to be used as termination setting.
limit_value (float) – Limit value of the dependent variable; if reached, the propagation is stopped.
use_as_lower_limit (bool, default=False) – Denotes whether the limit value should be used as lower or upper limit.
terminate_exactly_on_final_condition (bool, default=False) – Denotes whether the propagation is to terminate exactly on the final condition, or whether it is to terminate on the first step where it is violated.
termination_root_finder_settings (RootFinderSettings, default=None) – Settings object to create root finder used to converge on exact final condition.

Returns:

Dependent variable termination settings object.

Return type:

PropagationDependentVariableTerminationSettings

Notes

To reach exactly the final dependent variable value, state derivative function evaluations beyond the final time may be required by the propagator. Reaching the final condition exactly is an iterative process and very minor deviations from the specified final condition can occur.

Examples

Below, an example is shown for termination on a given vehicle altitude. The exact termination condition is defined in the termination_settings. The propagation is terminated once the lower limit of 25 km in altitude is reached (as the use_as_lower_limit is set to True). To use the above settings to terminate when an upper limit of 25 km is reached, set this boolean to False. In this example, we also want to stop exactly at 25 km, so we set terminate_exactly_on_final_condition to True, and we specify termination_root_finder_settings.

# Set dependent variable to be checked as termination setting
termination_variable = propagation_setup.dependent_variable.altitude(
    "Spacecraft", "Earth"
)
# Create termination settings
termination_settings = propagation_setup.propagator.dependent_variable_termination(
    dependent_variable_settings=termination_variable,
    limit_value=25.0e3,
    use_as_lower_limit=True,
    terminate_exactly_on_final_condition=True,
    termination_root_finder_settings=root_finders.secant(
        maximum_iteration=5,
        maximum_iteration_handling=root_finders.MaximumIterationHandling.accept_result,
    ),
)

custom_termination(custom_condition: Callable[[float | SupportsIndex], bool]) → tudatpy.kernel.dynamics.propagation_setup.propagator.PropagationTerminationSettings¶

Function to create custom termination settings for the propagation.

Function to create custom termination settings for the propagation. The propagation is stopped when the condition provided is verified. This custom function should take the current time as input and output a Boolean. It can use internal variables and calculations, for example retrieved from the environment.

Parameters:: custom_condition (callable[[Time], bool]) – Function of time (independent variable) which is called during the propagation and returns a boolean value denoting whether the termination condition is verified.
Returns:: Custom termination settings object.
Return type:: PropagationCustomTerminationSettings

Examples

# Create custom function returning a bool
def custom_termination_function(time):  # time is a Time object
    # Do something
    set_condition = ...
    # Return bool
    return set_condition

# Create termination settings
termination_settings = propagation_setup.propagator.custom_termination(
  custom_termination_function)

hybrid_termination(termination_settings: list[tudatpy.kernel.dynamics.propagation_setup.propagator.PropagationTerminationSettings], fulfill_single_condition: bool) → tudatpy.kernel.dynamics.propagation_setup.propagator.PropagationTerminationSettings¶

Function to create hybrid termination settings for the propagation.

Function to create hybrid termination settings for the propagation. This function can be used to define that all conditions or a single condition of the conditions provided must be met to stop the propagation. Each termination condition should be created according to each individual function and then added to a list of termination conditions.

Note

When using this option, the termination_details of the simulation results object (obtained from here after a propagation: propagation_results) is of derived type PropagationTerminationDetailsFromHybridCondition.

See the was_condition_met_when_stopping attribute for an example of how to retrieve which condition was met when the propagation was terminated.

Parameters:

termination_settings (list[PropagationTerminationSettings]) – List of single PropagationTerminationSettings objects to be checked during the propagation.
fulfill_single_condition (bool) – Whether only a single condition of those provided must be met to stop the propagation (true) or all of them simultaneously (false).

Returns:

Hybrid termination settings object.

Return type:

PropagationHybridTerminationSettings

Examples

In the following example, the propagation will terminate once one of the three termination settings (simulated time, cpu time, altitude) has reached the imposed limit value. The fulfill_single_condition variable determines whether the propagation terminates once a single condition is met (if True, as above) or once all conditions are met (False).

# Set simulation termination time
termination_time = simulation_start_epoch + 86400.0
# Create simulation time termination setting
time_termination_settings = propagation_setup.propagator.time_termination(
    termination_time
)

# Set dependent variable termination setting
termination_variable = propagation_setup.dependent_variable.altitude(
    "Spacecraft", "Earth"
)
# Create altitude-based termination setting
altitude_termination_settings = (
    propagation_setup.propagator.dependent_variable_termination(
        dependent_variable_settings=termination_variable,
        limit_value=25.0e3,
        use_as_lower_limit=True,
    )
)

# Set cpu termination time
cpu_termination_time = 120.0
# Create cpu time termination setting
cpu_termination_settings = propagation_setup.propagator.cpu_time_termination(
    cpu_termination_time
)

# Store termination setting objects in a list
termination_settings_list = [
    time_termination_settings,
    altitude_termination_settings,
    cpu_termination_settings,
]

# Create hybrid termination settings
termination_settings = propagation_setup.propagator.hybrid_termination(
    termination_settings_list, fulfill_single_condition=True
)

non_sequential_termination(forward_termination_settings: tudatpy.kernel.dynamics.propagation_setup.propagator.PropagationTerminationSettings, backward_termination_settings: tudatpy.kernel.dynamics.propagation_setup.propagator.PropagationTerminationSettings) → tudatpy.kernel.dynamics.propagation_setup.propagator.PropagationTerminationSettings¶

Function to create non-sequential termination settings for the propagation.

Function to create non-sequential termination settings for the propagation. By using this setting, the propagation of the dynamics along an arc is propagated starting from some point (initial time and state) along the arc, and then propagating both forwards and backwards in time. This termination condition allows the user to specify termination conditions for the propagations forwards and backwards in time. These two propagations are then internally performed separately, but the resulting propagation results provide the concatenated results from the two and effectively constitute By using this function, the propagation controlled by the forward_termination_settings automatically has a positive time step, while the backward_termination_settings automatically has a negative time step. By definition, both will start from the same initial time and state, which are provided in the propagation settings

Parameters:

forward_termination_settings (PropagationTerminationSettings) – Propagation termination setting for the forward-in-time propagation
backward_termination_settings (PropagationTerminationSettings) – Propagation termination setting for the backwards-in-time propagation

Returns:

Termination settings object for forward- and backwards-in-time propagation.

Return type:

PropagationTerminationSettings

first_order_bodycentric_relativistic_time_settings(body: str, perturbing_bodies: list[str], initial_time: tudatpy.kernel.astro.time_representation.Time, integrator_settings: tudatpy.kernel.dynamics.propagation_setup.integrator.IntegratorSettings, termination_settings: tudatpy.kernel.dynamics.propagation_setup.propagator.PropagationTerminationSettings, spherical_harmonic_expansions: dict[str, tuple[int | SupportsIndex, int | SupportsIndex]] = {}) → tudatpy.kernel.dynamics.propagation_setup.propagator.FirstOrderBodycentricRelativisticTimePropagatorSettings¶

Creates settings for first-order barycentric↔body-centered relativistic time conversion.

Creates settings for the first-order time-rate model used to convert between barycentric and body-centered coordinate time scales (for example TCB↔TCG), using only the \(\mathcal{O}(1/c^2)\) contribution. The time-scale notation used here is:

\[t_B=\text{barycentric coordinate time},\qquad t_P=\text{planet-centered coordinate time},\qquad \tau=\text{proper time of an observer}.\]

The propagated differential quantity is:

\[\frac{d}{dt_B}\Delta_{BC} = -\frac{1}{c^2}\left(\frac{v_C^2}{2}+w_{0,\mathrm{ext}}\right).\]

In Tudat, the external scalar potential term is evaluated as

\[\begin{split}w_{0,\mathrm{ext}}=\sum_{i=1}^{N} w_{0,i},\qquad w_{0,i}= \begin{cases} \mu_i/R_i, & \text{point-mass contribution},\\ U_i^{\mathrm{SH}}, & \text{if spherical-harmonic contributions are configured}. \end{cases}\end{split}\]

with

\[\Delta_{BC}=t_P-t_B,\qquad t\equiv t_B,\]

where \(c\) is the speed of light, \(N\) is the number of perturbing bodies included in the sums, \(\mathbf{v}_C\) is the central-body barycentric velocity vector, \(v_C=\lVert\mathbf{v}_C\rVert\) is its magnitude, \(\mu_i=GM_i\) is the gravitational parameter of perturbing body \(i\), \(R_i=\lVert\mathbf{r}_C-\mathbf{r}_i\rVert\) is the distance from the central body to body \(i\), and \(U_i^{\mathrm{SH}}\) is the configured spherical-harmonic potential contribution.

Parameters:

body (str) – Name of the central body that defines the body-centered coordinate time scale.
perturbing_bodies (list[str]) – Bodies whose gravity contributes to the external potential terms in the conversion.
initial_time (float) – Initial time (seconds since J2000).
integrator_settings (IntegratorSettings) – Numerical integrator settings used to propagate the relativistic time state.
termination_settings (PropagationTerminationSettings) – Termination settings for the relativistic time-state propagation.
spherical_harmonic_expansions (dict[str, tuple[int, int]], optional) – Optional map from body name to (degree, order) defining spherical-harmonic gravity expansions in the potential evaluation.

Returns:

Settings object for this first-order barycentric↔body-centered relativistic time conversion model.

Return type:

FirstOrderBodycentricRelativisticTimePropagatorSettings

bodycentered_to_topocentric_time_settings(reference_point_id: tuple[str, str], use_acceleration_term: bool, maximum_spherical_harmonic_degree: int | SupportsIndex, use_time_dependent_body_fixed_position: bool, topocentric_external_bodies: list[str], initial_state: Annotated[numpy.typing.ArrayLike, numpy.float64], initial_time: tudatpy.kernel.astro.time_representation.Time, integrator_settings: tudatpy.kernel.dynamics.propagation_setup.integrator.IntegratorSettings, termination_settings: tudatpy.kernel.dynamics.propagation_setup.propagator.PropagationTerminationSettings) → tudatpy.kernel.dynamics.propagation_setup.propagator.BodycenteredToTopocentricTimePropagatorSettings¶

Creates settings for body-centered↔topocentric relativistic time conversion.

Creates settings for the proper-time conversion at a local reference point (for example a ground station), starting from a body-centered coordinate time scale. The implemented model follows Turyshev and Toth [24], Eq. (22). The time-scale notation used here is:

\[t_B=\text{barycentric coordinate time},\qquad t_P=\text{planet-centered coordinate time},\qquad \tau=\text{proper time of an observer}.\]

The propagated differential quantity is:

\[\frac{d}{dt_P}\left(\tau-t_P\right) = -\frac{1}{c^2}\left[ \frac{1}{2}v_0^2 +U_E(\mathbf{y}) +\sum_{b\neq E}\frac{GM_b}{2r_{bE}^3}\left(3(\mathbf{n}_{bE}\cdot\mathbf{y})^2-\mathbf{y}^2\right) +\mathbf{a}_E\cdot\mathbf{y} \right].\]

with

\[\Delta_{PT}=\tau-t_P,\]

where \(\tau\) is proper time at the reference point, \(c\) is the speed of light, \(\mathbf{v}_0\) is the reference-point velocity vector in the body-centered frame, \(v_0=\lVert\mathbf{v}_0\rVert\) is its magnitude, \(U_E(\mathbf{y})\) is the body gravitational potential at the reference-point position \(\mathbf{y}\) (with \(\mathbf{y}^2=\mathbf{y}\cdot\mathbf{y}\)), \(G\) is the gravitational constant, \(M_b\) is the mass of external body \(b\), \(r_{bE}\) is the distance between external body \(b\) and the central body \(E\), \(\mathbf{n}_{bE}\) is the unit vector from \(E\) to \(b\), and \(\mathbf{a}_E\) is the barycentric acceleration of the central body; \(\cdot\) denotes the Euclidean inner product.

Parameters:

reference_point_id (tuple[str, str]) – (body_name, reference_point_name) identifier of the topocentric reference point (for example ("Earth", "Graz")).
use_acceleration_term (bool) – Whether to include the \(\mathbf{a}_E\cdot\mathbf{y}\) acceleration term.
maximum_spherical_harmonic_degree (int) – Maximum spherical-harmonic degree used in the body gravity contribution.
use_time_dependent_body_fixed_position (bool) – Whether the reference-point body-fixed position is treated as time-dependent.
topocentric_external_bodies (list[str]) – External bodies used in the third-body tidal potential term.
initial_state (numpy.ndarray) – Initial state of the relativistic time variables. Accepted shapes are [m], [m,1] or [1,m].
initial_time (float) – Initial time (seconds since J2000).
integrator_settings (IntegratorSettings) – Numerical integrator settings used to propagate the relativistic time state.
termination_settings (PropagationTerminationSettings) – Termination settings for the relativistic time-state propagation.

Returns:

Settings object for this body-centered↔topocentric relativistic time conversion model.

Return type:

BodycenteredToTopocentricTimePropagatorSettings

direct_relativistic_time_settings(reference_point_id: tuple[str, str], initial_time: tudatpy.kernel.astro.time_representation.Time, integrator_settings: tudatpy.kernel.dynamics.propagation_setup.integrator.IntegratorSettings, termination_settings: tudatpy.kernel.dynamics.propagation_setup.propagator.PropagationTerminationSettings, distance_scaling_factor: float | SupportsIndex = 1.0, dependent_variables_to_save: list[tudatpy.kernel.dynamics.propagation_setup.dependent_variable.SingleDependentVariableSaveSettings] = [], output_settings: tudatpy.kernel.dynamics.propagation_setup.propagator.SingleArcPropagatorProcessingSettings = None) → tudatpy.kernel.dynamics.propagation_setup.propagator.DirectRelativisticTimePropagatorSettings¶

Creates settings for direct metric-based relativistic time conversion.

Creates settings for propagating the proper-time difference of a reference point directly from a space-time metric. The metric used by this model is the base metric stored in space_time_properties, which is configured through space_time_settings. Metric and space-time settings are defined in the space_time module. The time-scale notation used here is:

\[t_B=\text{barycentric coordinate time},\qquad t_P=\text{planet-centered coordinate time},\qquad \tau=\text{proper time of an observer}.\]

The propagated differential quantity is

\[\frac{d}{dt_B}\Delta_{\mathrm{direct}}=\frac{d\tau}{dt_B}-1,\qquad \Delta_{\mathrm{direct}}\equiv\tau-t_B.\]

In Tudat, for this model, the proper-time rate is evaluated from the covariant metric perturbation with a second-order square-root expansion:

\[\frac{d\tau}{dt_B}-1=-\frac{1}{2}\varepsilon-\frac{1}{8}\varepsilon^2,\qquad \varepsilon=\frac{1}{c^2}\left(u^\mu h_{\mu\nu}u^\nu+v^2\right),\qquad u^\mu=(c,\mathbf{v}).\]

The distance scaling factor is denoted by \(L\) (default \(L=1\)). In terms of scaled spatial quantities:

\[\mathbf{r}^{(L)} = L\,\mathbf{r},\qquad \mu^{(L)} = L\,\mu,\qquad L=1\ \text{(default)}.\]

where \(\tau\) is proper time at the reference point, \(t_B\) is barycentric coordinate time, \(c\) is the speed of light, \(\varepsilon\) is the dimensionless expansion quantity defined above, \(h_{\mu\nu}\) is the covariant metric perturbation tensor at the reference-point state, \(u^\mu\) is the space-time coordinate-velocity 4-vector, \(\mathbf{v}\) is the 3-velocity vector of the reference point, \(v=\lVert\mathbf{v}\rVert\), and \(\mu,\nu\in\{0,1,2,3\}\) are space-time indices.

Parameters:

reference_point_id (tuple[str, str]) – (body_name, reference_point_name) identifier of the propagated point. Use an empty reference-point name to use the body origin.
initial_time (float) – Initial time (seconds since J2000).
integrator_settings (IntegratorSettings) – Numerical integrator settings used to propagate the relativistic time state.
termination_settings (PropagationTerminationSettings) – Termination settings for the relativistic time-state propagation.
distance_scaling_factor (float, optional) – Distance scaling factor \(L\) (default 1.0).
dependent_variables_to_save (list[SingleDependentVariableSaveSettings], optional) – Dependent variables to save during propagation.
output_settings (SingleArcPropagatorProcessingSettings, optional) – Output/processing settings for the propagated results. If omitted, default single-arc processing settings are used.

Returns:

Settings object for this direct metric-based relativistic time conversion model.

Return type:

DirectRelativisticTimePropagatorSettings

add_dependent_variable_settings(dependent_variable_settings: list[tudatpy.kernel.dynamics.propagation_setup.dependent_variable.SingleDependentVariableSaveSettings], propagator_settings: tudat::propagators::SingleArcPropagatorSettings<double, double>) → None¶

Function to add dependent variables to existing propagator settings.

Function to add dependent variables to existing SingleArcPropagatorSettings object. This function is added as an alternative to the regular manner in which to defined dependent variables (use of input to functions for single-arc propagator settings translational(), rotational(), mass(), multitype()). Typically, this function is used to modify existing propagator settings in a loop when running multiple simulations

Parameters:

dependent_variable_settings (List[ SingleDependentVariableSaveSettings ]) – List of dependent variable settings that are to be added to propagator settings. Note that this function adds settings, and does not replace any existing settings (nor does it check for duplicate settings).
propagator_settings (SingleArcPropagatorSettings) – Propagator settings to which the additional dependent variables settings are to be added.

Returns:

None

Return type:

None

custom_termination_with_state_input(custom_condition: Callable[[float | SupportsIndex, numpy.ndarray[numpy.float64[m, n]]], bool]) → tudatpy.kernel.dynamics.propagation_setup.propagator.PropagationTerminationSettings¶: No propagator documentation found.

Enumerations¶

`TranslationalPropagatorType`	Enumeration of available translational propagator types.
`RotationalPropagatorType`	Enumeration of available rotational propagator types.
`StateType`	Enumeration of available integrated state types.
`PropagationTerminationTypes`	Enumeration of possible propagation termination types

class TranslationalPropagatorType¶

Bases: pybind11_object

Enumeration of available translational propagator types.

Members:

undefined_translational_propagator :

cowell :

Propagation of Cartesian elements (state vector size 6), without any transformations

encke :

Propagation of the difference in Cartesian elements of the orbit w.r.t. an unperturbed reference orbit. The reference orbit is generated from the initial state/central body, and not updated during the propagation (see Wakker [27])

gauss_keplerian :

Propagation of Keplerian elements (state vector size 6), with true anomaly as the ‘fast’ element (see Vallado [25])

gauss_modified_equinoctial :

Propagation of Modified equinoctial elements (state vector size 6), with the element \(I\) defining the location of the singularity based on the initial condition (see Hintz [11])

unified_state_model_quaternions :

Propagation of Unified state model using quaternions (state vector size 7, see Vittaldev et al. [26])

unified_state_model_modified_rodrigues_parameters :

Propagation of Unified state model using modified Rodrigues parameters (state vector size 7, last element represents shadow parameter, see Vittaldev et al. [26])

unified_state_model_exponential_map :

Propagation of Unified state model using exponential map (state vector size 7, last element represents shadow parameter, see Vittaldev et al. [26])

TranslationalPropagatorType.name -> str

class RotationalPropagatorType¶

Bases: pybind11_object

Enumeration of available rotational propagator types.

Members:

undefined_rotational_propagator :

quaternions :

Entries 1-4: The quaternion defining the rotation from inertial to body-fixed frame (see here)

Entries 5-7: The body’s angular velocity vector, expressed in its body-fixed frame.

modified_rodrigues_parameters :

Entries 1-4: The modified Rodrigues parameters defining the rotation from inertial to body-fixed frame (with entry four the shadow parameter)

Entries 5-7: The body’s angular velocity vector, expressed in its body-fixed frame.

exponential_map :

Entries 1-4: The exponential map defining the rotation from inertial to body-fixed frame (with entry four the shadow parameter)

Entries 5-7: The body’s angular velocity vector, expressed in its body-fixed frame.

RotationalPropagatorType.name -> str

class StateType¶

Bases: pybind11_object

Enumeration of available integrated state types.

Members:

hybrid_type :

translational_type :

rotational_type :

mass_type :

custom_type :

StateType.name -> str

class PropagationTerminationTypes¶

Bases: pybind11_object

Enumeration of possible propagation termination types

Members:

time_stopping_condition_type : No propagator documentation found.

cpu_time_stopping_condition_type : No propagator documentation found.

dependent_variable_stopping_condition_type : No propagator documentation found.

hybrid_stopping_condition_type : No propagator documentation found.

custom_stopping_condition_type : No propagator documentation found.

PropagationTerminationTypes.name -> str

Classes¶

`PropagatorSettings`	Base class to define settings for propagators.
`MultiArcPropagatorSettings`	Class derived from `PropagatorSettings` to define settings for multi-arc dynamics
`HybridArcPropagatorSettings`	Class derived from `PropagatorSettings` to define settings for hybrid-arc dynamics
`SingleArcPropagatorSettings`	Class derived from `PropagatorSettings` to define settings for single-arc dynamics (of any type, including translational, rotational, etc.) An object of this type is typically created using the specific propagator settings creation function, such as `translational()`, `rotational()` of `multitype()`
`TranslationalStatePropagatorSettings`	SingleArcPropagatorSettings-derived class to define settings for single-arc translational dynamics.
`RotationalStatePropagatorSettings`	SingleArcPropagatorSettings-derived class to define settings for single-arc rotational state propagation.
`MultiTypePropagatorSettings`	SingleArcPropagatorSettings-derived class to define settings for propagation of multiple quantities.
`RelativisticTimePropagatorSettings`	Base class for settings of relativistic time-state propagation.
`FirstOrderBodycentricRelativisticTimePropagatorSettings`	Settings for first-order barycentric↔body-centered relativistic time conversion.
`BodycenteredToTopocentricTimePropagatorSettings`	Settings for body-centered↔topocentric relativistic time conversion.
`DirectRelativisticTimePropagatorSettings`	Settings for direct metric-based relativistic time conversion.
`PropagationTerminationSettings`	Functional base class to define termination settings for the propagation.
`PropagationDependentVariableTerminationSettings`	PropagationTerminationSettings-derived class to define termination settings for the propagation from dependent variables.
`PropagationTimeTerminationSettings`	PropagationTerminationSettings-derived class to define termination settings for the propagation from propagation time.
`PropagationCPUTimeTerminationSettings`	PropagationTerminationSettings-derived class to define termination settings for the propagation from CPU time.
`PropagationCustomTerminationSettings`	PropagationTerminationSettings-derived class to define custom termination settings for the propagation.
`PropagationHybridTerminationSettings`	PropagationTerminationSettings-derived class to define hybrid termination settings for the propagation.
`PropagationPrintSettings`	Class to save settings on what is to be written to the console during the propagation of a single arc.
`PropagatorProcessingSettings`	Base class to define settings on how the numerical results are to be used
`SingleArcPropagatorProcessingSettings`	Class to define settings on how the numerical results are to be used for single-arc propagations
`MultiArcPropagatorProcessingSettings`	Class to define settings on how the numerical results are to be used for multi-arc propagations
`HybridArcPropagatorProcessingSettings`	Class to define settings on how the numerical results are to be used for hybrid-arc propagations

class PropagatorSettings¶

Bases: pybind11_object

Base class to define settings for propagators.

Base class to define settings for propagators. Derived classes are split into settings for single-, multi-arc and hybrid-arc dynamics. Single-arc settings are in turn split into specific derived classes per dynamics type

property initial_states¶

Vector of initial state values for the numerical propagation. For the multi-arc, this contains the concatenated single-arc initial states. For the hybrid-arc, this contains first the list of single-arc component initial states, followed by the multi-arc component initial states.

Type:: np.array

class MultiArcPropagatorSettings¶

Bases: PropagatorSettings

Class derived from PropagatorSettings to define settings for multi-arc dynamics

Class derived from PropagatorSettings to define settings for multi-arc dynamics An object of this type is typically created using the dedicated creation function multi_arc()

property initial_state_list¶

read-only

List of initial states per arc (e.g. entry j of this list is the initial state for arc j).

Type:: list[np.array]

property processing_settings¶

read-only

Settings that determine how the multi-arc propagation results are processed (e.g. if the results are used to update the body ephemeris, if data from each epoch is saved, etc.), and which data is printed to the console See user guide for more details.

Type:: MultiArcPropagatorProcessingSettings

property single_arc_settings¶

read-only

List of single arc settings (e.g. entry j of this list is the single-arc propagator setting for arc j).

Type:: list[SingleArcPropagatorSettings]

class HybridArcPropagatorSettings¶

Bases: PropagatorSettings

Class derived from PropagatorSettings to define settings for hybrid-arc dynamics

Class derived from PropagatorSettings to define settings for hybrid-arc dynamics An object of this type is typically created using the dedicated creation function hybrid_arc()

property processing_settings¶

read-only

Settings that determine how the hybrid-arc propagation results are processed (e.g. if the results are used to update the body ephemeris, if data from each epoch is saved, etc.), and which data is printed to the console See user guide for more details.

type:

HybridArcPropagatorProcessingSettings

class SingleArcPropagatorSettings¶

Bases: PropagatorSettings

Class derived from PropagatorSettings to define settings for single-arc dynamics (of any type, including translational, rotational, etc.) An object of this type is typically created using the specific propagator settings creation function, such as translational(), rotational() of multitype()

property integrator_settings¶

Settings for creating the numerical integrator object that is used to solve the equations of motion

Type:: IntegratorSettings

property print_settings¶

read-only

Settings that determine which information is printed to the console during the propagation. NOTE: this object can also be retrieved from the processing_settings attribute See the user guide for more details.

Type:: PropagationPrintSettings

property processing_settings¶

read-only

Settings that determine how the propagation results are processed (e.g. if the results are used to update the body ephemeris, if data from each epoch is saved, etc.), and which data is printed to the console See our user guide for more details.

Type:: SingleArcPropagatorProcessingSettings

property termination_settings¶

Settings for creating the object that checks whether the propagation is finished (e.g. on a final time, a final dependent variable, etc.)

Type:: PropagationTerminationSettings

class TranslationalStatePropagatorSettings¶

Bases: SingleArcPropagatorSettings

SingleArcPropagatorSettings-derived class to define settings for single-arc translational dynamics.

get_propagated_state_size(self: tudatpy.kernel.dynamics.propagation_setup.propagator.TranslationalStatePropagatorSettings) → int¶

reset_and_recreate_acceleration_models(self: tudatpy.kernel.dynamics.propagation_setup.propagator.TranslationalStatePropagatorSettings, new_acceleration_settings: dict[str, dict[str, list[tudatpy.kernel.dynamics.propagation_setup.acceleration.AccelerationSettings]]], bodies: tudatpy.kernel.dynamics.environment.SystemOfBodies) → None¶

class RotationalStatePropagatorSettings¶

Bases: SingleArcPropagatorSettings

SingleArcPropagatorSettings-derived class to define settings for single-arc rotational state propagation.

class MultiTypePropagatorSettings¶

Bases: SingleArcPropagatorSettings

SingleArcPropagatorSettings-derived class to define settings for propagation of multiple quantities.

recreate_state_derivative_models(self: tudatpy.kernel.dynamics.propagation_setup.propagator.MultiTypePropagatorSettings, bodies: tudatpy.kernel.dynamics.environment.SystemOfBodies) → None¶

reset_initial_states(self: tudatpy.kernel.dynamics.propagation_setup.propagator.MultiTypePropagatorSettings, initial_states: numpy.ndarray[numpy.float64[m, 1]]) → None¶

single_type_settings(self: tudatpy.kernel.dynamics.propagation_setup.propagator.MultiTypePropagatorSettings, state_type: tudatpy.kernel.dynamics.propagation_setup.propagator.StateType) → tudatpy.kernel.dynamics.propagation_setup.propagator.SingleArcPropagatorSettings¶

property propagator_settings_per_type¶

None

Type:: dict[IntegratedStateType, list[SingleArcPropagatorSettings]]

class RelativisticTimePropagatorSettings¶

Bases: pybind11_object

Base class for settings of relativistic time-state propagation.

class FirstOrderBodycentricRelativisticTimePropagatorSettings¶

Bases: RelativisticTimePropagatorSettings

Settings for first-order barycentric↔body-centered relativistic time conversion.

class BodycenteredToTopocentricTimePropagatorSettings¶

Bases: RelativisticTimePropagatorSettings

Settings for body-centered↔topocentric relativistic time conversion.

class DirectRelativisticTimePropagatorSettings¶

Bases: RelativisticTimePropagatorSettings

Settings for direct metric-based relativistic time conversion.

class PropagationTerminationSettings¶

Bases: pybind11_object

Functional base class to define termination settings for the propagation.

class PropagationDependentVariableTerminationSettings¶

Bases: PropagationTerminationSettings

PropagationTerminationSettings-derived class to define termination settings for the propagation from dependent variables.

class PropagationTimeTerminationSettings¶

Bases: PropagationTerminationSettings

PropagationTerminationSettings-derived class to define termination settings for the propagation from propagation time.

class PropagationCPUTimeTerminationSettings¶

Bases: PropagationTerminationSettings

PropagationTerminationSettings-derived class to define termination settings for the propagation from CPU time.

class PropagationCustomTerminationSettings¶

Bases: PropagationTerminationSettings

PropagationTerminationSettings-derived class to define custom termination settings for the propagation.

class PropagationHybridTerminationSettings¶

Bases: PropagationTerminationSettings

PropagationTerminationSettings-derived class to define hybrid termination settings for the propagation.

class PropagationPrintSettings¶

Bases: pybind11_object

Class to save settings on what is to be written to the console during the propagation of a single arc.

Upon creation, this object has default settings such that no data is printed to the console.

disable_all_printing(self: tudatpy.kernel.dynamics.propagation_setup.propagator.PropagationPrintSettings) → None¶: Function enabling all printing (e.g. sets all boolean attributes to False, and disables all other output as well)

enable_all_boolean_printing(self: tudatpy.kernel.dynamics.propagation_setup.propagator.PropagationPrintSettings) → None¶: Function enabling all True/False printing (e.g. sets all boolean attributes to True)

enable_all_printing(self: tudatpy.kernel.dynamics.propagation_setup.propagator.PropagationPrintSettings, results_print_frequency_in_seconds: float | SupportsIndex, results_print_frequency_in_steps: int | SupportsIndex) → None¶

Function enabling all True/False printing (e.g. sets all boolean attributes to True), and setting the non-boolean attributes to values defined here.

Parameters:

results_print_frequency_in_seconds (float) – See results_print_frequency_in_seconds class attribute
results_print_frequency_in_steps (int) – See results_print_frequency_in_steps class attribute

property print_dependent_variable_indices¶

Boolean defining whether the meaning and indices of the entries of the dependent variable data are to be printed to the console (before the propagation).

Note

The same information can be retrieved from the SingleArcSimulationResults.dependent_variable_ids attribute.

Type:: bool

property print_dependent_variables_during_propagation¶

Boolean defining whether the dependent variables are to be printed during the propagation along with the state, at steps/epochs define by the results_print_frequency_in_seconds and/or results_print_frequency_in_steps inputs.

Type:: float

property print_initial_and_final_conditions¶

Boolean defining whether the initial and final conditions (state and time) are to be printed to the console (before and after propagation, respectively).

Type:: bool

property print_number_of_function_evaluations¶

Boolean defining whether the number of function evaluations that were performed is to be printed to the console (after propagation).

Type:: bool

property print_processed_state_indices¶

Boolean defining whether the meaning and indices of the entries of the processed state vector are to be printed to the console (after the propagation). The distinction between the propagated and processed (or conventional) state representation is described in detail here. Summarizing: the processed state is the ‘typical’ formulation of the state (for translational dynamics: Cartesian states).

Note

The same information can be retrieved from the SingleArcSimulationResults.processed_state_ids attribute.

Type:: bool

property print_propagation_clock_time¶

Boolean defining whether the total clock time taken for the propagation is to be printed to the console (after propagation).

Type:: bool

property print_state_indices¶

Boolean defining whether the meaning and indices of the entries of the state vector are to be printed to the console (before the propagation).

Note

The same information can be retrieved from the SingleArcSimulationResults.propagated_state_ids attribute.

Type:: bool

property print_termination_reason¶

Boolean defining whether the reason for propagation termination is to be printed to the console (after propagation).

Type:: bool

property results_print_frequency_in_seconds¶

Variable indicating how often (in seconds of simulation time) the current state and time are to be printed to the console (by default, set to NaN - they are never printed). In case this setting is active (e.g. not NaN), and the results_print_frequency_in_steps setting is active, the current state is printed as soon as one of the two conditions (number of seconds, or number of steps) is met.

Type:: Float

property results_print_frequency_in_steps¶

Variable indicating how often (in number of full integration steps) the current state and time are to be printed to the console (by default, set to 0 - they are never printed). In case this setting is active (e.g. not 0), and the results_print_frequency_in_seconds setting is active, the current state is printed as soon as one of the two conditions (number of seconds, or number of steps) is met.

Type:: int

class PropagatorProcessingSettings¶

Bases: pybind11_object

Base class to define settings on how the numerical results are to be used

Base class to define settings on how the numerical results are to be used, both during the propagation (printing to console) and after propagation (resetting environment) Instances of this class are typically not created by the user. Settings objects for derived class of single-, multi- and hybrid arc propagation are instantiated through the functions to define propagator settings (such as translational() or multi_arc()) in this module.

Upon creation, this object has default settings, clear_numerical_solution: false and set_integrated_result: false.

property clear_numerical_solution¶

Boolean defining whether the propagation results should be deleted after the propagation is terminated. If this is done, the state_history, unprocessed_state_history and dependent_variable_history will not be available in the SingleArcSimulationResults class. Putting this setting to True (deleting the results) is only sensible when the set_integrated_result is set to True. In that case, the propagated states are not accessible directly from the associated SingleArcVariationalSimulationResults object (for the case of single-arc propagation) but the results are used to update the environment, e.g. update the ephemeris of the propagated body with the numerical results.

Type:: bool

property create_dependent_variable_interface¶: No propagator documentation found.

property set_integrated_result¶

Boolean defining whether the propagation results are to be used to update the environment. If this variable is set to False, the numerical propagation results can be retrieved from the associated SingleArcSimulationResults object (for the case of single-arc propagation; provided the clear_numerical_solution is set to False), but the (for instance) Ephemeris of the propagated body is not updated with the propagation results. If this variable is set to True, the properties of the propagated Body object will be updated as per the numerical results (see here for details).

Type:: bool

property set_integrated_variational_result¶: Boolean defining whether the propagation results of variational equations (if any) are to be used to update the interpolators of the state transition and sensitivity matrices. If this variable is set to False, the numerical propagation results of the variational equations can still be retrieved from the associated SingleArcVariationalSimulationResults object (for the case of single-arc propagation; provided the clear_numerical_solution is set to False), but the state_transition_interface object will not have its internal interpolators updated with these numerical results. :type: bool

class SingleArcPropagatorProcessingSettings¶

Bases: PropagatorProcessingSettings

Class to define settings on how the numerical results are to be used for single-arc propagations

Class to define settings on how the numerical results are to be used, both during the propagation (printing to console) and after propagation (resetting environment), derived from PropagatorProcessingSettings. Instances of this class are typically not created by the user. A settings object is instantiated through the functions to define single-arc propagator settings (such as translational() or rotational()) in this module

Upon creation, this object has default settings, print_settings: `` (see :class:`~PropagationPrintSettings` for default), ``results_save_frequency_in_steps: 1, and results_save_frequency_in_seconds: NaN (e.g. not used).

property print_settings¶

Settings object defining which quantities should be printed to the console before, during and after the propagation. By default, this object is instantiated to print nothing.

Type:: PropagationPrintSettings

property results_save_frequency_in_seconds¶

Variable indicating how often (in seconds of simulation time) the propagated time, state, dependent variables, etc. are to be saved to data structures containing the results (by default, set to NaN - they are not saved based on propagation time; see below and results_save_frequency_in_steps attribute ). In case this setting is active, and set to \(\Delta t\), the data are saved as soon as the current time step is \(\ge \Delta t\) after the last step at which data was saved. In case this setting is active (e.g. not NaN), and the results_save_frequency_in_steps setting is active, the current state is printed as soon as one of the two conditions (number of seconds, or number of steps) is met.

Type:: float

property results_save_frequency_in_steps¶

Variable indicating how often (in number of integrator steps) the propagated time, state, dependent variables, etc. are to be saved to data structures containing the results (by default, set to 1 - they are saved every time step). If this setting is set to 0, the data is never saved based on number of steps. In case this setting is active (e.g. not 0), and the results_save_frequency_in_seconds setting is active, the data is saved as soon as one of the two conditions (number of seconds, or number of steps) is met.

Type:: int

class MultiArcPropagatorProcessingSettings¶

Bases: PropagatorProcessingSettings

Class to define settings on how the numerical results are to be used for multi-arc propagations

Class to define settings on how the numerical results are to be used, both during the propagation (printing to console) and after propagation (resetting environment), derived from PropagatorProcessingSettings. Instances of this class are typically not created by the user. A settings object is instantiated through the function multi_arc() to define multi-arc propagator settings. This object contains a list of SingleArcPropagatorProcessingSettings objects, containing the processing settings for each constituent arc.

set_print_settings_for_all_arcs(self: tudatpy.kernel.dynamics.propagation_setup.propagator.MultiArcPropagatorProcessingSettings, single_arc_print_settings: tudatpy.kernel.dynamics.propagation_setup.propagator.PropagationPrintSettings) → None¶

Function that sets the same print settings for each arc in the multi-arc propagation.

Parameters:: single_arc_print_settings (PropagationPrintSettings) – Propagation print settings that are applied to each constituent single-arc settings, overriding any existing settings.

property identical_settings_per_arc¶: No propagator documentation found.

property print_output_on_first_arc_only¶

read-only

Variable defining whether the set_print_settings_for_all_arcs function has been used to define identical print settings for each arc.

Type:: bool

property single_arc_settings¶

read-only

List containing the processing settings for each constituent arc

Type:: list[SingleArcPropagatorProcessingSettings]

class HybridArcPropagatorProcessingSettings¶

Bases: PropagatorProcessingSettings

Class to define settings on how the numerical results are to be used for hybrid-arc propagations

Class to define settings on how the numerical results are to be used, both during the propagation (printing to console) and after propagation (resetting environment), derived from PropagatorProcessingSettings. Instances of this class are typically not created by the user. A settings object is instantiated through the function hybrid_arc() to define hybrid-arc propagator settings. This object contains a SingleArcPropagatorProcessingSettings object and a MultiArcPropagatorProcessingSettings , containing the processing settings for the constituents of the hybrid-arc propagation.

set_print_settings_for_all_arcs(self: tudatpy.kernel.dynamics.propagation_setup.propagator.HybridArcPropagatorProcessingSettings, print_settings: tudatpy.kernel.dynamics.propagation_setup.propagator.PropagationPrintSettings) → None¶

Function that sets the same print settings for each arc in the multi-arc propagation.

Parameters:: single_arc_print_settings (PropagationPrintSettings) – Propagation print settings that are applied to each constituent single-arc settings, overriding any existing settings.

property multi_arc_settings¶

Processing settings for the single-arc component of the multi-arc propagation.

Type:: MultiArcPropagatorProcessingSettings

property single_arc_settings¶

Processing settings for the single-arc component of the hybrid-arc propagation.

Type:: SingleArcPropagatorProcessingSettings

propagator¶

Functions¶

Enumerations¶

Classes¶

`propagator`¶