def __init__(self): self.space = dict() self.color = dict() space_letters = ["A", "B", "C", "D", "E", "F", "G", "H"] for i in range(71, 7, -1): self.space[space_letters[i % 8] + str(i // 8)] = space.Space( 'w', None) if i % 2 == 0 else space.Space('b', None) # Initialize a standard board # TODO: change to accept FEN notation self.initialize_standard_setup()
def test_earth_moon_loop(self): """Test that moon loops over Earth.""" moon = dot.Dot() moon.mass = constants.MOON.MASS moon.pos[0] = constants.MOON.PERIGEE_ORBIT_RADIUS init_moon_pos = numpy.array(moon.pos) moon.vel[1] = constants.MOON.MAX_ORBITAL_VELOCITY earth = dot.Dot() earth.mass = constants.EARTH.MASS # Set system inertion to 0 earth.vel[ 1] = -constants.MOON.MAX_ORBITAL_VELOCITY * moon.mass / earth.mass test_space = space.Space(dots=[earth, moon]) # Distance between moon initial position and position after loop min_distance = numpy.inf n_loops = 4. n_iterations = 10000 t = 0 dt = n_loops * constants.MOON.SIDEREAL_ROTATION_PERIOD / n_iterations for iteration in range(n_iterations): test_space.step(time=dt) t += dt if t > constants.MOON.SIDEREAL_ROTATION_PERIOD / 2: min_distance = min( min_distance, space.Space.distance(init_moon_pos, moon.pos), ) assert min_distance < constants.MOON.RADIUS / 100, "Moon not reached init position."
def main(): search_space = s.Space(0.0, epsilon, 15, __function__) particles_vector = [ p.Particle() for _ in range(search_space.num_particles) ] search_space.particles = particles_vector search_space.set_pbest() search_space.set_gbest() iteration = 0 n_iterations = 1000 val_prev = val_prev_1 = 0.0 while iteration < n_iterations or search_space.gbest_value < epsilon: search_space.set_pbest() search_space.set_gbest() # JEŚLI PRZEZ TRZY ITERACJE NIE ZMIENI SIE WARTOŚĆ => BREAK if iteration == 0: val_prev = search_space.gbest_value else: val_prev_1 = val_prev val_prev = search_space.gbest_value print("POŁOŻENIE: ", search_space.gbest_position, " WARTOŚĆ: ", search_space.gbest_value) saveToFile(__function__, search_space.gbest_value) if abs(search_space.gbest_value - search_space.target ) <= search_space.epsilon or val_prev_1 == val_prev: break search_space.move_particles() iteration += 1 print("Solution: ", search_space.gbest_position, " value ", search_space.gbest_value)
def experiment(omega_factor): # Defining experiment parameters J0 = 1 simulation_time = 2 * 10**(-9) # PEC box parameters x_length, y_length = 1, 1 # [m] (i.c. approximately 30 wavelengths) # Initializing a space with a PEC bounding box box = space.Space(x_length, y_length, simulation_time) src = source.Gaussian_pulse(1 / 2 * x_length, 1 / 2 * y_length, J0, 4 * 10**(-10), 10**(-10)) box.set_source(src) lambda_min = 3 / omega_factor * src.get_lambda_min(1) Delta_p = lambda_min / 25 Delta_t = 1 / (3 * c * np.sqrt(2 / Delta_p**2)) box.define_discretization(Delta_p, Delta_p, Delta_t) # Measurement parameters measurement_points = [(1 / 2 * x_length, 1 / 2 * y_length)] measurement_titles = ["Reflected field"] # Adding measurment points box.add_measurement_points(measurement_points, measurement_titles) # Measuring time to perform measurement start = timeit.default_timer() box.FDTD(plot_space=False, visualize_fields=False, eps_averaging=False) time = timeit.default_timer() - start return [time, Delta_p, Delta_t, lambda_min]
def deviation( dvx1: object, dvy1: object, dvx2: object, dvy2: object, dist, plot: object = False ) -> object: #simulation of first half of the orbit if plot: arrX.clear() arrY.clear() global dt unitmass = 1.0 ut = unit.Unit(np.array([1.0, 0.0, 0.0]), np.array([0.0 + dvx1, 1.0 + dvy1, 0.0]), unitmass) sp = space.Space() planetmass = 1.0 / G pl = planet.Planet(planetmass) sp.planet = pl sp.unit = ut pos = ut.pos angle = 0 E0 = ut.getEnergy(planetmass) A0 = ut.vectorLenc(planetmass) flag = False while True: #Condition for the whole orbit if (ut.pos[1] < ut.vel[1] * dt) and (ut.pos[0] < 0) and not flag: flag = True ut.vel[0] += dvx2 ut.vel[1] += dvy2 elif flag and (ut.pos[0] > 0) and (ut.pos[1] > 0): #pos_next = ut.pos[1] + ut.vel[1] * dt #vel_next = ut.vel + pl.acceleration(ut.pos) * dt #ut.vel = (ut.vel * abs(pos_next) + vel_next * abs(ut.pos[1])) / (abs(ut.pos[1]) + abs(pos_next)) break angle += math.degrees(0.001 / 57) sp.step_rot(dt, dist, angle) if plot: arrX.append(ut.pos[0]) arrY.append(ut.pos[1]) E = ut.getEnergy(planetmass) A = ut.vectorLenc(planetmass) glob_vel = ut.vel glob_pos = ut.pos delta = ((E - E0)**2) + vectors.squarelength(A - A0) return delta
def worldInit(): # things carKey = things.Thing("car key", tags=["take"]) catFood = things.Thing("cat food", tags=["take", "eat", "cat food"], eat_val=6) # Actors hungryCat = actors.HouseCat( properName="Hungry Cat", commonName="Cat", description="He looks like he has a big appetite.", inventory=[catFood], hunger=15, hunger_rate=15, ) # mouse = actors.Animal( # commonName="mouse", description="It's a little mouse.", tags=[] # ) # Spaces room27 = space.Space("Room 27", "My hotel room.") hallway = space.Space("the second floor hallway", "A long narrow hallway.") # Spaces -Exits doorway = space.Connection(room27, hallway, "south", "north", blocked=False) # Spaces -doors hallway.addThings( [things.Door("door", doorway, "An old wooden door.", room27)]) # Spaces -things room27.addThings([carKey]) room27.addThings([copy.copy(catFood)]) hallway.addThings( [copy.copy(catFood), copy.copy(catFood), copy.copy(catFood)]) # Spaces -Actors room27.addActors([hungryCat]) # room27.addActors([copy.copy(mouse), copy.copy(mouse)]) # Player player = actors.User("User", location=room27) actors.player = player return player
def main(parameters_file="example_scenarios/spatial/BlackScholes_scenario.json", input_data_file=None, output_pareto_file=None) : """ Compute Pareto from the csv data files specified in the json output_pareto_file field. :param parameters_file: the json file the specify all the HyperMapper input parameters. :return: the csv file is written on disk. """ print("######## compute_pareto.py #####################"); print("### Parameters file is %s" % parameters_file); sys.stdout.flush() filename, file_extension = os.path.splitext(parameters_file) if file_extension != ".json": print("Error: invalid file name. \nThe input file has to be a .json file not a %s" % file_extension) exit(1) with open(parameters_file, 'r') as f: config = json.load(f) json_schema_file = 'scripts/schema.json' with open(json_schema_file, 'r') as f: schema = json.load(f) DefaultValidatingDraft4Validator = extend_with_default(Draft4Validator) DefaultValidatingDraft4Validator(schema).validate(config) application_name = config["application_name"] max_number_of_predictions = config['max_number_of_predictions'] optimization_metrics = config["optimization_objectives"] number_of_cpus = config["number_of_cpus"] run_directory = config["run_directory"] if input_data_file == None: output_data_file = config["output_data_file"] if output_data_file == "output_samples.csv": output_data_file = application_name + "_" + output_data_file input_data_file = deal_with_relative_and_absolute_path(run_directory, output_data_file) if output_pareto_file == None: output_pareto_file = config["output_pareto_file"] if output_pareto_file == "output_pareto.csv": output_pareto_file = application_name + "_" + output_pareto_file output_pareto_file = deal_with_relative_and_absolute_path(run_directory, output_pareto_file) param_space = space.Space(config) print("### The input data file is %s" % input_data_file) print("### The output Pareto file is %s" % output_pareto_file) print("################################################") debug = False print("Computing the Pareto...") start_time = datetime.datetime.now() # Compute Pareto and save it to output_pareto_file with open(input_data_file, 'r') as f_csv_file_data_array: count_number_of_points_in_Pareto = compute_pareto(param_space, input_data_file, output_pareto_file, debug, number_of_cpus) end_time = datetime.datetime.now() print(("Total time of computation is (read and Pareto computation): " + str((end_time - start_time).total_seconds()) + " seconds")) print(("The total size of the Pareto (RS + AL) is: %d" % count_number_of_points_in_Pareto)); sys.stdout.flush() print("End of the compute_pareto.py script!\n")
def create_bombs(self): """ Calls the generate_bomb_loc function to generate a list of bomb locations that are then used to change the spaces at those locations to bombs. :return: void """ Board.generate_bomb_loc(self.num_bomb, self.xdim, self.ydim) print(bomb_locations) for location in bomb_locations: self.gameboard[location[1] * self.xdim + location[0]] = space.Space(is_bomb = True, value = 9)
def test_simple_earth_gravity(self): """Test gravitational acceleration at Earth surface near 9.8 m/s^2.""" earth = dot.Dot() earth.mass = constants.EARTH.MASS simple_dot = dot.Dot() simple_dot.pos[0] = constants.EARTH.RADIUS test_space = space.Space(dots=[earth, simple_dot]) test_space.step_acceleration() assert math.isclose(simple_dot.acc[0], -9.8, abs_tol=0.01)
def create_board(gameboard:list, xdim:int, ydim:int): """ Creates an empty two dimensional list of Spaces with the given dimensions. :param board: An empty list which will contain the spaces in the game :type board: list :param xdim: The x dimension of the board :type xdim: int :param ydim: The y dimension of the board :type ydim: int """ for location in range(ydim * xdim): gameboard.append(space.Space())
def worldInit(): # things pie = things.Thing("pie", "A freshly baked pie.", tags=["take", "eat"], eat_val=10) knife = things.Thing("knife", "Sharp as all heck.", tags=["take"]) # Actors GrumphTorgi = actors.Human("Grumph Torgi", "Grumph", "A villain!") SilbertHumperdinck = actors.Human("Silbert Humperdinck", "Sil", "Looks like a respectable fellow.") GertyVanFleek = actors.Human("Gerty Van Fleek", "Gerty", "An old pie woman of some sort.", inventory=[pie]) MelissaMansname = actors.Human("Melissa Mansname", "Mel", "Just wed; nee Forthod") UmbrellaDeVille = actors.Human("Umbrella DeVille", "Ella", "Should be named deMaitreDe.") # Spaces Alley = space.Space("alley", "A dark alley.") Park = space.Space("park", "Look at this grass.") TorgiHome = space.Space("Torgi Household", "The cluttered home of a man named Torgi.") MansnameHome = space.Space("Mansname Household", "Wow! It's hard to come up with descriptions!") VanFleekHome = space.Space("Van Fleek Household", "Reeks of pie.") Restaurant = space.Space("Barren Grille", "I hear they have great desert.") # Spaces -Connections space.Connection(TorgiHome, Park, "north", "south") space.Connection(TorgiHome, Restaurant, "west", "east") space.Connection(Restaurant, Park, "north", "south") space.Connection(Park, Alley, "north", "south") space.Connection(VanFleekHome, Alley, "west", "east") space.Connection(MansnameHome, Alley, "east", "west") # Spaces -things tempKnife = copy(knife) TorgiHome.addThings([tempKnife]) Restaurant.addThings([copy(pie)]) # Spaces -Actors TorgiHome.addActors([GrumphTorgi, SilbertHumperdinck]) Restaurant.addActors([UmbrellaDeVille]) VanFleekHome.addActors([GertyVanFleek]) MansnameHome.addActors([MelissaMansname]) # Actors -Itinerary GrumphTorgi.addItinerary([ (36000, ["take", tempKnife]), (43200, ["move", Park]), (57600, ["move", Alley]), ]) # SilbertHumperdinck.addItinerary([(25200, 'wake up'), ()]) # Player player = actors.User("User") Park.addActors([player]) actors.player = player return player
def experiment(J0, eps_r, start_time, simulation_time): d = 0.05 # PEC box parameters x_length, y_length = 0.5, 0.5 # [m] (i.c. approximately 30 wavelengths) # Initializing a space with a PEC bounding box box = space.Space(x_length, y_length, simulation_time) box.add_objects([ dielectric.Dielectric(1 / 2 * x_length, 0, 1 / 2 * x_length, y_length, eps_r) ]) src = source.Gaussian_pulse(1 / 2 * x_length - d, 1 / 2 * y_length, J0, 4 * 10**(-10), 10**(-10)) box.set_source(src) print("lambda_min ({}): {}".format(eps_r, src.get_lambda_min(eps_r))) Delta_p = src.get_lambda_min(eps_r) / 25 Delta_t = 1 / (3 * c * np.sqrt(2 / Delta_p**2)) box.define_discretization(Delta_p, Delta_p, Delta_t) # Measurement parameters measurement_points = [ (1 / 2 * x_length - d, 1 / 2 * y_length), (1 / 2 * x_length + d, 1 / 2 * y_length), ] measurement_titles = ["Reflected field", "Transmitted field"] # Getting measurments box.add_measurement_points(measurement_points, measurement_titles) measurements = box.FDTD(plot_space=False, visualize_fields=False, eps_averaging=False) start = int(start_time / Delta_t) return np.array([ measurements[0].time_E[start:], measurements[0].time_H[start:], measurements[0].H_x[start:], measurements[0].H_y[start:], measurements[0].E_z[start:], measurements[1].H_x[start:], measurements[1].H_y[start:], measurements[1].E_z[start:], ])
def deviation(dvx, dvy, dist): #simulation of first half of the orbit global glob_pos #some global names to store variables global glob_vel unitmass = 1.0 ut = unit.Unit(np.array([1.0, 0.0, 0.0]), np.array([0.0 + dvx, 1.1 + dvy, 0.0]), unitmass) sp = space.Space() count = 0 planetmass = 1.0 / G pl = planet.Planet(planetmass) sp.planet = pl sp.unit = ut pos = ut.pos dt = 0.001 #simulation step E0 = ut.getEnergy(planetmass) A0 = ut.vectorLenc(planetmass) M0 = ut.getMomentum() while ((ut.pos[1] > ut.vel[1] * dt) or (ut.pos[0] > 0)): #Condition for one half of the orbit #while (ut.movetime(dt) < math.pi): #while (count < math.pi/dt): sp.step(dt, dist) count += 1 arrX.append(ut.pos[0]) arrY.append(ut.pos[1]) E = ut.getEnergy(planetmass) A = ut.vectorLenc(planetmass) M = ut.getMomentum() glob_vel = ut.vel glob_pos = ut.pos #delta = ((E - E0)**2) + vectors.squarelength(M - M0) + vectors.squarelength(A - A0) delta = ((E - E0)**2) + vectors.squarelength(A - A0) #print ('unit position: ',ut.pos) return delta
def deviation2(dvx, dvy, dist): # simulation of the second half sp = space.Space() count = 0 planetmass = 1.0 / G pl = planet.Planet(planetmass) sp.planet = pl unitmass = 1.0 pos = glob_pos vel = glob_vel dv = np.array([dvx, dvy, 0]) ut = unit.Unit(pos, (vel + dv), unitmass) sp.unit = ut #print ('start velocity', ut.vel) dt = 0.001 E0 = ut.getEnergy(planetmass) A0 = ut.vectorLenc(planetmass) M0 = ut.getMomentum() #while (ut.pos[1] < ut.vel[1] * dt) or (ut.pos[0] < 0 ): #Condition for second half of the orbit #while (ut.pos[1] <= 0): while (count < math.pi / dt): sp.step(dt, dist) count += 1 arrX.append(ut.pos[0]) arrY.append(ut.pos[1]) E = ut.getEnergy(planetmass) A = ut.vectorLenc(planetmass) M = ut.getMomentum() #delta = ((E - E0)**2) + vectors.squarelength(M - M0) + vectors.squarelength(A - A0) delta = ((E - E0)**2) + vectors.squarelength(A - A0) #print ('unit position: ', ut.pos , 'unit velocity: ', ut.vel) return delta
def __init__(self, alpha, beta, tau, env, gamma=0.99, size=1000000, batch_size=64, checkpoint='tmp/ddpg', max_actions=1e6, k_ratio=0.1): super().__init__(alpha, beta, tau, env, gamma, size, batch_size, checkpoint) self.experiment = env.spec.id if self.continious_action_space: self.action_space = space.Space(self.low, self.high, max_actions) max_actions = self.action_space.get_number_of_actions() else: max_actions = int(env.action_space.n) * 5 self.action_space = space.Discrete_space(max_actions) self.k_nearest_neighbors = max(5, int(max_actions * k_ratio))
def main(): search_space = s.Space(0.0, epsilon, 500) particles_vector = [ p.Particle() for _ in range(search_space.num_particles) ] search_space.particles = particles_vector search_space.set_pbest() search_space.set_gbest() iteration = 0 n_iterations = 100 val_prev = val_prev_1 = 0.0 while iteration < n_iterations or search_space.gbest_value <= epsilon: search_space.set_pbest() search_space.set_gbest() # JEŚLI PRZEZ TRZY ITERACJE NIE ZMIENI SIE WARTOŚĆ => BREAK if iteration == 0: val_prev = search_space.gbest_value else: val_prev_1 = val_prev val_prev = search_space.gbest_value #print("POŁOŻENIE: ", search_space.gbest_position, " WARTOŚĆ: ", search_space.gbest_value) if abs(search_space.gbest_value - search_space.target ) <= search_space.epsilon or val_prev_1 == val_prev: break search_space.move_particles() iteration += 1 save(search_space.gbest_value, 0) print("Solution: ", search_space.gbest_position, " value ", search_space.gbest_value) file = open("model.txt", 'a') file.write(str(search_space.gbest_position) + " \n") file.close() return search_space.gbest_position
def main(): search_space = s.Space(optimization_target, epsilon, 25) particles_vector = [ p.Particle() for _ in range(search_space.num_particles) ] search_space.particles = particles_vector search_space.set_pbest() search_space.set_gbest() iteration = 0 n_iterations = 1000 val_prev = val_prev_1 = 0.0 while iteration < n_iterations or search_space.gbest_value < epsilon: print(iteration) search_space.set_pbest() search_space.set_gbest() if iteration == 0: val_prev = search_space.gbest_value else: val_prev_1 = val_prev val_prev = search_space.gbest_value #print("POŁOŻENIE: ", search_space.gbest_position, " WARTOŚĆ: ", search_space.gbest_value) saveToFile(search_space.gbest_value, "main_22.csv") saveToFile(search_space.gbest_position, "coordinates_22.csv") if iteration > 10: if abs(search_space.gbest_value - search_space.target ) <= search_space.epsilon or val_prev_1 == val_prev: break search_space.move_particles() iteration += 1 #print("Solution: ", search_space.gbest_position, " value ", search_space.gbest_value) return search_space.gbest_position
omega_c = 10**5 # [Hz] = 1 GHz omega_c = 0 # [Hz] = 1 GHz sigma = 5 * 10**(-9) # [s] tc = 3 * sigma # [s] # Initializing the source (Choices: Sine_source, Gaussian_pulse, Gaussian_modulated_rd_pulse) # src = source.Sine_source(x_source, y_source, J0, omega_c) src = source.Gaussian_pulse(x_source, y_source, J0, tc, sigma) # src = source.Gaussian_modulated_rf_pulse(x_source, y_source, J0, tc, sigma, omega_c) # PEC box parameters x_length, y_length = 2 * x_source, 2 * y_source # [m] t_length = 7 * tc # [s] # Initializing a space with a PEC bounding box box = space.Space(x_length, y_length, t_length) box.set_source(src) # Discretization parameters (Based on limits in project description) Delta_x = src.get_lambda_min(1) / 30 Delta_y = Delta_x Delta_t = 1 / (c * np.sqrt(1 / Delta_x**2 + 1 / Delta_y**2)) * 1.0001 # Handing discretization parameters to our space box.define_discretization(Delta_x, Delta_y, Delta_t) # Measurement parameters measurement_points = [ (x_source, y_source) ] # [(1.1*x_source, 1.1*y_source)] + [(1.2*x_source, 1.24*y_source)] # List of measurement point coordinates [(m, m)] measurement_labels = [r" $1.0001$ Courant limit $t_{max} = 7 t_c$"
def main(config, black_box_function=None, output_file=""): """ Run design-space exploration using bayesian optimization. :param config: dictionary containing all the configuration parameters of this optimization. :param output_file: a name for the file used to save the dse results. """ start_time = (datetime.datetime.now()) run_directory = config["run_directory"] hypermapper_mode = config["hypermapper_mode"]["mode"] # Start logging log_file = deal_with_relative_and_absolute_path(run_directory, config["log_file"]) sys.stdout.change_log_file(log_file) if (hypermapper_mode == 'client-server'): sys.stdout.switch_log_only_on_file(True) # Log the json configuration for this optimization sys.stdout.write_to_logfile(str(config) + "\n") # Create parameter space object and unpack hyperparameters from json param_space = space.Space(config) application_name = config["application_name"] optimization_metrics = config["optimization_objectives"] optimization_iterations = config["optimization_iterations"] evaluations_per_optimization_iteration = config[ "evaluations_per_optimization_iteration"] number_of_cpus = config["number_of_cpus"] print_importances = config["print_parameter_importance"] epsilon_greedy_threshold = config["epsilon_greedy_threshold"] acquisition_function = config["acquisition_function"] weight_sampling = config["weight_sampling"] scalarization_method = config["scalarization_method"] scalarization_key = config["scalarization_key"] doe_type = config["design_of_experiment"]["doe_type"] number_of_doe_samples = config["design_of_experiment"]["number_of_samples"] model_type = config["models"]["model"] optimization_method = config["optimization_method"] time_budget = config["time_budget"] input_params = param_space.get_input_parameters() number_of_objectives = len(optimization_metrics) objective_limits = {} data_array = {} fast_addressing_of_data_array = {} objective_bounds = None exhaustive_search_data_array = None normalize_objectives = False debug = False if "feasible_output" in config: feasible_output = config["feasible_output"] feasible_output_name = feasible_output["name"] enable_feasible_predictor = feasible_output[ "enable_feasible_predictor"] enable_feasible_predictor_grid_search_on_recall_and_precision = feasible_output[ "enable_feasible_predictor_grid_search_on_recall_and_precision"] feasible_predictor_grid_search_validation_file = feasible_output[ "feasible_predictor_grid_search_validation_file"] feasible_parameter = param_space.get_feasible_parameter() number_of_trees = config["models"]["number_of_trees"] if (weight_sampling == "bounding_box"): objective_bounds = {} user_bounds = config["bounding_box_limits"] if (len(user_bounds) == 2): if (user_bounds[0] > user_bounds[1]): user_bounds[0], user_bounds[1] = user_bounds[1], user_bounds[0] for objective in optimization_metrics: objective_bounds[objective] = user_bounds objective_limits[objective] = user_bounds elif (len(user_bounds) == number_of_objectives * 2): idx = 0 for objective in optimization_metrics: objective_bounds[objective] = user_bounds[idx:idx + 2] if (objective_bounds[objective][0] > objective_bounds[objective][1]): objective_bounds[objective][0], objective_bounds[ objective][1] = objective_bounds[objective][ 1], objective_bounds[objective][0] objective_limits[objective] = objective_bounds[objective] idx += 2 else: print("Wrong number of bounding boxes, expected 2 or", 2 * number_of_objectives, "got", len(user_bounds)) raise SystemExit else: for objective in optimization_metrics: objective_limits[objective] = [float("inf"), float("-inf")] if output_file == "": output_data_file = config["output_data_file"] if output_data_file == "output_samples.csv": output_data_file = application_name + "_" + output_data_file else: output_data_file = output_file exhaustive_search_data_array = None exhaustive_search_fast_addressing_of_data_array = None if hypermapper_mode == 'exhaustive': exhaustive_file = config["hypermapper_mode"]["exhaustive_search_file"] exhaustive_search_data_array, exhaustive_search_fast_addressing_of_data_array = param_space.load_data_file( exhaustive_file, debug=False, number_of_cpus=number_of_cpus) # Check if some parameters are correctly defined if hypermapper_mode == "default": if black_box_function == None: print("Error: the black box function must be provided") raise SystemExit if not callable(black_box_function): print("Error: the black box function parameter is not callable") raise SystemExit if (model_type == "gaussian_process") and (acquisition_function == "TS"): print( "Error: The TS acquisition function with Gaussian Process models is still under implementation" ) print("Using EI acquisition function instead") config["acquisition_function"] = "EI" if number_of_cpus > 1: print( "Warning: HyperMapper supports only sequential execution for now. Running on a single cpu." ) number_of_cpus = 1 # If priors are present, use prior-guided optimization user_priors = False for input_param in config["input_parameters"]: if config["input_parameters"][input_param]["prior"] != "uniform": if number_of_objectives == 1: user_priors = True else: print( "Warning: prior optimization does not work with multiple objectives yet, priors will be uniform" ) config["input_parameters"][input_param]["prior"] = "uniform" if user_priors: bo_method = prior_guided_optimization else: bo_method = random_scalarizations normalize_objectives = True ### Resume previous optimization, if any beginning_of_time = param_space.current_milli_time() absolute_configuration_index = 0 doe_t0 = datetime.datetime.now() if config["resume_optimization"] == True: resume_data_file = config["resume_optimization_data"] if not resume_data_file.endswith('.csv'): print("Error: resume data file must be a CSV") raise SystemExit if resume_data_file == "output_samples.csv": resume_data_file = application_name + "_" + resume_data_file data_array, fast_addressing_of_data_array = param_space.load_data_file( resume_data_file, debug=False, number_of_cpus=number_of_cpus) absolute_configuration_index = len(data_array[list(data_array.keys( ))[0]]) # get the number of points evaluated in the previous run beginning_of_time = beginning_of_time - data_array[ param_space.get_timestamp_parameter()[0]][ -1] # Set the timestamp back to match the previous run print("Resumed optimization, number of samples = %d ......." % absolute_configuration_index) ### DoE phase if absolute_configuration_index < number_of_doe_samples: configurations = [] default_configuration = param_space.get_default_or_random_configuration( ) str_data = param_space.get_unique_hash_string_from_values( default_configuration) if str_data not in fast_addressing_of_data_array: fast_addressing_of_data_array[ str_data] = absolute_configuration_index configurations.append(default_configuration) absolute_configuration_index += 1 doe_configurations = [] if absolute_configuration_index < number_of_doe_samples: doe_configurations = param_space.get_doe_sample_configurations( fast_addressing_of_data_array, number_of_doe_samples - absolute_configuration_index, doe_type) configurations += doe_configurations print( "Design of experiment phase, number of new doe samples = %d ......." % len(configurations)) doe_data_array = param_space.run_configurations( hypermapper_mode, configurations, beginning_of_time, black_box_function, exhaustive_search_data_array, exhaustive_search_fast_addressing_of_data_array, run_directory) data_array = concatenate_data_dictionaries( data_array, doe_data_array, param_space.input_output_and_timestamp_parameter_names) absolute_configuration_index = number_of_doe_samples iteration_number = 1 else: iteration_number = absolute_configuration_index - number_of_doe_samples + 1 # If we have feasibility constraints, we must ensure we have at least one feasible and one infeasible sample before starting optimization # If this is not true, continue design of experiment until the condition is met if enable_feasible_predictor: while are_all_elements_equal(data_array[ feasible_parameter[0]]) and optimization_iterations > 0: print( "Warning: all points are either valid or invalid, random sampling more configurations." ) print("Number of doe samples so far:", absolute_configuration_index) configurations = param_space.get_doe_sample_configurations( fast_addressing_of_data_array, 1, "random sampling") new_data_array = param_space.run_configurations( hypermapper_mode, configurations, beginning_of_time, black_box_function, exhaustive_search_data_array, exhaustive_search_fast_addressing_of_data_array, run_directory) data_array = concatenate_data_dictionaries( new_data_array, data_array, param_space.input_output_and_timestamp_parameter_names) absolute_configuration_index += 1 optimization_iterations -= 1 # Create output file with explored configurations from resumed run and DoE with open( deal_with_relative_and_absolute_path(run_directory, output_data_file), 'w') as f: w = csv.writer(f) w.writerow(param_space.get_input_output_and_timestamp_parameters()) tmp_list = [ param_space.convert_types_to_string(j, data_array) for j in param_space.get_input_output_and_timestamp_parameters() ] tmp_list = list(zip(*tmp_list)) for i in range(len(data_array[optimization_metrics[0]])): w.writerow(tmp_list[i]) for objective in optimization_metrics: lower_bound = min(objective_limits[objective][0], min(data_array[objective])) upper_bound = max(objective_limits[objective][1], max(data_array[objective])) objective_limits[objective] = [lower_bound, upper_bound] print( "\nEnd of doe/resume phase, the number of evaluated configurations is: %d\n" % absolute_configuration_index) sys.stdout.write_to_logfile( ("End of DoE - Time %10.4f sec\n" % ((datetime.datetime.now() - doe_t0).total_seconds()))) if doe_type == "grid_search" and optimization_iterations > 0: print( "Warning: DoE is grid search, setting number of optimization iterations to 0" ) optimization_iterations = 0 ### Main optimization loop if evaluations_per_optimization_iteration > 1: print("Warning, number of evaluations per iteration > 1") print( "HyperMapper bayesian optimization currently does not support multiple runs per iteration, setting evaluations per iteration to 1" ) bo_t0 = datetime.datetime.now() run_time = (datetime.datetime.now() - start_time).total_seconds() / 60 # run_time / time_budget < 1 if budget > elapsed time or budget == -1 if time_budget > 0: print('starting optimization phase, limited to run for ', time_budget, ' minutes') elif time_budget == 0: print( 'Time budget cannot be zero. To not limit runtime set time_budget = -1' ) sys.exit() while iteration_number <= optimization_iterations and run_time / time_budget < 1: print("Starting optimization iteration", iteration_number) iteration_t0 = datetime.datetime.now() model_t0 = datetime.datetime.now() regression_models, _, _ = models.generate_mono_output_regression_models( data_array, param_space, input_params, optimization_metrics, 1.00, config, model_type=model_type, number_of_cpus=number_of_cpus, print_importances=print_importances, normalize_objectives=normalize_objectives, objective_limits=objective_limits) classification_model = None if enable_feasible_predictor: classification_model, _, _ = models.generate_classification_model( application_name, param_space, data_array, input_params, feasible_parameter, 1.00, config, debug, number_of_cpus=number_of_cpus, data_array_exhaustive=exhaustive_search_data_array, enable_feasible_predictor_grid_search_on_recall_and_precision= enable_feasible_predictor_grid_search_on_recall_and_precision, feasible_predictor_grid_search_validation_file= feasible_predictor_grid_search_validation_file, print_importances=print_importances) model_t1 = datetime.datetime.now() if (weight_sampling == "bounding_box"): objective_weights = sample_weight_bbox(optimization_metrics, objective_bounds, 1)[0] elif (weight_sampling == "flat"): objective_weights = sample_weight_flat(optimization_metrics, 1)[0] else: print("Error: unrecognized option:", weight_sampling) raise SystemExit data_array_scalarization, _ = compute_data_array_scalarization( data_array, objective_weights, objective_limits, scalarization_method) data_array[scalarization_key] = data_array_scalarization.tolist() epsilon = random.uniform(0, 1) local_search_t0 = datetime.datetime.now() if epsilon > epsilon_greedy_threshold: best_configuration = bo_method(config, data_array, param_space, fast_addressing_of_data_array, regression_models, iteration_number, objective_weights, objective_limits, classification_model) else: sys.stdout.write_to_logfile( str(epsilon) + " < " + str(epsilon_greedy_threshold) + " random sampling a configuration to run\n") best_configuration = param_space.random_sample_configurations_without_repetitions( fast_addressing_of_data_array, 1)[0] local_search_t1 = datetime.datetime.now() configurations = [best_configuration] str_data = param_space.get_unique_hash_string_from_values( best_configuration) fast_addressing_of_data_array[str_data] = absolute_configuration_index absolute_configuration_index += 1 black_box_function_t0 = datetime.datetime.now() new_data_array = param_space.run_configurations( hypermapper_mode, configurations, beginning_of_time, black_box_function, exhaustive_search_data_array, exhaustive_search_fast_addressing_of_data_array, run_directory) black_box_function_t1 = datetime.datetime.now() with open( deal_with_relative_and_absolute_path(run_directory, output_data_file), 'a') as f: w = csv.writer(f) tmp_list = [ param_space.convert_types_to_string(j, new_data_array) for j in list(param_space.get_input_output_and_timestamp_parameters()) ] tmp_list = list(zip(*tmp_list)) for i in range(len(new_data_array[optimization_metrics[0]])): w.writerow(tmp_list[i]) data_array = concatenate_data_dictionaries( new_data_array, data_array, param_space.input_output_and_timestamp_parameter_names) for objective in optimization_metrics: lower_bound = min(objective_limits[objective][0], min(data_array[objective])) upper_bound = max(objective_limits[objective][1], max(data_array[objective])) objective_limits[objective] = [lower_bound, upper_bound] iteration_number += 1 run_time = (datetime.datetime.now() - start_time).total_seconds() / 60 sys.stdout.write_to_logfile(("Model fitting time %10.4f sec\n" % ((model_t1 - model_t0).total_seconds()))) sys.stdout.write_to_logfile( ("Local search time %10.4f sec\n" % ((local_search_t1 - local_search_t0).total_seconds()))) sys.stdout.write_to_logfile(("Black box function time %10.4f sec\n" % ( (black_box_function_t1 - black_box_function_t0).total_seconds()))) sys.stdout.write_to_logfile( ("Total iteration time %10.4f sec\n" % ((datetime.datetime.now() - iteration_t0).total_seconds()))) sys.stdout.write_to_logfile( ("End of BO phase - Time %10.4f sec\n" % ((datetime.datetime.now() - bo_t0).total_seconds()))) print("End of Bayesian Optimization") sys.stdout.write_to_logfile( ("Total script time %10.2f sec\n" % ((datetime.datetime.now() - start_time).total_seconds())))
def main(parameters_file, output_hvi_file_name, list_of_dirs): """ Plot the hypervolume indicator (HVI) results of the design space exploration. In this plot specifically we plot the HVI of HyperMapper's DSE against the HVI of a competing approach. On the x axis we plot time in seconds and on the y axis the HVI. HVI to be computed needs a real Pareto or at least a Pareto that is the best found by the results concatenation of HyperMapper and the competing approach. ###################################################### ######### Input of this script ###################### # 1) a file that is the real Pareto or the best Pareto found # (supposing the we are comparing several approaches for example the best Pareto is the result of all these approaches combined). # 2) a file containing all the samples of the exploration (not only the Pareto). # From this file we can compute the Pareto at time t and then the hvi at time t """ xlabel = "Time (sec)" ylabel = "HyperVolume Indicator (HVI)" number_of_bins = 20 filename, file_extension = os.path.splitext(parameters_file) if file_extension != ".json": print( "Error: invalid file name. \nThe input file has to be a .json file not a %s" % file_extension) exit(1) with open(parameters_file, 'r') as f: config = json.load(f) json_schema_file = 'scripts/schema.json' with open(json_schema_file, 'r') as f: schema = json.load(f) DefaultValidatingDraft4Validator = extend_with_default(Draft4Validator) DefaultValidatingDraft4Validator(schema).validate(config) if "application_name" in config: application_name = config["application_name"] else: application_name = "" print("########## plot_hvi.py #########################") print("### Parameters file is %s" % parameters_file) print("### Application name is %s" % application_name) print("### The input directories data are %s" % str(list_of_dirs)) print("################################################") param_space = space.Space(config) optimization_metrics = param_space.get_optimization_parameters() ################################################################################################################### ########### Compute the hypervolume of all the input files concatenated as a reference for the HVI metric. ################################################################################################################### input_files = {} # y_data_mean is dict on the directories that for each entry in the dict contains the mean of each point x over multiple file repetitions in one directory; lower and upper are for the confidence interval. y_data_mean = defaultdict(list) y_data_median = defaultdict(list) y_data_min = defaultdict(list) y_data_max = defaultdict(list) y_data_lower = defaultdict(list) y_data_upper = defaultdict(list) bin_array_X = {} number_or_runs_in_bins = {} for dir in list_of_dirs: input_files[dir] = [f for f in listdir(dir) if isfile(join(dir, f))] for dir in list_of_dirs: files_to_remove = [] for file in input_files[dir]: filename, file_extension = os.path.splitext(file) if file_extension != ".csv": print( "Warning: file %s is not a csv file, it will not be considered in the HVI plot. " % file) files_to_remove.append(file) # Don't move this for loop inside the previous identical one otherwise you will remove the elements before they get process because of overlapping references. for file in files_to_remove: input_files[dir].remove(file) for dir in list_of_dirs: if len(input_files[dir]) == 0: print( "Warning: directory %s is empty, it will not be considered in the HVI plot." ) del input_files[dir] if len(input_files) == 0: print("Error: there no input files to compute the HVI.") print("The files used as a input are: ") for i, dir in enumerate(input_files.keys()): print("Directory " + str(i) + ": " + dir + ", # of files: " + str(len(input_files[dir])) + ", list of files: " + str(input_files[dir])) all_data_files = [] for dir in input_files.keys(): for file in input_files[dir]: all_data_files += [dir + "/" + file] selection_keys = param_space.get_output_parameters( ) + param_space.get_timestamp_parameter() feasible_flag = True if ( param_space.get_feasible_parameter() != [None]) else False concatenated_all_data_array = param_space.load_data_files( all_data_files, selection_keys_list=selection_keys, only_valid=feasible_flag) if len(next(iter(concatenated_all_data_array.values()))) == 0: return return_empty_images(application_name, input_files, number_of_bins, output_hvi_file_name, xlabel, ylabel) bounds = {} max_point = [] standard_deviation_optimization_metrics = [] max_min_difference = [] # Get bounds of objective space for metric in optimization_metrics: X = np.array(concatenated_all_data_array[metric]) standard_deviation = np.std(X, axis=0) standard_deviation_optimization_metrics.append(standard_deviation) X /= standard_deviation concatenated_all_data_array[metric] = X bounds[metric] = (min(concatenated_all_data_array[metric]), max(concatenated_all_data_array[metric])) max_point.append(bounds[metric][1]) max_min_difference.append(bounds[metric][1] - bounds[metric][0]) print( "(min, max) = (%f, %f) for the metric %s. This is to compute the hypervolume." % (bounds[metric][0], bounds[metric][1], metric)) total_volume = prod(max_min_difference) list_of_objectives = [ concatenated_all_data_array[objective] for objective in param_space.get_optimization_parameters() ] reformatted_all_data = list(zip(*list_of_objectives)) # Get dominated hypervolume for Pareto of all data observed hv_all_data = H(reformatted_all_data, max_point) print("The hypervolume of all the files concatenated: %d" % hv_all_data) ################################################################################################################### ########### Compute the HVI for each directory. ################################################################################################################### hvi = {} for dir in input_files: print("Compute HVI for %s" % dir) convert_in_seconds = 1000.0 hvi[dir], bin_array_X[dir], number_or_runs_in_bins[dir] = compute_hvi( standard_deviation_optimization_metrics, input_files[dir], dir, total_volume, max_point, hv_all_data, param_space, convert_in_seconds, number_of_bins) # Round the floating point numbers to 1 decimal for clarity of visualization. bin_array_X[dir] = [round(float(i), 1) for i in bin_array_X[dir]] for file in hvi[dir]: for bin in hvi[dir][file]: hvi[dir][file][bin] = round(float(hvi[dir][file][bin]), 1) ################################################################################################################### ########### Plot all the HVIs (using box plots bin_array_X and hvi) ################################################################################################################### for dir in input_files: hvi_list_of_lists = [] each_bin = defaultdict(list) for file in hvi[dir]: for bin in hvi[dir][file]: each_bin[bin].append(hvi[dir][file][bin]) for bin in hvi[dir][file]: hvi_list_of_lists.append( each_bin[bin] ) # This is a list of bins and for each bin there is a list of hvi values for each file in that directory. # Print boxplot (one figure per directory). boxplot(bin_array_X[dir], hvi_list_of_lists, application_name, number_of_bins, xlabel, ylabel, str(dir + "/" + os.path.basename(dir) + "_boxplot" + ".pdf")) # Print lineplot (only one figure comparing all the directories). for hvi_list in hvi_list_of_lists: hvi_list_array = np.array(hvi_list) y_data_mean[dir].append(hvi_list_array.mean()) y_data_median[dir].append(np.median(hvi_list_array)) y_data_min[dir].append(np.min(hvi_list_array)) y_data_max[dir].append(np.max(hvi_list_array)) low, up = sms.DescrStatsW(hvi_list_array).tconfint_mean() y_data_lower[dir].append(low) y_data_upper[dir].append(up) for bin_number, bin_value in enumerate(y_data_lower[dir]): if not math.isnan(bin_value) and bin_value < 0: y_data_lower[dir][bin_number] = 0 for bin_number, bin_value in enumerate(y_data_upper[dir]): if not math.isnan(bin_value) and bin_value < 0: y_data_upper[dir][bin_number] = 0 print_stats_on_a_txt( dir, str(dir + "/" + os.path.basename(dir) + "_stats" + ".txt"), bin_array_X, number_or_runs_in_bins, y_data_mean, y_data_median, y_data_min, y_data_max, y_data_lower, y_data_upper) # Call the function to create plot lineplotCI(input_files, application_name, x_data=bin_array_X, y_data=y_data_mean, low_CI=y_data_lower, upper_CI=y_data_upper, xlabel=xlabel, ylabel=ylabel, title="Line plot with 95% confidence intervals", output_filename=output_hvi_file_name)
def HVI_from_files(real_pareto_file, parameters_file): """ Compute hvi for a target Pareto front using the real Pareto front as reference. :param real_pareto_file: file containing the real Pareto front :param parameters_file: file containing the experiment scenario. Also used to find the target Pareto file. :return: the hvi of the target Pareto front """ config = validate_json(parameters_file) param_space = space.Space(config) application_name = config["application_name"] test_pareto_file = config["output_pareto_file"] run_directory = config["run_directory"] if test_pareto_file == "output_pareto.csv": test_pareto_file = application_name + "_" + test_pareto_file test_pareto_file = deal_with_relative_and_absolute_path( run_directory, test_pareto_file) optimization_metrics = param_space.get_optimization_parameters() selection_keys = optimization_metrics + param_space.get_timestamp_parameter( ) feasible_flag = True if ( param_space.get_feasible_parameter() != [None]) else False exhaustive_branin_pareto, _ = param_space.load_data_file( real_pareto_file, selection_keys_list=selection_keys, only_valid=feasible_flag) test_pareto, _ = param_space.load_data_file( test_pareto_file, selection_keys_list=selection_keys, only_valid=feasible_flag) concatenated_all_data_array = concatenate_data_dictionaries( exhaustive_branin_pareto, test_pareto, selection_keys_list=selection_keys) standard_deviations, max_point = compute_std_and_max_point( concatenated_all_data_array, optimization_metrics) exhaustive_branin_pareto = normalize_with_std(exhaustive_branin_pareto, standard_deviations, optimization_metrics) test_pareto = normalize_with_std(test_pareto, standard_deviations, optimization_metrics) exhaustive_branin_pareto = [ exhaustive_branin_pareto[objective] for objective in optimization_metrics ] exhaustive_branin_pareto = list(zip(*exhaustive_branin_pareto)) test_pareto = [ test_pareto[objective] for objective in optimization_metrics ] test_pareto = list(zip(*test_pareto)) hv_exhaustive = H(exhaustive_branin_pareto, max_point) hv_test = H(test_pareto, max_point) hvi = hv_exhaustive - hv_test return hvi
def main(config, black_box_function=None, output_file=""): """ Run design-space exploration using evolution. :param config: dictionary containing all the configuration parameters of this design-space exploration. :param black_box_function: The function hypermapper seeks to optimize :param output_file: a name for the file used to save the dse results. :return: """ param_space = space.Space(config) run_directory = config["run_directory"] application_name = config["application_name"] hypermapper_mode = config["hypermapper_mode"]["mode"] if hypermapper_mode == "default": if black_box_function == None: print("Error: the black box function must be provided") raise SystemExit if not callable(black_box_function): print("Error: the black box function parameter is not callable") raise SystemExit optimization_metrics = config["optimization_objectives"] number_of_objectives = len(optimization_metrics) if number_of_objectives != 1: print( "the evolutionary optimization does not support multi-objective optimization. Exiting." ) sys.exit() fitness_measure = optimization_metrics[0] population_size = config["evolution_population_size"] generations = config["evolution_generations"] mutation_rate = config["mutation_rate"] if mutation_rate > len(param_space.get_input_parameters()): print( "mutation rate cannot be higher than the number of parameters. Exiting." ) sys.exit() if mutation_rate < 1: print( "mutation rate must be at least 1 for evolution to work. Exiting.") sys.exit() crossover = config["evolution_crossover"] regularize = config["regularize_evolution"] batch_size = config["batch_size"] if batch_size > population_size: print("population_size must be bigger than batch_size. Exiting.") sys.exit() elif batch_size < 2 and not crossover: print("batch_size cannot be smaller than 2. Exiting.") sys.exit() elif batch_size < 3 and crossover: print("batch_size must be at least 3 when using crossover. Exiting.") sys.exit() log_file = deal_with_relative_and_absolute_path(run_directory, config["log_file"]) sys.stdout.change_log_file(log_file) if hypermapper_mode == "client-server": sys.stdout.switch_log_only_on_file(True) if output_file == "": output_data_file = config["output_data_file"] if output_data_file == "output_samples.csv": output_data_file = application_name + "_" + output_data_file else: output_data_file = output_file absolute_configuration_index = 0 fast_addressing_of_data_array = {} evolution_fast_addressing_of_data_array = {} evolution_data_array = defaultdict(list) beginning_of_time = param_space.current_milli_time() optimization_function_parameters = dict() optimization_function_parameters['hypermapper_mode'] = hypermapper_mode optimization_function_parameters['param_space'] = param_space optimization_function_parameters['beginning_of_time'] = beginning_of_time optimization_function_parameters['run_directory'] = run_directory optimization_function_parameters['black_box_function'] = black_box_function optimization_function_parameters[ 'evolution_data_array'] = evolution_data_array optimization_function_parameters[ 'fast_addressing_of_data_array'] = evolution_fast_addressing_of_data_array print("Starting evolution...") evolution_t0 = datetime.datetime.now() all_samples = evolution(population_size, generations, mutation_rate, crossover, regularize, batch_size, fitness_measure, param_space, fast_addressing_of_data_array, run_objective_function, optimization_function_parameters) print("Evolution finished after %d function evaluations" % (len(evolution_data_array[optimization_metrics[0]]))) sys.stdout.write_to_logfile( ("Evolutionary search time %10.4f sec\n" % ((datetime.datetime.now() - evolution_t0).total_seconds()))) with open( deal_with_relative_and_absolute_path(run_directory, output_data_file), 'w') as f: w = csv.writer(f) w.writerow(list(evolution_data_array.keys())) tmp_list = [ param_space.convert_types_to_string(j, evolution_data_array) for j in list(evolution_data_array.keys()) ] tmp_list = list(zip(*tmp_list)) for i in range(len(evolution_data_array[optimization_metrics[0]])): w.writerow(tmp_list[i]) print("### End of the evolutionary search")
import space if __name__ == '__main__': earth = dot.Dot() earth.mass = constants.EARTH.MASS moon = dot.Dot() moon.mass = constants.MOON.MASS moon.pos[0] = constants.MOON.PERIGEE_ORBIT_RADIUS moon.vel[1] = constants.MOON.MAX_ORBITAL_VELOCITY moon.vel[2] = 20 earth.vel[ 1] = -constants.MOON.MAX_ORBITAL_VELOCITY * moon.mass / earth.mass test_space = space.Space(dots=[earth, moon]) print() print(test_space) n_loops = 3 n_iterations = 1000 results = numpy.zeros(shape=(n_iterations, 12)) dt = n_loops * constants.MOON.SIDEREAL_ROTATION_PERIOD / n_iterations for iteration in range(n_iterations): test_space.step(time=dt) results[iteration, 0:3] = moon.acc results[iteration, 3:6] = moon.vel results[iteration, 6:9] = moon.pos results[iteration, 9:12] = earth.pos
def deviation(dvx,dvy, dist): sp = space.Space() count = 0 planetmass = 1.0 / G pl = planet.Planet(planetmass) sp.planet = pl unitmass = 1.0 ut = unit.Unit(np.array([0.9,0.0,0.0]),np.array([0.0+dvx,1.0+dvy,0.0]), unitmass) sp.unit = ut t = 0 angle = 0 dt = 0.01 # simulation step pos0 = np.array([1,0.0,0.0]) pos = ut.pos E0 = ut.getEnergy(planetmass) A0 = ut.vectorLenc(planetmass) U0 = ut.getPotentialEnergy(planetmass) KO = ut.getKinectEnergy() #----------------Arrays of physical quantities ---------------- arrE = [] arrt = [] arrT = [] arrX = [] arrY = [] arrU = [] arrK = [] arrA = [] arrM = [] arrM_full = [] arrMx = [] arrMy = [] arrMz = [] arrAx = [] arrAy = [] arrAz = [] arrAngle = [] arrA_full = [] #------------------Simulation cycle----------------------------- n = 10 # number of circles while (t<(2*math.pi)*n): #one circle sp.step_rot(dt, dist, angle) count +=1 t+=dt angle+= math.degrees(0.001/57) E = ut.getEnergy(planetmass) U = ut.getPotentialEnergy(planetmass) K = ut.getKinectEnergy() A = ut.vectorLenc(planetmass) M = ut.getMomentum() Angle = math.atan2(ut.vectorLenc(planetmass)[0],ut.vectorLenc(planetmass)[1]) T = t / (2 * math.pi) # number of orbits done #-----------------Filling the arrays---------------------------- arrK.append(K) arrE.append(E) arrU.append(U) arrt.append(t) arrT.append(T) arrX.append(ut.pos[0]) arrY.append(ut.pos[1]) arrA.append(A) arrAx.append(A[0]) arrAy.append(A[1]) arrAz.append(A[2]) arrA_full.append(A[0]+A[1]+A[2]) arrMx.append(M[0]) arrMy.append(M[1]) arrMz.append(M[2]) arrM_full.append(M[0]+M[1]+M[2]) arrAngle.append(Angle) #-------------------------------------------------------------- #plt.plot(lnh, lnE) #------------------ graph plotting----------------------------- plt.figure(1) plt.xlabel('Number of circles') plt.ylabel('Potential Energy') plt.title('Potential Energy of the spacecraft') plt.axis([0, n, 0, 2]) plt.grid(True) plt.plot(arrT,arrU) #plt.plot(arrX,arrY) plt.figure(2) plt.xlabel('Number of circles') plt.ylabel('Angle') plt.grid(True) plt.plot(arrT, arrAngle) plt.figure(3) plt.xlabel('Number of circles') plt.ylabel('E') plt.title('Total Energy of the spacecraft') plt.axis([0, n, -0.7, -0.3]) plt.grid(True) plt.plot(arrT, arrE) plt.figure(4) plt.xlabel('x') plt.ylabel('y') plt.title('Orbit of the spacecraft') plt.axis([-1.5, 1.5, -1.5, 1.5]) plt.grid(True) plt.plot(arrX, arrY) plt.figure(5) plt.axis([0, n, -1, 2]) plt.grid(True) plt.plot(arrT, arrA_full) plt.xlabel('Number of circles') plt.ylabel('A') plt.title('Laplace–Runge–Lenz vector state ') plt.figure(6) plt.axis([0, n, -1, 2]) plt.grid(True) fig, ax = plt.subplots() ax.plot(arrT, arrAx, label ='x_component') ax.plot(arrT, arrAy, label ='y_component') ax.plot(arrT, arrAz, label ='z_component') plt.xlabel('Number of circles') plt.ylabel('A') plt.title('Laplace–Runge–Lenz vector components state ') legend = ax.legend(loc='upper right', shadow=True) frame = legend.get_frame() frame.set_facecolor('0.90') plt.figure(7) plt.axis([0, n, -1, 2]) plt.grid(True) fig, ay = plt.subplots() ay.plot(arrT, arrMx, label='x_component') ay.plot(arrT, arrMy, label='y_component') ay.plot(arrT, arrMz, label='z_component') plt.xlabel('Number of circles') plt.ylabel('A') plt.title('Angular momentum state ') legend = ay.legend(loc='upper right', shadow=True) frame = legend.get_frame() frame.set_facecolor('0.90') # Set the fontsize for label in legend.get_texts(): label.set_fontsize('large') for label in legend.get_lines(): label.set_linewidth(1.5) # the legend line width plt.show() #-------------------------------------------------------------- M = ut.getMomentum() #delta = ((E - E0)**2) + vectors.squarelength(M - M0) + vectors.squarelength(A - A0) delta = ((E - E0) ** 2) + vectors.squarelength(A - A0) return delta
def main(parameters_file, list_of_pairs_of_files=[], image_output_file=None): """ Plot the results of the previously run design space exploration. """ show_samples = False filename, file_extension = os.path.splitext(parameters_file) if file_extension != ".json": print( "Error: invalid file name. \nThe input file has to be a .json file not a %s" % file_extension) exit(1) with open(parameters_file, 'r') as f: config = json.load(f) json_schema_file = 'scripts/schema.json' with open(json_schema_file, 'r') as f: schema = json.load(f) DefaultValidatingDraft4Validator = extend_with_default(Draft4Validator) DefaultValidatingDraft4Validator(schema).validate(config) application_name = config["application_name"] optimization_metrics = config["optimization_objectives"] feasible_output = config["feasible_output"] feasible_output_name = feasible_output["name"] run_directory = config["run_directory"] xlog = config["output_image"]["image_xlog"] ylog = config["output_image"]["image_ylog"] if "optimization_objectives_labels_image_pdf" in config["output_image"]: optimization_objectives_labels_image_pdf = config["output_image"][ "optimization_objectives_labels_image_pdf"] else: optimization_objectives_labels_image_pdf = optimization_metrics # Only consider the files in the json file if there are no input files. if list_of_pairs_of_files == []: output_pareto_file = config["output_pareto_file"] if output_pareto_file == "output_pareto.csv": output_pareto_file = application_name + "_" + output_pareto_file output_data_file = config["output_data_file"] if output_data_file == "output_samples.csv": output_data_file = application_name + "_" + output_data_file list_of_pairs_of_files.append( (deal_with_relative_and_absolute_path(run_directory, output_pareto_file), deal_with_relative_and_absolute_path(run_directory, output_data_file))) if image_output_file != None: output_image_pdf_file = image_output_file filename = os.path.basename(image_output_file) path = os.path.dirname(image_output_file) if path == "": output_image_pdf_file_with_all_samples = "all_" + filename else: output_image_pdf_file_with_all_samples = path + "/" + "all_" + filename else: tmp_file_name = config["output_image"]["output_image_pdf_file"] if tmp_file_name == "output_pareto.pdf": tmp_file_name = application_name + "_" + tmp_file_name output_image_pdf_file = deal_with_relative_and_absolute_path( run_directory, tmp_file_name) if tmp_file_name[0] == "/": filename = os.path.basename(output_image_pdf_file) path = os.path.dirname(output_image_pdf_file) output_image_pdf_file_with_all_samples = path + "/" + "all_" + filename else: output_image_pdf_file_with_all_samples = str(run_directory + "/" + "all_" + tmp_file_name) str_files = "" for e in list_of_pairs_of_files: str_files += str(e[0] + " " + e[1] + " ") print("######### plot_dse.py ##########################") print("### Parameters file is %s" % parameters_file) print("### The Pareto and DSE data files are: %s" % str_files) print("### The first output pdf image is %s" % output_image_pdf_file) print("### The second output pdf image is %s" % output_image_pdf_file_with_all_samples) print("################################################") param_space = space.Space(config) xelem = optimization_metrics[0] yelem = optimization_metrics[1] handler_map_for_legend = {} xlabel = optimization_objectives_labels_image_pdf[0] ylabel = optimization_objectives_labels_image_pdf[1] x_max = float("-inf") x_min = float("inf") y_max = float("-inf") y_min = float("inf") print_legend = True fig = plt.figure() ax1 = plt.subplot(1, 1, 1) if xlog: ax1.set_xscale('log') if ylog: ax1.set_yscale('log') objective_1_max = objective_2_max = 1 objective_1_is_percentage = objective_2_is_percentage = False if "objective_1_max" in config["output_image"]: objective_1_max = config["output_image"]["objective_1_max"] objective_1_is_percentage = True if "objective_2_max" in config["output_image"]: objective_2_max = config["output_image"]["objective_2_max"] objective_2_is_percentage = True input_data_array = {} fast_addressing_of_data_array = {} non_valid_optimization_obj_1 = defaultdict(list) non_valid_optimization_obj_2 = defaultdict(list) for file_pair in list_of_pairs_of_files: # file_pair is tuple containing: (pareto file, DSE file) next_color = get_next_color() ############################################################################# ###### Load data from files and do preprocessing on the data before plotting. ############################################################################# for file in file_pair: print(("Loading data from %s ..." % file)) input_data_array[file], fast_addressing_of_data_array[ file] = param_space.load_data_file(file, debug) if input_data_array[file] == None: print("Error: no data found in input data file: %s. \n" % file_pair[1]) exit(1) if (xelem not in input_data_array[file]) or ( yelem not in input_data_array[file]): print( "Error: the optimization variables have not been found in input data file %s. \n" % file) exit(1) print(("Parameters are " + str(list(input_data_array[file].keys())) + "\n")) input_data_array[file][xelem] = [ float(input_data_array[file][xelem][i]) / objective_1_max for i in range(len(input_data_array[file][xelem])) ] input_data_array[file][yelem] = [ float(input_data_array[file][yelem][i]) / objective_2_max for i in range(len(input_data_array[file][yelem])) ] if objective_1_is_percentage: input_data_array[file][xelem] = [ input_data_array[file][xelem][i] * 100 for i in range(len(input_data_array[file][xelem])) ] if objective_2_is_percentage: input_data_array[file][yelem] = [ input_data_array[file][yelem][i] * 100 for i in range(len(input_data_array[file][yelem])) ] x_max, x_min, y_max, y_min = compute_min_max_samples( input_data_array[file], x_max, x_min, xelem, y_max, y_min, yelem) input_data_array_size = len(input_data_array[file][list( input_data_array[file].keys())[0]]) print("Size of the data file %s is %d" % (file, input_data_array_size)) file_pareto = file_pair[0] # This is the Pareto file file_search = file_pair[1] # This is the DSE file ###################################################################################################### ###### Compute invalid samples to be plot in a different color (and remove them from the data arrays). ###################################################################################################### if show_samples: i = 0 for ind in range(len(input_data_array[file][yelem])): if input_data_array[file][feasible_output_name][i] == False: non_valid_optimization_obj_2[file_search].append( input_data_array[file][yelem][i]) non_valid_optimization_obj_1[file_search].append( input_data_array[file][xelem][i]) for key in list(input_data_array[file].keys()): del input_data_array[file][key][i] else: i += 1 label_is = get_last_dir_and_file_names(file_pareto) all_samples, = plt.plot(input_data_array[file_search][xelem], input_data_array[file_search][yelem], color=next_color, linestyle='None', marker='.', mew=0.5, markersize=3, fillstyle="none", label=label_is) plt.plot(input_data_array[file_pareto][xelem], input_data_array[file_pareto][yelem], linestyle='None', marker='.', mew=0.5, markersize=3, fillstyle="none") handler_map_for_legend[all_samples] = HandlerLine2D(numpoints=1) ################################################################################################################ ##### Create a straight Pareto plot: we need to add one point for each point of the data in paretoX and paretoY. ##### We also need to reorder the points on the x axis first. ################################################################################################################ straight_pareto_x = list() straight_pareto_y = list() if len(input_data_array[file_pareto][xelem]) != 0: data_array_pareto_x, data_array_pareto_y = (list(t) for t in zip( *sorted( zip(input_data_array[file_pareto][xelem], input_data_array[file_pareto][yelem])))) for j in range(len(data_array_pareto_x)): straight_pareto_x.append(data_array_pareto_x[j]) straight_pareto_x.append(data_array_pareto_x[j]) straight_pareto_y.append(data_array_pareto_y[j]) straight_pareto_y.append(data_array_pareto_y[j]) straight_pareto_x.append( x_max) # Just insert the max on the x axis straight_pareto_y.insert( 0, y_max) # Just insert the max on the y axis label_is = "Pareto - " + get_last_dir_and_file_names(file_pareto) pareto_front, = plt.plot(straight_pareto_x, straight_pareto_y, label=label_is, linewidth=1, color=next_color) handler_map_for_legend[pareto_front] = HandlerLine2D(numpoints=1) label_is = "Invalid Samples - " + get_last_dir_and_file_names( file_search) if show_samples: non_valid, = plt.plot(non_valid_optimization_obj_1[file_search], non_valid_optimization_obj_2[file_search], linestyle='None', marker='.', mew=0.5, markersize=3, fillstyle="none", label=label_is) handler_map_for_legend[non_valid] = HandlerLine2D(numpoints=1) plt.ylabel(ylabel, fontsize=16) plt.xlabel(xlabel, fontsize=16) for tick in ax1.xaxis.get_major_ticks(): tick.label.set_fontsize( 14) # Set the fontsize of the label on the ticks of the x axis for tick in ax1.yaxis.get_major_ticks(): tick.label.set_fontsize( 14) # Set the fontsize of the label on the ticks of the y axis # Add the legend with some customizations if print_legend: lgd = ax1.legend(handler_map=handler_map_for_legend, loc='best', bbox_to_anchor=(1, 1), fancybox=True, shadow=True, ncol=1, prop={'size': 14}) # Display legend. font = {'size': 16} matplotlib.rc('font', **font) fig.savefig(output_image_pdf_file_with_all_samples, dpi=120, bbox_inches='tight') if objective_1_is_percentage: plt.xlim(0, 100) if objective_2_is_percentage: plt.ylim(0, 100) fig.savefig(output_image_pdf_file, dpi=120, bbox_inches='tight')
def main(configuration_file, data_dirs, labels=None, minimum=0, outfile=None, title=None, plot_log=False, unlog_y_axis=False, budget=None, out_dir=None, ncol=4, x_label=None, y_label=None, show_doe=True, expert_configuration=None): # Read json configuration file if not configuration_file.endswith('.json'): _, file_extension = splitext(configuration_file) print( "Error: invalid file name. \nThe input file has to be a .json file not a %s" % file_extension) raise SystemExit with open(configuration_file, 'r') as f: config = json.load(f) json_schema_file = 'scripts/schema.json' with open(json_schema_file, 'r') as f: schema = json.load(f) DefaultValidatingDraft4Validator = extend_with_default(Draft4Validator) try: DefaultValidatingDraft4Validator(schema).validate(config) except exceptions.ValidationError as ve: print("Failed to validate json:") print(ve) raise SystemExit param_space = space.Space(config) output_metric = param_space.get_optimization_parameters()[ 0] # only works for mono-objective doe_size = config['design_of_experiment']['number_of_samples'] feasibility_flag = param_space.get_feasible_parameter()[ 0] # returns a list, we just want the name best = 0 if minimum is not None: best = minimum application_name = config["application_name"] if budget is None: budget = float("inf") regrets = {} log_regrets = {} total_iterations = {} max_iters = float("-inf") for data_dir_idx, data_dir in enumerate(data_dirs): dir_regrets = [] dir_log_regrets = [] min_dir_iters = budget for file in listdir(data_dir): if not file.endswith('.csv'): print("Skipping:", file) continue full_file = join(data_dir, file) data_array = load_data(full_file) total_iters = min(len(data_array[output_metric]), budget) min_dir_iters = min(total_iters, min_dir_iters) max_iters = max(max_iters, total_iters) iterations = list(range(total_iters)) simple_regret = [] log_regret = [] incumbent = float("inf") for idx in iterations: if feasibility_flag is not None: if data_array[feasibility_flag][idx] == True: incumbent = min(incumbent, data_array[output_metric][idx]) else: incumbent = min(incumbent, data_array[output_metric][idx]) regret = incumbent - best simple_regret.append(regret) log_regret.append(np.log(regret)) dir_regrets.append(np.array(simple_regret)) dir_log_regrets.append(np.array(log_regret)) for idx in range(len(dir_regrets)): dir_regrets[idx] = dir_regrets[idx][:min_dir_iters] dir_log_regrets[idx] = dir_log_regrets[idx][:min_dir_iters] regrets[data_dir] = np.array(dir_regrets) log_regrets[data_dir] = np.array(dir_log_regrets) total_iterations[data_dir] = list(range(min_dir_iters)) mpl.rcParams.update({'font.size': 40}) plt.rcParams["figure.figsize"] = [16, 12] linewidth = 6 fig, ax = plt.subplots() colors = [ "red", "green", "blue", "magenta", "yellow", "purple", "orange", "cyan" ] legend_elements = [] if expert_configuration is not None: if plot_log: expert_configuration = np.log(expert_configuration) expert_data = [expert_configuration] * max_iters plt.plot(list(range(max_iters)), expert_data, color="black", linewidth=linewidth, linestyle="solid") for key_idx, key in enumerate(regrets.keys()): std = np.std(regrets[key], axis=0, ddof=1) log_std = np.std(log_regrets[key], axis=0, ddof=1) simple_means = np.mean(regrets[key], axis=0) log_means = np.log(simple_means) lower_bound = [] upper_bound = [] plot_means = simple_means plot_stds = std if plot_log: plot_means = log_means plot_stds = log_std for idx in range(plot_stds.shape[0]): lower_bound.append(plot_means[idx] - plot_stds[idx]) upper_bound.append(plot_means[idx] + plot_stds[idx]) next_color = colors[key_idx % len(colors)] plt.plot(total_iterations[key], plot_means, color=next_color, linewidth=linewidth) plt.fill_between(total_iterations[key], lower_bound, upper_bound, color=next_color, alpha=.2) if labels is None: label = key else: label = labels[key_idx] legend_elements.append( Line2D([0], [0], color=next_color, label=label, linewidth=linewidth)) if expert_configuration is not None: legend_elements.append( Line2D([0], [0], color="black", linewidth=linewidth, linestyle="solid", label="Expert Configuration")) if plot_log and unlog_y_axis: locs, plt_labels = plt.yticks() plt_labels = [np.exp(float(item)) for item in locs] plt_labels = ["{0:,.2f}\n".format(item) for item in plt_labels] plt.yticks(locs, plt_labels) if show_doe: legend_elements.append( Line2D([0], [0], color="black", linewidth=linewidth, linestyle="dashed", label="Initialization")) plt.legend(handles=legend_elements, loc='center', bbox_to_anchor=(0.5, 1.08), fancybox=True, shadow=True, ncol=ncol, bbox_transform=plt.gcf().transFigure) if x_label is None: x_label = "Number of Evaluations" if y_label is None: if plot_log: y_label = "Log Regret" else: y_label = "Regret" plt.xlabel(x_label) plt.ylabel(y_label) if title is None: title = config["application_name"] plt.title(title, y=1) plt.xlim(0, ) plt.axvline(x=doe_size, color="black", linewidth=linewidth, linestyle="dashed") if out_dir != "": if not out_dir.endswith("/"): out_dir += "/" os.makedirs(out_dir, exist_ok=True) if outfile is None: outfile = out_dir + application_name + "_regret.pdf" plt.savefig(outfile, bbox_inches='tight', dpi=300) plt.gcf().clear() return legend_elements
def main(config, black_box_function=None, output_file=""): """ Run design-space exploration using random scalarizations. :param config: dictionary containing all the configuration parameters of this design-space exploration. :param output_file: a name for the file used to save the dse results. :return: """ param_space = space.Space(config) run_directory = config["run_directory"] application_name = config["application_name"] hypermapper_mode = config["hypermapper_mode"]["mode"] if hypermapper_mode == "default": if black_box_function == None: print("Error: the black box function must be provided") raise SystemExit if not callable(black_box_function): print("Error: the black box function parameter is not callable") raise SystemExit optimization_metrics = config["optimization_objectives"] number_of_objectives = len(optimization_metrics) number_of_cpus = config["number_of_cpus"] local_search_random_points = config["local_search_random_points"] local_search_evaluation_limit = config["local_search_evaluation_limit"] if local_search_evaluation_limit == -1: local_search_evaluation_limit = float("inf") scalarization_key = config["scalarization_key"] scalarization_method = config["scalarization_method"] scalarization_weights = config["local_search_scalarization_weights"] if len(scalarization_weights) < len(optimization_metrics): print("Error: not enough scalarization weights. Received", len(scalarization_weights), "expected", len(optimization_metrics)) raise SystemExit if sum(scalarization_weights) != 1: sys.stdout.write_to_logfile( "Weights must sum 1. Normalizing weights.\n") for idx in range(len(scalarization_weights)): scalarization_weights[idx] = scalarization_weights[idx] / sum( scalarization_weights) sys.stdout.write_to_logfile("New weights:" + str(scalarization_weights) + "\n") objective_weights = {} objective_limits = {} for idx, objective in enumerate(optimization_metrics): objective_weights[objective] = scalarization_weights[idx] objective_limits[objective] = [float("inf"), float("-inf")] exhaustive_search_data_array = None exhaustive_search_fast_addressing_of_data_array = None if (hypermapper_mode == 'exhaustive'): exhaustive_file = config["hypermapper_mode"]["exhaustive_search_file"] print("Exhaustive mode, loading data from %s ..." % exhaustive_file) exhaustive_search_data_array, exhaustive_search_fast_addressing_of_data_array = param_space.load_data_file( exhaustive_file, debug=False, number_of_cpus=number_of_cpus) enable_feasible_predictor = False if "feasible_output" in config: feasible_output = config["feasible_output"] feasible_output_name = feasible_output["name"] enable_feasible_predictor = feasible_output[ "enable_feasible_predictor"] enable_feasible_predictor_grid_search_on_recall_and_precision = feasible_output[ "enable_feasible_predictor_grid_search_on_recall_and_precision"] feasible_predictor_grid_search_validation_file = feasible_output[ "feasible_predictor_grid_search_validation_file"] feasible_parameter = param_space.get_feasible_parameter() local_search_starting_points = config["local_search_starting_points"] debug = False log_file = deal_with_relative_and_absolute_path(run_directory, config["log_file"]) sys.stdout.change_log_file(log_file) if hypermapper_mode == "client-server": sys.stdout.switch_log_only_on_file(True) if output_file == "": output_data_file = config["output_data_file"] if output_data_file == "output_samples.csv": output_data_file = application_name + "_" + output_data_file else: output_data_file = output_file absolute_configuration_index = 0 fast_addressing_of_data_array = {} local_search_fast_addressing_of_data_array = {} local_search_data_array = defaultdict(list) beginning_of_time = param_space.current_milli_time() optimization_function_parameters = {} optimization_function_parameters['hypermapper_mode'] = hypermapper_mode optimization_function_parameters['param_space'] = param_space optimization_function_parameters['beginning_of_time'] = beginning_of_time optimization_function_parameters['run_directory'] = run_directory optimization_function_parameters[ 'exhaustive_search_data_array'] = exhaustive_search_data_array optimization_function_parameters[ 'exhaustive_search_fast_addressing_of_data_array'] = exhaustive_search_fast_addressing_of_data_array optimization_function_parameters['black_box_function'] = black_box_function optimization_function_parameters['number_of_cpus'] = number_of_cpus optimization_function_parameters[ 'local_search_data_array'] = local_search_data_array optimization_function_parameters[ 'fast_addressing_of_data_array'] = local_search_fast_addressing_of_data_array optimization_function_parameters[ 'evaluation_limit'] = local_search_evaluation_limit optimization_function_parameters[ 'scalarization_weights'] = objective_weights optimization_function_parameters['objective_limits'] = objective_limits optimization_function_parameters[ 'scalarization_method'] = scalarization_method optimization_function_parameters[ 'enable_feasible_predictor'] = enable_feasible_predictor print("Starting local search...") local_search_t0 = datetime.datetime.now() all_samples, best_configuration = local_search( local_search_starting_points, local_search_random_points, param_space, fast_addressing_of_data_array, enable_feasible_predictor, run_objective_function, optimization_function_parameters, scalarization_key) print("Local search finished after %d function evaluations" % (len(local_search_data_array[optimization_metrics[0]]))) sys.stdout.write_to_logfile( ("Local search time %10.4f sec\n" % ((datetime.datetime.now() - local_search_t0).total_seconds()))) with open( deal_with_relative_and_absolute_path(run_directory, output_data_file), 'w') as f: w = csv.writer(f) w.writerow(list(local_search_data_array.keys())) tmp_list = [ param_space.convert_types_to_string(j, local_search_data_array) for j in list(local_search_data_array.keys()) ] tmp_list = list(zip(*tmp_list)) for i in range(len(local_search_data_array[optimization_metrics[0]])): w.writerow(tmp_list[i]) print("### End of the local search.")
import space as _space from space.time import Hour, Day, Cycle space = _space.Space() system = _space.System() space.systems.append(system) star = _space.Star() system.stars.append(star) planet = _space.Planet() star.bodies.append(planet) masterdam = _space.city.City("Masterdam") planet.cities.append(masterdam) import specification as _spec cook = _spec.Profession(_space.city.agent.Population, 'cook') farmer = _spec.Profession(_space.city.agent.Population, 'farmer') worker = _spec.Profession(_space.city.agent.Population, 'worker') engineer = _spec.Profession(_space.city.agent.Population, 'engineer') workers = { cook: 2, farmer: 1, worker: 1, engineer: 1, } for type, amount in workers.iteritems(): masterdam.actors.append(type.create(amount))
import matplotlib.pyplot as plt from scipy import special as sp from constants import eps_0, mu_0, c import space import source import dielectric import measurement # Defining experiment parameters J0 = 1 simulation_time = 4 * 10**(-9) # PEC box parameters x_length, y_length = 0.35, 0.35 # [m] (i.c. approximately 30 wavelengths) # Initializing a space with a PEC bounding box box = space.Space(x_length, y_length, simulation_time) src = source.Gaussian_pulse(1 / 2 * x_length, 1 / 2 * y_length, J0, 4 * 10**(-10), 10**(-10)) box.set_source(src) Delta_p = src.get_lambda_min(1) / 25 Delta_t = 1 / (3 * c * np.sqrt(2 / Delta_p**2)) box.define_discretization(Delta_p, Delta_p, Delta_t) print(Delta_p, Delta_t) # Measurement parameters measurement_points = [(1 / 2 * x_length, 1 / 2 * y_length)] measurement_titles = ["at source"] # Getting measurments box.add_measurement_points(measurement_points, measurement_titles)
i = 0 while True: t = time.time() - t0 if i % (1 * FPS) == 0: space.add_particle(particle.Particle((0, 0), (0, random.random() * 20.0), collides=False)) # if i % 16 == 0: # FLOOR.collides = False # if i % 25 == 0: # FLOOR.collides = True space.update() space.print_state() time.sleep(1.0/FPS) i += 1 if __name__ == "__main__": s = space.Space(9.81) s.add_particle(FLOOR) simulate_debug(s)