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