def __init__(self, vehicle_body: str, initial_time: float, parameter_vector: list): """ Constructor of the ThrustGuidance class. Parameters ---------- vehicle_body : str Name of the vehicle to apply the thrust guidance to. initial_time: float Initial time of the simulation [s]. parameter_vector : list List of thrust parameters to retrieve the thrust guidance from. Returns ------- none """ print('Initializing guidance...') # Set arguments as attributes self.vehicle_body = vehicle_body self.initial_time = initial_time self.parameter_vector = parameter_vector self.thrust_magnitude = parameter_vector[0] self.time_interval = parameter_vector[1] # Prepare dictionary for thrust angles self.thrust_angle_dict = {} # this defines the in-plane angle self.thrust_angle_2_dict = {} # this defines the out-of-plane angle # Initialize time current_time = initial_time # Loop over nodes for i in range(4): #((len(parameter_vector) - 2)/2): # qui mi da non risolto perche e' ancora basato sulla lunghezza precedente # Store time as key, thrust angle as value self.thrust_angle_dict[current_time] = parameter_vector[i + 2] self.thrust_angle_2_dict[current_time] = parameter_vector[i + 2 + 5]#(len(parameter_vector) - 2)/2] # Increase time current_time += self.time_interval # Create interpolator settings interpolator_settings = interpolators.linear_interpolation( boundary_interpolation=interpolators.use_boundary_value) # Create the interpolator between nodes and set it as attribute self.thrust_angle_interpolator = interpolators.create_one_dimensional_interpolator(self.thrust_angle_dict, interpolator_settings) self.thrust_angle_2_interpolator = interpolators.create_one_dimensional_interpolator(self.thrust_angle_2_dict, interpolator_settings)
def compare_benchmarks(first_benchmark: dict, second_benchmark: dict, output_path: str, filename: str) -> dict: """ It compares the results of two benchmark runs. It uses an 8th-order Lagrange interpolator to compare the state (or the dependent variable, depending on what is given as input) history. The difference is returned in form of a dictionary and, if desired, written to a file named filename and placed in the directory output_path. Parameters ---------- first_benchmark : dict State (or dependent variable history) from the first benchmark. second_benchmark : dict State (or dependent variable history) from the second benchmark. output_path : str If and where to save the benchmark results (if None, results are NOT written). filename : str Name of the output file. Returns ------- benchmark_difference : dict Interpolated difference between the two benchmarks' state (or dependent variable) history. """ # Create 8th-order Lagrange interpolator for first benchmark benchmark_interpolator = interpolators.create_one_dimensional_interpolator(first_benchmark, interpolators.lagrange_interpolation(8)) # Calculate the difference between the benchmarks print('Calculating benchmark differences...') # Initialize difference dictionaries benchmark_difference = dict() # Calculate the difference between the states and dependent variables in an iterative manner for second_epoch in second_benchmark.keys(): benchmark_difference[second_epoch] = benchmark_interpolator.interpolate(second_epoch) - \ second_benchmark[second_epoch] # Write results to files if output_path is not None: save2txt(benchmark_difference, filename, output_path) # Return the interpolator return benchmark_difference
# Set output path for the benchmarks if write_results_to_file: benchmark_output_path = current_dir + '/SimulationOutput/benchmarks/' else: benchmark_output_path = None # Generate benchmarks benchmark_step_size = 1.0 benchmark_list = Util.generate_benchmarks( benchmark_step_size, simulation_start_epoch, constant_specific_impulse, bodies, benchmark_propagator_settings, thrust_parameters, are_dependent_variables_to_save, benchmark_output_path) # Extract benchmark states first_benchmark_state_history = benchmark_list[0] second_benchmark_state_history = benchmark_list[1] # Create state interpolator for first benchmark benchmark_state_interpolator = interpolators.create_one_dimensional_interpolator( first_benchmark_state_history, benchmark_interpolator_settings) # Compare benchmark states, returning interpolator of the first benchmark benchmark_state_difference = Util.compare_benchmarks( first_benchmark_state_history, second_benchmark_state_history, benchmark_output_path, 'benchmarks_state_difference.dat') # Extract benchmark dependent variables, if present if are_dependent_variables_to_save: first_benchmark_dependent_variable_history = benchmark_list[2] second_benchmark_dependent_variable_history = benchmark_list[3] # Create dependent variable interpolator for first benchmark benchmark_dependent_variable_interpolator = interpolators.create_one_dimensional_interpolator( first_benchmark_dependent_variable_history, benchmark_interpolator_settings)