propagator
#
This module provides the functionality for creating propagator settings.
References#
Functions#

Overloaded function. 

Overloaded function. 

Overloaded function. 

Overloaded function. 

Factory function to create multiarc propagator settings. 

Factory function to create hybridarc propagator settings. 

Factory function to create time termination settings for the propagation. 

Factory function to create CPU time termination settings for the propagation. 
Factory function to create termination settings for the propagation based on a dependent variable. 


Factory function to create custom termination settings for the propagation. 

Factory function to create hybrid termination settings for the propagation. 
Factory function to create nonsequential termination settings for the propagation. 

Function to add dependent variables to existing propagator settings. 
 translational(*args, **kwargs)#
Overloaded function.
translational(central_bodies: list[str], acceleration_models: dict[str, dict[str, list[tudatpy.kernel.numerical_simulation.propagation.AccelerationModel]]], bodies_to_integrate: list[str], initial_states: numpy.ndarray[numpy.float64[m, 1]], termination_settings: tudat::propagators::PropagationTerminationSettings, propagator: tudatpy.kernel.numerical_simulation.propagation_setup.propagator.TranslationalPropagatorType = <TranslationalPropagatorType.cowell: 0>, output_variables: list[tudat::propagators::SingleDependentVariableSaveSettings] = [], print_interval: float = nan) > tudatpy.kernel.numerical_simulation.propagation_setup.propagator.TranslationalStatePropagatorSettings
translational(central_bodies: list[str], acceleration_models: dict[str, dict[str, list[tudatpy.kernel.numerical_simulation.propagation.AccelerationModel]]], bodies_to_integrate: list[str], initial_states: numpy.ndarray[numpy.float64[m, 1]], initial_time: float, integrator_settings: tudatpy.kernel.numerical_simulation.propagation_setup.integrator.IntegratorSettings, termination_settings: tudat::propagators::PropagationTerminationSettings, propagator: tudatpy.kernel.numerical_simulation.propagation_setup.propagator.TranslationalPropagatorType = <TranslationalPropagatorType.cowell: 0>, output_variables: list[tudat::propagators::SingleDependentVariableSaveSettings] = [], processing_settings: tudatpy.kernel.numerical_simulation.propagation_setup.propagator.SingleArcPropagatorProcessingSettings = <tudatpy.kernel.numerical_simulation.propagation_setup.propagator.SingleArcPropagatorProcessingSettings object at 0x7f7a9939a7f0>) > tudatpy.kernel.numerical_simulation.propagation_setup.propagator.TranslationalStatePropagatorSettings
Factory function to create translational state propagator settings with stopping condition at given final time.
Factory 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
, as created bycreate_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 (AccelerationMap) – 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()
andcreate_system_of_bodies()
). Consequently, for N integrated bodies, this input is a vector with size size 6N.initial_time (float) – 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=[]) – 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)
 Returns:
Translational state propagator settings object.
 Return type:
 rotational(*args, **kwargs)#
Overloaded function.
rotational(torque_models: dict[str, dict[str, list[tudatpy.kernel.numerical_simulation.propagation.TorqueModel]]], bodies_to_integrate: list[str], initial_states: numpy.ndarray[numpy.float64[m, 1]], termination_settings: tudat::propagators::PropagationTerminationSettings, propagator: tudatpy.kernel.numerical_simulation.propagation_setup.propagator.RotationalPropagatorType = <RotationalPropagatorType.quaternions: 0>, output_variables: list[tudat::propagators::SingleDependentVariableSaveSettings] = [], print_interval: float = nan) > tudatpy.kernel.numerical_simulation.propagation_setup.propagator.RotationalStatePropagatorSettings
rotational(torque_models: dict[str, dict[str, list[tudatpy.kernel.numerical_simulation.propagation.TorqueModel]]], bodies_to_integrate: list[str], initial_states: numpy.ndarray[numpy.float64[m, 1]], initial_time: float, integrator_settings: tudatpy.kernel.numerical_simulation.propagation_setup.integrator.IntegratorSettings, termination_settings: tudat::propagators::PropagationTerminationSettings, propagator: tudatpy.kernel.numerical_simulation.propagation_setup.propagator.RotationalPropagatorType = <RotationalPropagatorType.quaternions: 0>, output_variables: list[tudat::propagators::SingleDependentVariableSaveSettings] = [], processing_settings: tudatpy.kernel.numerical_simulation.propagation_setup.propagator.SingleArcPropagatorProcessingSettings = <tudatpy.kernel.numerical_simulation.propagation_setup.propagator.SingleArcPropagatorProcessingSettings object at 0x7f7a9939a970>) > tudatpy.kernel.numerical_simulation.propagation_setup.propagator.RotationalStatePropagatorSettings
Factory function to create rotational state propagator settings.
Factory 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 bodyfixed 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 an
TorqueModelMap
, as created bycreate_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 (float) – 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=[]) – 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)
 Returns:
