def fitness(self,
orbit_parameters):
# Retrieves system of bodies
current_bodies = self.bodies_function()
# Retrieves Itokawa gravitational parameter
itokawa_gravitational_parameter = current_bodies.get("Itokawa").gravitational_parameter
# Reset the initial state from the decision variable vector
new_initial_state = element_conversion.keplerian_to_cartesian_elementwise(
gravitational_parameter=itokawa_gravitational_parameter,
semi_major_axis=orbit_parameters[0],
eccentricity=orbit_parameters[1],
inclination=np.deg2rad(orbit_parameters[2]),
argument_of_periapsis=np.deg2rad(235.7),
longitude_of_ascending_node=np.deg2rad(orbit_parameters[3]),
true_anomaly=np.deg2rad(139.87))
# Retrieves propagator settings object
propagator_settings = self.propagator_settings_function()
# Retrieves integrator settings object
integrator_settings = self.integrator_settings_function()
# Reset the initial state
propagator_settings.initial_states = new_initial_state
# Propagate orbit
dynamics_simulator = numerical_simulation.SingleArcSimulator( current_bodies,
integrator_settings,
propagator_settings,
print_dependent_variable_data=False,
print_state_data=False)
# Update dynamics simulator function
self.dynamics_simulator_function = lambda: dynamics_simulator
# Retrieve dependent variable history
dependent_variables = dynamics_simulator.dependent_variable_history
dependent_variables_list = np.vstack(list(dependent_variables.values()))
# Retrieve distance
distance = dependent_variables_list[:, 0]
# Retrieve latitude
latitudes = dependent_variables_list[:, 1]
# Compute mean latitude
mean_latitude = np.mean(np.absolute(latitudes))
# Computes fitness as mean latitude
current_fitness = 1.0 / mean_latitude
# Exaggerate fitness value if the spacecraft has broken out of the selected distance range
current_penalty = 0.0
if (max(dynamics_simulator.dependent_variable_history.keys()) < self.mission_final_time):
current_penalty = 1.0E2
return [current_fitness + current_penalty, np.mean(distance) + current_penalty * 1.0E3]
This function requires the `system_of_bodies`, `integrator_settings`, and `propagator_settings` that have all been defined earlier.
After this, the history of the propagated state over time, containing both the position and velocity history, is extracted.
This history, taking the form of a dictionary, is then converted to an array containing 7 columns:
- Column 0: Time history, in seconds since J2000.
- Columns 1 to 3: Position history, in meters, in the frame that was specified in the `body_settings`.
- Columns 4 to 6: Velocity history, in meters per second, in the frame that was specified in the `body_settings`.
The same is done with the dependent variable history. The column indexes corresponding to a given dependent variable in the `dep_vars` variable are printed when the simulation is run, when `SingleArcSimulator()` is called.
Do mind that converting to an ndarray using the `result2array()` utility will shift these indexes, since the first column (index 0) will then be the times.
"""
# Instantiate the dynamics simulator and run the simulation
dynamics_simulator = numerical_simulation.SingleArcSimulator(
system_of_bodies,
integrator_settings,
propagator_settings,
print_dependent_variable_data=True)
# Extract the state and dependent variable history
state_history = dynamics_simulator.state_history
dependent_variable_history = dynamics_simulator.dependent_variable_history
# Convert the dictionaries to multi-dimensional arrays
vehicle_array = result2array(state_history)
dep_var_array = result2array(dependent_variable_history)
### Get Moon state from SPICE
"""
The state of the Moon at the epochs at which the propagation was run is now extracted from the SPICE kernel.
"""
## Propagate the orbit
"""
The orbit is now ready to be propagated.
This is done by calling the `SingleArcSimulator()` function of the `numerical_simulation module`.
This function requires the `bodies`, `integrator_settings`, and `propagator_settings` that have all been defined earlier.
After this, the history of the propagated state over time, containing both the position and velocity history, is extracted.
This history, taking the form of a dictionary, is then converted to an array containing 7 columns:
- Column 0: Time history, in seconds since J2000.
- Columns 1 to 3: Position history, in meters, in the frame that was specified in the `body_settings`.
- Columns 4 to 6: Velocity history, in meters per second, in the frame that was specified in the `body_settings`.
"""
# Create simulation object and propagate the dynamics
dynamics_simulator = numerical_simulation.SingleArcSimulator(
bodies, integrator_settings, propagator_settings)
# Extract the resulting state history and convert it to an ndarray
states = dynamics_simulator.state_history
states_array = result2array(states)
## Post-process the propagation results
"""
The results of the propagation are then processed to a more user-friendly form.
"""
### Print initial and final states
"""
First, let's print the initial and final position and velocity vector of `Delfi-C3`.
"""
"""
Each of the bodies can now be simulated.
This is done by calling the `SingleArcSimulator()` function of the `numerical_simulation` module.
This function requires the `body_system`, `integrator_settings`, and the appropriate `propagator_settings_X` (with X being the propagation varian), that have all been defined earlier.
In the same step, the history of the propagated states over time, containing both the position and velocity history, is extracted.
This history takes the form of a dictionary. The keys are the simulated epochs, and the values are an array containing the states of all of the bodies one after another.
"""
# Propagate the system of bodies and save the state history (all in one step)
for propagation_variant in ["barycentric", "hierarchical"]:
if propagation_variant == "barycentric":
results_barycentric = numerical_simulation.SingleArcSimulator(
body_system, integrator_settings,
propagator_settings_barycentric).state_history
else:
results_hierarchical = numerical_simulation.SingleArcSimulator(
body_system, integrator_settings,
propagator_settings_hierarchical).state_history
## Post-process the propagation results
"""
The results of the propagation are then processed to a more user-friendly form.
"""
### Plot the barycentric system evolution in 3D
"""
Let's first plot the trajectory of each of the bodies in 3 dimensions, with respect to the Solar System Barycenter.
"""