propagator#

This module provides the functionality for creating propagator settings.

References#

Functions#

translational(*args, **kwargs)

Overloaded function.

rotational(*args, **kwargs)

Overloaded function.

mass(*args, **kwargs)

Overloaded function.

multitype(*args, **kwargs)

Overloaded function.

multi_arc(single_arc_settings, ...)

Factory function to create multi-arc propagator settings.

hybrid_arc(single_arc_settings, ...)

Factory function to create hybrid-arc propagator settings.

time_termination(termination_time[, ...])

Factory function to create time termination settings for the propagation.

cpu_time_termination(cpu_termination_time)

Factory function to create CPU time termination settings for the propagation.

dependent_variable_termination(...)

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

custom_termination(custom_condition)

Factory function to create custom termination settings for the propagation.

hybrid_termination(termination_settings, ...)

Factory function to create hybrid termination settings for the propagation.

add_dependent_variable_settings(...)

Function to add dependent variables to existing propagator settings.

translational(*args, **kwargs)#

Overloaded function.

  1. 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

  2. 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 0x7f43f1852730>) -> 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 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 (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() and create_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:

TranslationalStatePropagatorSettings

rotational(*args, **kwargs)#

Overloaded function.

  1. 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

  2. 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 0x7f43f1852930>) -> 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 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 an 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 (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:

RotationalStatePropagatorSettings

mass(*args, **kwargs)#

Overloaded function.

  1. 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

  2. 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 0x7f43f18528f0>) -> 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 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_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.

  1. 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

  2. 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 0x7f43f1852cf0>) -> 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 0x7f43f1852c70>) tudatpy.kernel.numerical_simulation.propagation_setup.propagator.MultiArcPropagatorSettings#

Factory function to create multi-arc propagator settings.

Factory 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) – 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:

Multi-arc propagator settings object.

Return type:

MultiArcPropagatorSettings

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 0x7f43f1852db0>) tudatpy.kernel.numerical_simulation.propagation_setup.propagator.HybridArcPropagatorSettings#

Factory function to create hybrid-arc propagator settings.

Factory 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) – 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:

Hybrid-arc propagator settings object.

Return type:

HybridArcPropagatorSettings

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 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) 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:

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: 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 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 (bool, 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], 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:

PropagationCustomTerminationSettings

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.

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:

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 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 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 )
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 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

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#

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 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.

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#

PropagatorSettings

Functional base class to define settings for propagators.

MultiArcPropagatorSettings

PropagatorSettings-derived class to define settings for multi-arc dynamics.

HybridArcPropagatorSettings

PropagatorSettings-derived class to define settings for hybrid-arc dynamics.

SingleArcPropagatorSettings

PropagatorSettings-derived class to define settings for single-arc dynamics.

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.

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#

Functional base class to define settings for propagators.

Base class to define settings for propagators. Derived classes are split into settings for single- and multi-arc dynamics.

property initial_states#

No documentation found.

class MultiArcPropagatorSettings#

PropagatorSettings-derived class to define settings for multi-arc dynamics.

property processing_settings#

No documentation found.

class HybridArcPropagatorSettings#

PropagatorSettings-derived class to define settings for hybrid-arc dynamics.

property processing_settings#

No documentation found.

class SingleArcPropagatorSettings#

PropagatorSettings-derived class to define settings for single-arc dynamics.

termination_settings#

Settings for creating the object that checks whether the propagation is finished.

Type:

PropagationTerminationSettings

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#

SingleArcPropagatorSettings-derived class to define settings for single-arc 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#

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

class MultiTypePropagatorSettings#

SingleArcPropagatorSettings-derived 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#

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

class PropagationTimeTerminationSettings#

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

class PropagationCPUTimeTerminationSettings#

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

class PropagationCustomTerminationSettings#

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

class PropagationHybridTerminationSettings#

PropagationTerminationSettings-derived 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 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 (beforee 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 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:

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#

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() or multi_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 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 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:

bool

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 propagated Body object will be updated as per the numerical results (see here for details).

Type:

bool

class SingleArcPropagatorProcessingSettings#

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 factory functions to define single-arc propagator settings (such as translational() or rotational()) 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:

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#

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 factory 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.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 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 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#

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 factory function hybrid_arc() to define hybrid-arc propagator settings. This object contains a SingleArcPropagatorProcessingSettings object and a MultuArcPropagatorProcessingSettings , containing the processing settings for the constituents of the hybrid-arc 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 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