Rotational state propagator settings object.
 Return type:
 mass(*args, **kwargs)#
Overloaded function.
mass(bodies_with_mass_to_propagate: list[str], mass_rate_models: dict[str, list[tudatpy.kernel.numerical_simulation.propagation.MassRateModel]], initial_body_masses: numpy.ndarray[numpy.float64[m, 1]], termination_settings: tudat::propagators::PropagationTerminationSettings, output_variables: list[tudat::propagators::SingleDependentVariableSaveSettings] = [], print_interval: float = nan) > tudatpy.kernel.numerical_simulation.propagation_setup.propagator.MassPropagatorSettings
mass(bodies_with_mass_to_propagate: list[str], mass_rate_models: dict[str, list[tudatpy.kernel.numerical_simulation.propagation.MassRateModel]], initial_body_masses: numpy.ndarray[numpy.float64[m, 1]], initial_time: float, integrator_settings: tudatpy.kernel.numerical_simulation.propagation_setup.integrator.IntegratorSettings, termination_settings: tudat::propagators::PropagationTerminationSettings, output_variables: list[tudat::propagators::SingleDependentVariableSaveSettings] = [], processing_settings: tudatpy.kernel.numerical_simulation.propagation_setup.propagator.SingleArcPropagatorProcessingSettings = <tudatpy.kernel.numerical_simulation.propagation_setup.propagator.SingleArcPropagatorProcessingSettings object at 0x7f7a9939a8f0>) > tudatpy.kernel.numerical_simulation.propagation_setup.propagator.MassPropagatorSettings
Factory function to create mass propagator settings
Factory function to create mass propagator settings It works by providing a keyvalue 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_settings (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 (float) – 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=[]) – 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)
 Returns:
Mass propagator settings object.
 Return type:
MassPropagatorSettings
 multitype(*args, **kwargs)#
Overloaded function.
multitype(propagator_settings_list: list[tudatpy.kernel.numerical_simulation.propagation_setup.propagator.SingleArcPropagatorSettings], termination_settings: tudat::propagators::PropagationTerminationSettings, output_variables: list[tudat::propagators::SingleDependentVariableSaveSettings] = [], print_interval: float = nan) > tudatpy.kernel.numerical_simulation.propagation_setup.propagator.MultiTypePropagatorSettings
multitype(propagator_settings_list: list[tudatpy.kernel.numerical_simulation.propagation_setup.propagator.SingleArcPropagatorSettings], integrator_settings: tudatpy.kernel.numerical_simulation.propagation_setup.integrator.IntegratorSettings, initial_time: float, termination_settings: tudat::propagators::PropagationTerminationSettings, output_variables: list[tudat::propagators::SingleDependentVariableSaveSettings] = [], processing_settings: tudatpy.kernel.numerical_simulation.propagation_setup.propagator.SingleArcPropagatorProcessingSettings = <tudatpy.kernel.numerical_simulation.propagation_setup.propagator.SingleArcPropagatorProcessingSettings object at 0x7f7a9939acf0>) > tudatpy.kernel.numerical_simulation.propagation_setup.propagator.MultiTypePropagatorSettings
Factory function to create multitype propagator settings.
Factory 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=[]) – 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)
 Returns:
Mass propagator settings object.
 Return type:
MassPropagatorSettings
 multi_arc(single_arc_settings: list[tudatpy.kernel.numerical_simulation.propagation_setup.propagator.SingleArcPropagatorSettings], transfer_state_to_next_arc: bool = False, processing_settings: tudatpy.kernel.numerical_simulation.propagation_setup.propagator.MultiArcPropagatorProcessingSettings = <tudatpy.kernel.numerical_simulation.propagation_setup.propagator.MultiArcPropagatorProcessingSettings object at 0x7f7a9939ac70>) tudatpy.kernel.numerical_simulation.propagation_setup.propagator.MultiArcPropagatorSettings #
Factory function to create multiarc propagator settings.
Factory function to create multiarc 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) – 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)
 Returns:
Multiarc propagator settings object.
 Return type:
 hybrid_arc(single_arc_settings: tudatpy.kernel.numerical_simulation.propagation_setup.propagator.SingleArcPropagatorSettings, multi_arc_settings: tudatpy.kernel.numerical_simulation.propagation_setup.propagator.MultiArcPropagatorSettings, processing_settings: tudatpy.kernel.numerical_simulation.propagation_setup.propagator.HybridArcPropagatorProcessingSettings = <tudatpy.kernel.numerical_simulation.propagation_setup.propagator.HybridArcPropagatorProcessingSettings object at 0x7f7a9939ae30>) tudatpy.kernel.numerical_simulation.propagation_setup.propagator.HybridArcPropagatorSettings #
Factory function to create hybridarc propagator settings.
Factory function to create hybridarc propagator settings (i.e., a combination of single and multiarc dynamics).
 Parameters:
single_arc_settings (SingleArcPropagatorSettings) – SingleArcPropagatorSettings object to use for the propagation.
multi_arc_settings (MultiArcPropagatorSettings) – 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)
 Returns:
Hybridarc propagator settings object.
 Return type:
 time_termination(termination_time: float, terminate_exactly_on_final_condition: bool = False) tudatpy.kernel.numerical_simulation.propagation_setup.propagator.PropagationTerminationSettings #
Factory function to create time termination settings for the propagation.
Factory 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 timestep, 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:
 Returns:
Time termination settings object.
 Return type:
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) tudatpy.kernel.numerical_simulation.propagation_setup.propagator.PropagationTerminationSettings #
Factory function to create CPU time termination settings for the propagation.
Factory 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:
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: tudat::propagators::SingleDependentVariableSaveSettings, limit_value: float, 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.numerical_simulation.propagation_setup.propagator.PropagationTerminationSettings #
Factory function to create termination settings for the propagation based on a dependent variable.
Factory 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 timestep, 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 (bool, default=None) – Settings object to create root finder used to converge on exact final condition.
 Returns:
Dependent variable termination settings object.
 Return type:
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 theuse_as_lower_limit
is set toTrue
). To use the above settings to terminate when an upper limit of 25 km is reached, set this boolean toFalse
. In this example, we also want to stop exactly at 25 km, so we setterminate_exactly_on_final_condition
toTrue
, and we specifytermination_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], bool]) tudatpy.kernel.numerical_simulation.propagation_setup.propagator.PropagationTerminationSettings #
Factory function to create custom termination settings for the propagation.
Factory 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[[float], 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:
Examples
# Create custom function returning a bool def custom_termination_function(time: float): # 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.numerical_simulation.propagation_setup.propagator.PropagationTerminationSettings], fulfill_single_condition: bool) tudatpy.kernel.numerical_simulation.propagation_setup.propagator.PropagationTerminationSettings #
Factory function to create hybrid termination settings for the propagation.
Factory 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 factory function and then added to a list of termination conditions.
Note that, when using this option, the
termination_details
of the simulation results object (obtained from here after a propagation: :attr:`~tudatpy.numerical_simulation.SingleArcSimulator.propagation_results) is of derived typePropagationTerminationDetailsFromHybridCondition
, which contains additional details on the hybrid termination (such as the specific conditions that were met). Parameters:
termination_settings (list[PropagationTerminationSettings]) – List of single PropagationTerminationSettings objects to be checked during the propagation.
fulfill_single_condition (bool, default=False) – 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:
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 must be 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 altitudebased 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.numerical_simulation.propagation_setup.propagator.PropagationTerminationSettings, backward_termination_settings: tudatpy.kernel.numerical_simulation.propagation_setup.propagator.PropagationTerminationSettings) tudatpy.kernel.numerical_simulation.propagation_setup.propagator.PropagationTerminationSettings #
Factory function to create nonsequential termination settings for the propagation.
Factory function to create nonsequential 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 thebackward_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 forwardintime propagation
backward_termination_settings (PropagationTerminationSettings) – Propagation termination setting for the backwardsintime propagation
 Returns:
Termination settings object for forward and backwardsintime propagation.
 Return type:
 add_dependent_variable_settings(dependent_variable_settings: list[tudat::propagators::SingleDependentVariableSaveSettings], propagator_settings: tudatpy.kernel.numerical_simulation.propagation_setup.propagator.SingleArcPropagatorSettings) 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 teh regular manner in which to defined dependent variables (use of input to factory functions for singlearc propagator settingstranslational()
,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
Enumerations#
Enumeration of available translational propagator types. 

Enumeration of available rotational propagator types. 

Enumeration of available integrated state types. 

Enumeration of possible propagation termination types 
 class TranslationalPropagatorType#
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, 2015 [2])
gauss_keplerian :
Propagation of Keplerian elements (state vector size 6), with true anomaly as the ‘fast’ element (see Vallado, 2001 [4])
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, 2008 [3])
unified_state_model_quaternions :
Propagation of Unified state model using quaternions (state vector size 7, see Vittaldev et al., 2012 [1])
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., 2012 [1])
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., 2012 [1])
 property name#
 class RotationalPropagatorType#
Enumeration of available rotational propagator types.
Members:
undefined_rotational_propagator :
quaternions :
Entries 14: The quaternion defining the rotation from inertial to bodyfixed frame (see here) Entries 57: The body’s angular velocity vector, expressed in its bodyfixed frame.
modified_rodrigues_parameters :
Entries 14: The modified Rodrigues parameters defining the rotation from inertial to bodyfixed frame (with entry four the shadow parameter) Entries 57: The body’s angular velocity vector, expressed in its bodyfixed frame.
exponential_map :
Entries 14: The exponential map defining the rotation from inertial to bodyfixed frame (with entry four the shadow parameter) Entries 57: The body’s angular velocity vector, expressed in its bodyfixed frame.
 property name#
 class StateType#
Enumeration of available integrated state types.
Members:
hybrid_type :
translational_type :
rotational_type :
mass_type : No documentation found.
custom_type :
 property name#
 class PropagationTerminationTypes#
Enumeration of possible propagation termination types
Members:
time_stopping_condition_type : No documentation found.
cpu_time_stopping_condition_type : No documentation found.
dependent_variable_stopping_condition_type : No documentation found.
hybrid_stopping_condition_type : No documentation found.
custom_stopping_condition_type : No documentation found.
 property name#
Classes#
Functional base class to define settings for propagators. 

PropagatorSettingsderived class to define settings for multiarc dynamics. 

PropagatorSettingsderived class to define settings for hybridarc dynamics. 

PropagatorSettingsderived class to define settings for singlearc dynamics. 

SingleArcPropagatorSettingsderived class to define settings for singlearc translational dynamics. 

SingleArcPropagatorSettingsderived class to define settings for singlearc rotational state propagation. 

SingleArcPropagatorSettingsderived class to define settings for propagation of multiple quantities. 

Functional base class to define termination settings for the propagation. 

PropagationTerminationSettingsderived class to define termination settings for the propagation from dependent variables. 

PropagationTerminationSettingsderived class to define termination settings for the propagation from propagation time. 

PropagationTerminationSettingsderived class to define termination settings for the propagation from CPU time. 

PropagationTerminationSettingsderived class to define custom termination settings for the propagation. 

PropagationTerminationSettingsderived class to define hybrid termination settings for the propagation. 

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

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

Class to define settings on how the numerical results are to be used for singlearc propagations 

Class to define settings on how the numerical results are to be used for multiarc propagations 

Class to define settings on how the numerical results are to be used for hybridarc propagations 
 class PropagatorSettings#
Functional base class to define settings for propagators.
Base class to define settings for propagators. Derived classes are split into settings for single and multiarc dynamics.
 property initial_states#
No documentation found.
 class MultiArcPropagatorSettings#
PropagatorSettingsderived class to define settings for multiarc dynamics.
 property processing_settings#
No documentation found.
 class HybridArcPropagatorSettings#
PropagatorSettingsderived class to define settings for hybridarc dynamics.
 property processing_settings#
No documentation found.
 class SingleArcPropagatorSettings#
PropagatorSettingsderived class to define settings for singlearc dynamics.
 termination_settings#
Settings for creating the object that checks whether the propagation is finished.
 property integrator_settings#
No documentation found.
 property print_settings#
No documentation found.
 property processing_settings#
No documentation found.
 property termination_settings#
No documentation found.
 class TranslationalStatePropagatorSettings#
SingleArcPropagatorSettingsderived class to define settings for singlearc translational dynamics.
 acceleration_settings#
Settings for retrieving the accelerations acting on the body during propagation.
 Type:
SelectedAccelerationMap
 get_propagated_state_size(self: tudatpy.kernel.numerical_simulation.propagation_setup.propagator.TranslationalStatePropagatorSettings) int #
 reset_and_recreate_acceleration_models(self: tudatpy.kernel.numerical_simulation.propagation_setup.propagator.TranslationalStatePropagatorSettings, new_acceleration_settings: dict[str, dict[str, list[tudatpy.kernel.numerical_simulation.propagation_setup.acceleration.AccelerationSettings]]], bodies: tudatpy.kernel.numerical_simulation.environment.SystemOfBodies) None #
 class RotationalStatePropagatorSettings#
SingleArcPropagatorSettingsderived class to define settings for singlearc rotational state propagation.
 class MultiTypePropagatorSettings#
SingleArcPropagatorSettingsderived class to define settings for propagation of multiple quantities.
 recreate_state_derivative_models(self: tudatpy.kernel.numerical_simulation.propagation_setup.propagator.MultiTypePropagatorSettings, bodies: tudatpy.kernel.numerical_simulation.environment.SystemOfBodies) None #
 reset_initial_states(self: tudatpy.kernel.numerical_simulation.propagation_setup.propagator.MultiTypePropagatorSettings, initial_states: numpy.ndarray[numpy.float64[m, 1]]) None #
 single_type_settings(self: tudatpy.kernel.numerical_simulation.propagation_setup.propagator.MultiTypePropagatorSettings, state_type: tudatpy.kernel.numerical_simulation.propagation_setup.propagator.StateType) tudatpy.kernel.numerical_simulation.propagation_setup.propagator.SingleArcPropagatorSettings #
 property propagator_settings_per_type#
None
 Type:
dict[IntegratedStateType, list[SingleArcPropagatorSettings]]
 class PropagationTerminationSettings#
Functional base class to define termination settings for the propagation.
 class PropagationDependentVariableTerminationSettings#
PropagationTerminationSettingsderived class to define termination settings for the propagation from dependent variables.
 class PropagationTimeTerminationSettings#
PropagationTerminationSettingsderived class to define termination settings for the propagation from propagation time.
 class PropagationCPUTimeTerminationSettings#
PropagationTerminationSettingsderived class to define termination settings for the propagation from CPU time.
 class PropagationCustomTerminationSettings#
PropagationTerminationSettingsderived class to define custom termination settings for the propagation.
 class PropagationHybridTerminationSettings#
PropagationTerminationSettingsderived class to define hybrid termination settings for the propagation.
 class PropagationPrintSettings#
Class to save settings on what is to be written to the console during the propagation of a single arc.
 disable_all_printing(self: tudatpy.kernel.numerical_simulation.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.numerical_simulation.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.numerical_simulation.propagation_setup.propagator.PropagationPrintSettings, results_print_frequency_in_seconds: float, results_print_frequency_in_steps: int) None #
Function enabling all True/False printing (e.g. sets all boolean attributes to True), and setting the nonboolean attributes to values defined here.
 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:
 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/orresults_print_frequency_in_steps
inputs. Type:
 property print_initial_and_final_conditions#
Boolean defining whether the initial and final conditions (state and time) are to be printed to the console (beforee and after propagation, respectively).
 Type:
 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:
 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 conventuional) 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:
 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:
 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:
 property print_termination_reason#
Boolean defining whether the reason for propagation termination is to be printed to the console (after propagation).
 Type:
 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:
 class PropagatorProcessingSettings#
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 factory functions to define propagator settings (such as
translational()
ormulti_arc()
) in this module 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
anddependent_variable_history
will not be available in theSingleArcSimulationResults
class. Putting this setting to True (deleting the results) is only sensible when theset_integrated_result
is set to True. In that case, the propagated states are not accessible directly from this objects, but the results are used to update the environment, e.g. update the ephemeris of the propagated body with the numerical results. Type:
 property create_dependent_variable_interface#
No 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 this object (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 propagatedBody
object will be updated as per the numerical results (see here for details). Type:
 class SingleArcPropagatorProcessingSettings#
Class to define settings on how the numerical results are to be used for singlearc 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 factory functions to define singlearc propagator settings (such astranslational()
orrotational()
) in this module 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:
 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 theresults_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:
 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:
 class MultiArcPropagatorProcessingSettings#
Class to define settings on how the numerical results are to be used for multiarc 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 factory functionmulti_arc()
to define multiarc propagator settings. This object contains a list ofSingleArcPropagatorProcessingSettings
objects, containing the processing settings for each constituent arc. set_print_settings_for_all_arcs(self: tudatpy.kernel.numerical_simulation.propagation_setup.propagator.MultiArcPropagatorProcessingSettings, single_arc_print_settings: tudatpy.kernel.numerical_simulation.propagation_setup.propagator.PropagationPrintSettings) None #
Function that sets the same print settings for each arc in the multiarc propagation.
 Parameters:
single_arc_print_settings (PropagationPrintSettings) – Propagation print settings that are applied to each constituent singlearc settings, overriding any existing settings.
 property identical_settings_per_arc#
No documentation found.
 property print_output_on_first_arc_only#
readonly
Variable defining whether the
set_print_settings_for_all_arcs
function has been used to define identical print settings for each arc. Type:
 property single_arc_settings#
readonly
List containing the processing settings for each constituent arc
 class HybridArcPropagatorProcessingSettings#
Class to define settings on how the numerical results are to be used for hybridarc 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 factory functionhybrid_arc()
to define hybridarc propagator settings. This object contains aSingleArcPropagatorProcessingSettings
object and aMultuArcPropagatorProcessingSettings
, containing the processing settings for the constituents of the hybridarc propagatioon. set_print_settings_for_all_arcs(self: tudatpy.kernel.numerical_simulation.propagation_setup.propagator.HybridArcPropagatorProcessingSettings, print_settings: tudatpy.kernel.numerical_simulation.propagation_setup.propagator.PropagationPrintSettings) None #
Function that sets the same print settings for each arc in the multiarc propagation.
 Parameters:
single_arc_print_settings (PropagationPrintSettings) – Propagation print settings that are applied to each constituent singlearc settings, overriding any existing settings.
 property multi_arc_settings#
Processing settings for the singlearc component of the multiarc propagation.
 property single_arc_settings#
Processing settings for the singlearc component of the hybridarc propagation.