def run_network(duration, update=False, drive=0): """Run network without Webots and plot results""" # Simulation setup timestep = 5e-3 times = np.arange(0, duration, timestep) n_iterations = len(times) parameter_set = SimulationParameters( simulation_duration=100, drive_mlr=2.5, phase_lag=2 * np.pi / 10, ) network = SalamanderNetwork(timestep, parameter_set) osc_left = np.arange(10) osc_right = np.arange(10, 20) osc_legs = np.arange(20, 24) # Logs phases_log = np.zeros([n_iterations, len(network.state.phases)]) phases_log[0, :] = network.state.phases amplitudes_log = np.zeros([n_iterations, len(network.state.amplitudes)]) amplitudes_log[0, :] = network.state.amplitudes freqs_log = np.zeros([n_iterations, len(network.parameters.freqs)]) freqs_log[0, :] = network.parameters.freqs outputs_log = np.zeros( [n_iterations, len(network.get_motor_position_output())]) outputs_log[0, :] = network.get_motor_position_output() # Run network ODE and log data tic = time.time() for i, _ in enumerate(times[1:]): if update: network.parameters.update( SimulationParameters( drive_mlr=2 # amplitude_gradient=None, # phase_lag=None )) network.step() phases_log[i + 1, :] = network.state.phases amplitudes_log[i + 1, :] = network.state.amplitudes outputs_log[i + 1, :] = network.get_motor_position_output() freqs_log[i + 1, :] = network.parameters.freqs toc = time.time() # Network performance pylog.info("Time to run simulation for {} steps: {} [s]".format( n_iterations, toc - tic)) # Implement plots of network results pylog.warning("Implement plots") #plot_results.main(plot=True) #plt.plot(phases_log) plt.close('all') plt.figure('a') plt.plot(outputs_log) plt.figure('b') plt.plot(amplitudes_log)
def run_network(duration, update=False, drive=0): """Run network without Webots and plot results""" # Simulation setup timestep = 5e-3 times = np.arange(0, duration, timestep) n_iterations = len(times) parameters = SimulationParameters( drive=drive, amplitude_gradient=None, phase_lag=None, turn=1.0, use_drive_saturation=1, shes_got_legs=1, cR_body=[0.05, 0.16], #cR1, cR0 cR_limb=[0.131, 0.131], #cR1, cR0 amplitudes_rate=40, ) network = SalamanderNetwork(timestep, parameters) osc_left = np.arange(10) osc_right = np.arange(10, 20) osc_legs = np.arange(20, 24) # Logs phases_log = np.zeros([n_iterations, len(network.state.phases)]) phases_log[0, :] = network.state.phases amplitudes_log = np.zeros([n_iterations, len(network.state.amplitudes)]) amplitudes_log[0, :] = network.state.amplitudes freqs_log = np.zeros([n_iterations, len(network.parameters.freqs)]) freqs_log[0, :] = network.parameters.freqs outputs_log = np.zeros( [n_iterations, len(network.get_motor_position_output())]) outputs_log[0, :] = network.get_motor_position_output() # Run network ODE and log data tic = time.time() for i, _ in enumerate(times[1:]): if update: network.parameters.update( SimulationParameters( # amplitude_gradient=None, # phase_lag=None )) network.step() phases_log[i + 1, :] = network.state.phases amplitudes_log[i + 1, :] = network.state.amplitudes outputs_log[i + 1, :] = network.get_motor_position_output() freqs_log[i + 1, :] = network.parameters.freqs toc = time.time() # Network performance pylog.info("Time to run simulation for {} steps: {} [s]".format( n_iterations, toc - tic)) # Implement plots of network results pylog.warning("Implement plots") plot_results.main()
def run_network(duration, update=False, drive=0): """Run network without Webots and plot results""" # Simulation setup timestep = 5e-3 times = np.arange(0, duration, timestep) n_iterations = len(times) parameters = SimulationParameters() network = SalamanderNetwork(timestep, parameters) osc_left = np.arange(10) osc_right = np.arange(10, 20) osc_legs = np.arange(20, 24) # Logs phases_log = np.zeros([n_iterations, len(network.state.phases)]) phases_log[0, :] = network.state.phases amplitudes_log = np.zeros([n_iterations, len(network.state.amplitudes)]) amplitudes_log[0, :] = network.state.amplitudes freqs_log = np.zeros([n_iterations, len(network.parameters.freqs)]) freqs_log[0, :] = network.parameters.freqs outputs_log = np.zeros( [n_iterations, len(network.get_motor_position_output())]) outputs_log[0, :] = network.get_motor_position_output() # Run network ODE and log data tic = time.time() for i, _ in enumerate(times[1:]): if update: network.parameters.update( SimulationParameters( # amplitude_gradient=None, # phase_lag=None )) network.step() phases_log[i + 1, :] = network.state.phases amplitudes_log[i + 1, :] = network.state.amplitudes outputs_log[i + 1, :] = network.get_motor_position_output() freqs_log[i + 1, :] = network.parameters.freqs toc = time.time() # Network performance pylog.info("Time to run simulation for {} steps: {} [s]".format( n_iterations, toc - tic)) # Implement plots of network results #pylog.warning("Implement plots") # body joint angles #plot_positions(times, outputs_log[:,:10]) # limb joint angles plot_positions(times, outputs_log[:, 10:])
def exercise_9d2(world, timestep, reset): """Exercise 9d2""" parameter_set = [ SimulationParameters( simulation_duration=10, use_drive_saturation=1, reverse = reverse, turn = turn, shes_got_legs = 1, cR_body = [0.05, 0.16], #cR1, cR0 cR_limb = [0.131, 0.131], #cR1, cR0 drive_left = 3.3, drive_right = 3.3, # ... ) for turn in np.linspace(-.2,.2, 3) for reverse in np.linspace(0,1,2) ] # Grid search for simulation_i, parameters in enumerate(parameter_set): reset.reset() run_simulation( world, parameters, timestep, int(1000 * parameters.simulation_duration / timestep), logs="./logs/9d2/simulation_{}.npz".format(simulation_i) ) plot_results.plot9d2() #TODO: Plot GPS Coordinates #TODO: Plot Spine Angles #TODO: Maybe compare spine angles to swimming forward?
def exercise_example(world, timestep, reset): """Exercise example""" # Parameters n_joints = 10 parameter_set = [ SimulationParameters( simulation_duration=10, #drive=drive, amplitudes=0.8, freqs = 8, turn=0, ) for drive in np.linspace(1, 2, 2) # for ... ] # Grid search for simulation_i, parameters in enumerate(parameter_set): reset.reset() run_simulation( world, parameters, timestep, int(1000*parameters.simulation_duration/timestep), logs="./logs/example/simulation_{}.npz".format(simulation_i) )
def exercise_example(world, timestep, reset): """Exercise example""" # Parameters n_joints = 10 parameter_set = [ SimulationParameters( simulation_duration=10, drive_mlr=drive, amplitude_value=0.5, turn=0 ) for drive in np.linspace(3, 4, 2)] # Grid search for simulation_i, parameters in enumerate(parameter_set): reset.reset() run_simulation( world, parameters, timestep, int(1000*parameters.simulation_duration/timestep), logs="./logs/example/simulation_{}.npz".format(simulation_i) )
def exercise_9c(world, timestep, reset): Rhead = [0.1, 0.2, 0.3] Rtail = [0.1, 0.2, 0.3] parameter_set = [ SimulationParameters( simulation_duration=10, #drive=drive, amplitude_gradient=True, amplitudes=[H, T], freqs=1, phase_bias_vertical=2 * np.pi / 10, turn=0, ) for H in Rhead for T in Rtail ] # Grid search for simulation_i, parameters in enumerate(parameter_set): reset.reset() path = "./logs/9c/simulation_{}.npz".format(simulation_i) run_simulation(world, parameters, timestep, int(1000 * parameters.simulation_duration / timestep), logs=path) plot_results.plot_9c(len(parameter_set))
def exercise_9c(world, timestep, reset): """Exercise 9c""" # Parameters n_joints = 10 parameter_set = [ SimulationParameters( simulation_duration=5, drive=1, nominal_amplitudes=0.0, is_amplitude_gradient=1, rhead=rhead, rtail=rtail, turn=1, # ... ) for rhead in np.linspace(0.0, 0.5, num=5) for rtail in np.linspace(0.0, 0.5, num=5) ] # Grid search for simulation_i, parameters in enumerate(parameter_set): reset.reset() run_simulation( world, parameters, timestep, int(1000 * parameters.simulation_duration / timestep), logs="./logs/9c/random/simulation_{}.npz".format(simulation_i))
def exercise_9c(world, timestep, reset): """Exercise 9c""" # Parameters n_joints = 10 listuple = [] Rtail = np.linspace(0.1, 0.4, 2) Rhead = np.linspace(0.1, 0.4, 4) for i in range(Rtail.size): for j in range(len(Rhead)): listuple.append((Rtail[i], Rhead[j])) nbsimu = Rhead.size * Rtail.size parameter_set = [ SimulationParameters( simulation_duration=1, #drive=drive, amplitude_gradient=-(grad[1] - grad[0]) / 10, amplitude_body_value=grad[1], phase_lag=2 * np.pi / 10) for grad in listuple ] # Grid search for simulation_i, parameters in enumerate(parameter_set): print(simulation_i) reset.reset() run_simulation(world, parameters, timestep, int(1000 * parameters.simulation_duration / timestep), logs="./logs/9c/simulation_{}.npz".format(simulation_i)) plot_results.main(nbsimu, Rtail, Rhead, plot=True)
def exercise_9f2(world, timestep, reset): """Exercise 9f""" ''' II) Influence of: - Body oscillation amplitude on: - walking speed (along the x axis) -> Set nominal radius to best value found previously. -> show plot showing the effect of the amplitude. ''' # Parameters n_joints = 10 _, amplitudes = get_amplitude_search_space() for i,amplitude in enumerate(amplitudes): parameters = SimulationParameters( drive=2.5, amplitude=[amplitude,amplitude], # head, tail phase_lag=2*np.pi/10, # total phase lag of 2 pi along the body turn=None, couplingBody=10, couplingLeg=30, rate=20, simulation_duration=10, limb_spine_phase_lag=0 ) reset.reset() run_simulation( world, parameters, timestep, int(1000*parameters.simulation_duration/timestep), logs="./logs/9f2/simulation_{}.npz".format(i) )
def exercise_9d1(world, timestep, reset): """Exercise 9d1""" n_joints = 10 parameter_set = [ SimulationParameters( simulation_duration=40, drive=4, #amplitudes=0.5, #frequency=1, #RHead = RHead, #RTail = RTail, Backwards = False, #phase_lag=2*np.pi/10, turnRate=[1,1], # ... ) ] # Grid search for simulation_i, parameters in enumerate(parameter_set): reset.reset() run_simulation( world, parameters, timestep, int(1000*parameters.simulation_duration/timestep), logs="./logs/exercise_9d1/simulation_{}.npz".format(simulation_i) )
def exercise_9b(world, timestep, reset): """Exercise 9b""" # Parameters amplitudes = [0.2, 0.5] phase_bias = [np.pi / 2, np.pi / 10, np.pi / 14, np.pi / 20] parameter_set = [ SimulationParameters( simulation_duration=4, #drive=drive, amplitudes=amp, phase_bias_vertical=phase, turn=0, freqs=3, ) for amp in amplitudes for phase in phase_bias ] # Grid search for simulation_i, parameters in enumerate(parameter_set): reset.reset() path = "./logs/9b/simulation_{}.npz".format(simulation_i) run_simulation(world, parameters, timestep, int(1000 * parameters.simulation_duration / timestep), logs=path) plot_results.main("./logs/9b/simulation_{}.npz", len(parameter_set))
def exercise_9b(world, timestep, reset): """Exercise 9b""" # Parameters n_joints = 10 parameter_set = [ SimulationParameters( simulation_duration=15, # nominal_amplitudes=test, drive_right=test, drive_left=test, body_phase_bias=test2, use_drive_saturation=1, turn=0, # ... ) for test in np.linspace(4.0, 5.0, num=6) #As seen in Ijspeer paper fig.1.B. for test2 in np.linspace( 2 * np.pi / 10 - 0.2, 2 * np.pi / 10 + 0.2, num=7) #We know nature is set to 2*pi/length. So we could test from lower than 2*pi/lengh to above of it. #Different proposals with 2*pi/lenght on the center value. ] # Grid search for simulation_i, parameters in enumerate(parameter_set): reset.reset() run_simulation(world, parameters, timestep, int(1000 * parameters.simulation_duration / timestep), logs="./logs/9b/test_{}.npz".format(simulation_i))
def main(): """ Main method """ window = GameWindow(SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_TITLE) simulation_parameters = SimulationParameters( population_count=650, person_size=7, frames_to_result=200, chance_of_infection=0.6, chance_for_immunity=1.0, chance_for_death=0.05, initial_top_speed=250, reporting_interval=10, initial_infected_people=1, initial_immune_people=0, vertical_walls=4, door_size=100, ) # for chance_of_infection in [0.4, 0.7]: # simulation_parameters.chance_of_infection = chance_of_infection window.setup(simulation_parameters) arcade.run() plot_results(window) window.close()
def exercise_9c(world, timestep, reset): """Exercise 9c""" n_joints = 10 parameter_set = [ SimulationParameters( simulation_duration=10, drive=4, amplitudes=0.28, frequency=1, RHead = RHead, RTail = RTail, #Backwards = False, #phase_lag=2*np.pi/10, #turnRate=[1,1], # ... ) for RHead in np.linspace(0,1, 10) for RTail in np.linspace(0,1, 10) ] # Grid search for simulation_i, parameters in enumerate(parameter_set): reset.reset() run_simulation( world, parameters, timestep, int(1000*parameters.simulation_duration/timestep), logs="./logs/exercise_9c/simulation_{}.npz".format(simulation_i) )
def exercise_9g(world, timestep, reset): """Exercise 9g""" # Parameters n_joints = 10 listuple = [] Rtail = np.linspace(0.2, 0.2, 1) Rhead = np.linspace(0.1, 0.2, 1) for i in range(Rtail.size): for j in range(len(Rhead)): listuple.append((Rtail[i], Rhead[j])) nbsimu = Rhead.size * Rtail.size parameter_set = [ SimulationParameters( simulation_duration=30, phase_lag=2 * np.pi / 10, drive_mlr=1.2, turn=0, ) for grad in listuple ] # Grid search for simulation_i, parameters in enumerate(parameter_set): print(simulation_i) reset.reset() run_simulation(world, parameters, timestep, int(1000 * parameters.simulation_duration / timestep), logs="./logs/9g/simulation_{}.npz".format(simulation_i)) plot_results.main(nbsimu, Rtail, Rhead, plot=True)
def exercise_9d1(world, timestep, reset): parameter_set = [ SimulationParameters( simulation_duration=10, use_drive_saturation=1, shes_got_legs=1, cR_body = [0.05, 0.16], #cR1, cR0 cR_limb = [0.131, 0.131], #cR1, cR0 amplitudes_rate = 40, drive_left = 3.3, drive_right = 3.3, turn=turn # ... ) for turn in np.linspace(-.2,.2, 7) ] # Grid search #logs ="" for simulation_i, parameters in enumerate(parameter_set): reset.reset() run_simulation( world, parameters, timestep, int(1000 * parameters.simulation_duration / timestep), logs="./logs/9d1/simulation_{}.npz".format(simulation_i) )
def exercise_9b(world, timestep, reset): """Exercise 9b""" n_joints = 10 parameter_set = [ SimulationParameters( simulation_duration=10, drive=4, amplitude=amplitude, phase_lag=phase_lag, turn=0, flag="9b" # ... ) for phase_lag in np.linspace(math.pi*3/2,4*math.pi,10) for amplitude in np.linspace(0.3,0.5,10) # for amplitudes in ... # for ... ] # Grid search for simulation_i, parameters in enumerate(parameter_set): reset.reset() run_simulation( world, parameters, timestep, int(1000*parameters.simulation_duration/timestep), logs="./logs/9b/simulation_{}.npz".format(simulation_i) )
def exercise_9f(world, timestep, reset): """Exercise 9f""" amplitudes = np.linspace(0, 0.5, 10) parameter_set = [ SimulationParameters( freq_coef_body=np.array([1, .5]), # [C_v1, C_v0] in HZ freq_coef_limb=np.array([1, 0.0]), amp_coef_body=np.array([amp, 0.0]), # [C_R1, C_R0] in radians amp_coef_limb=np.array([0.3, 0.0]), simulation_duration=10, drive=1, walk=True, ) for amp in amplitudes ] for i, parameters in enumerate(parameter_set): reset.reset() path = "./logs/9f/simulation_{}.npz".format(i) run_simulation(world, parameters, timestep, int(1000 * parameters.simulation_duration / timestep), logs=path) plot_results.plot_9f(timestep, len(amplitudes), amplitudes)
def exercise_9d2(world, timestep, reset): """Exercise 9d2""" ''' Modify phase to generate backward swimming. -> plot GPS trajectory to show turning results. -> plot spine angles. ''' # Parameters n_joints = 10 parameters = SimulationParameters( drive=5, amplitude=[0.16, 0.2], # head, tail phase_lag=-2 * np.pi / 10, # total phase lag of 2 pi along the body -> but swim BACKWARD!! turn=None, couplingBody=10, couplingLeg=30, rate=20, simulation_duration=10) reset.reset() run_simulation(world, parameters, timestep, int(1000 * parameters.simulation_duration / timestep), logs="./logs/9d2/simulation.npz")
def exercise_9g(world, timestep, reset): """Exercise 9g""" n_joints = 10 parameter_set = [ SimulationParameters( simulation_duration=25, use_drive_saturation=1, shes_got_legs=1, cR_body=[0.052, 0.157],#0.052 # cR1, cR0 cR_limb=[0.105, 0.105],#0.105 # cR1, cR0 drive_left=2.0, drive_right=2.0, enable_transitions=True, # ... ) # for turn in np.linspace(-.2,.2, 7) ] # Grid search # logs ="" for simulation_i, parameters in enumerate(parameter_set): reset.reset() run_simulation( world, parameters, timestep, int(1000 * parameters.simulation_duration / timestep), logs="./logs/9g/water_to_land_1{}.npz".format(simulation_i) ) # plot_results.plot_turn_trajectory() plot_results.plot_9g()
def exercise_9d1(world, timestep, reset): """Exercise 9d1""" ''' Modulate drive to generate turning. -> plot GPS trajectory to show turning results. -> plot spine angles. ''' # Parameters n_joints = 10 parameters = SimulationParameters( drive=5, amplitude=[0.16, 0.2], # head, tail phase_lag=2 * np.pi / 10, # total phase lag of 2 pi along the body turn=-0.5, # turn left couplingBody=10, couplingLeg=30, rate=20, simulation_duration=10) reset.reset() run_simulation(world, parameters, timestep, int(1000 * parameters.simulation_duration / timestep), logs="./logs/9d1/simulation.npz")
def exercise_9f(world, timestep, reset): """Exercise 9f""" n_joints = 10 parameter_set = [ SimulationParameters( simulation_duration=10, drive=2, turn=0, leg_body=leg_body, flag="9f", amplitude=0.3 # ... ) for leg_body in np.linspace(0,math.pi*2,50) #for amplitude in np.linspace(0,0.6,50) # for ... ] # Grid search for simulation_i, parameters in enumerate(parameter_set): reset.reset() run_simulation( world, parameters, timestep, int(1000*parameters.simulation_duration/timestep), logs="./logs/9f/simulation_{}.npz".format(simulation_i) )
def exercise_9d2(world, timestep, reset): """Exercise 9d2""" n_joints = 10 parameter_set = [ SimulationParameters( simulation_duration=20, drive=4, turn=0, flag="9d2", back=True, # ... ) # for amplitudes in ... # for ... ] # Grid search for simulation_i, parameters in enumerate(parameter_set): reset.reset() run_simulation( world, parameters, timestep, int(1000 * parameters.simulation_duration / timestep), logs="./logs/9d2/simulation_{}.npz".format(simulation_i))
def exercise_9b(world, timestep, reset): """Exercise example""" # Parameters n_joints = 10 listamplitude=np.linspace(0.05,0.4, 4) listphaselag=np.linspace(0., 0.9, 6) listuple=[] for i in range(len(listamplitude)): for j in range(len(listphaselag)): listuple.append((listamplitude[i], listphaselag[j])) nbsimu=len(listamplitude)* len(listphaselag) parameter_set = [SimulationParameters( simulation_duration=15, amplitude_body_value=amp, phase_lag=phasel, drive_mlr=None) for amp, phasel in listuple] # Grid search for simulation_i, parameters in enumerate(parameter_set): print(simulation_i) reset.reset() run_simulation( world, parameters, timestep, int(1000*parameters.simulation_duration/timestep), logs="./logs/9b/simulation_{}.npz".format(simulation_i) ) plot_results.main(nbsimu,listamplitude, listphaselag, plot=True)
def exercise_8f_offet(timestep): """search phase offset """ phase_range=np.linspace(0, np.pi, 10) parameter_set = [ SimulationParameters( duration=10, # Simulation duration in [s] timestep=timestep, # Simulation timestep in [s] spawn_position=[0, 0, 0.1], # Robot position in [m] spawn_orientation=[0, 0, 0], # Orientation in Euler angles [rad] drive=2., # An example of parameter part of the grid search amplitudes=[0.3, 0.3], turn=0, pattern='walk', phase_lag=0.2*np.pi, absolute_amplitude=False, phase_body_limb=temp_phase , ) for temp_phase in phase_range ] filename = './logs_8f/phase{}.{}' for i in range(len(phase_range)): temp_phase=phase_range[i] temp_param=parameter_set[i] sim, data = simulation ( sim_parameters=temp_param, arena='ground', fast=True ) data.to_file(filename.format(temp_phase,'h5')) velocities=[] for i in range(len(phase_range)): temp_phase=phase_range[i] data=AnimatData.from_file(filename.format(temp_phase, 'h5')) links_positions = data.sensors.gps.urdf_positions() head_positions = links_positions[:, 0, :] final_head_dist=np.linalg.norm(head_positions[-1]) times = data.times total_time = times[-1] - times[0] temp_velocity = final_head_dist/total_time velocities.append(temp_velocity) fig = plt.figure() plt.plot(phase_range, velocities) plt.legend() plt.xlabel("phase") plt.ylabel("velocity") plt.title("Relationship of Phase Offset and Walking Speed") plt.grid(True)
def exercise_example(timestep): """Exercise example""" # Parameters parameter_set = [ SimulationParameters( duration=10, # Simulation duration in [s] timestep=timestep, # Simulation timestep in [s] spawn_position=[0, 0, 0.1], # Robot position in [m] spawn_orientation=[0, 0, 0], # Orientation in Euler angles [rad] drive=3, # An example of parameter part of the grid search amplitude_gradient=None, #amplitudes=[1, 2, 3], # Just an example phase_lag=2 * np.pi / 10, # or np.zeros(n_joints) for example # Another example frequency=1, # ... ) for drive in np.linspace(1, 2, 2) # for amplitudes in ... # for ... ] # Grid search for simulation_i, sim_parameters in enumerate(parameter_set): filename = './logs/example/simulation_{}.{}' sim, data = simulation( sim_parameters=sim_parameters, # Simulation parameters, see above arena='water', # Can also be 'ground' or 'amphibious' # fast=True, # For fast mode (not real-time) # headless=True, # For headless mode (No GUI, could be faster) # record=True, # Record video, see below for saving # video_distance=1.5, # Set distance of camera to robot # video_yaw=0, # Set camera yaw for recording # video_pitch=-45, # Set camera pitch for recording ) # Log robot data data.to_file(filename.format(simulation_i, 'h5'), sim.iteration) # Log simulation parameters with open(filename.format(simulation_i, 'pickle'), 'wb') as param_file: pickle.dump(sim_parameters, param_file) # Save video if sim.options.record: if 'ffmpeg' in manimation.writers.avail: sim.interface.video.save( filename='salamandra_robotica_simulation.mp4', iteration=sim.iteration, writer='ffmpeg', ) elif 'html' in manimation.writers.avail: # FFmpeg might not be installed, use html instead sim.interface.video.save( filename='salamandra_robotica_simulation.html', iteration=sim.iteration, writer='html', ) else: pylog.error('No known writers, maybe you can use: {}'.format( manimation.writers.avail))
def exercise_8f(timestep, phase_lag_vector, experience): """Exercise 8f""" # Parameters parameter_set = [ SimulationParameters( duration=10, # Simulation duration in [s] timestep=timestep, # Simulation timestep in [s] spawn_position=[0, 0, 0.1], # Robot position in [m] spawn_orientation=[0, 0, 0], # Orientation in Euler angles [rad] drive_mlr=2, # drive so the robot can walk amplitude_limb=0.5, phase_lag=phase_lag, phase_limb_body=np.pi / 2, exercise_8f=True # ... ) for phase_lag in phase_lag_vector ] # Grid search for simulation_i, sim_parameters in enumerate(parameter_set): filename = './logs/{}/simulation_{}.{}' sim, data = simulation( sim_parameters=sim_parameters, # Simulation parameters, see above arena='ground', # Can also be 'ground' or 'amphibious' #fast=True, # For fast mode (not real-time) #headless=True, # For headless mode (No GUI, could be faster) # record=True, # Record video, see below for saving # video_distance=1.5, # Set distance of camera to robot # video_yaw=0, # Set camera yaw for recording # video_pitch=-45, # Set camera pitch for recording ) # Log robot data data.to_file(filename.format(experience, simulation_i, 'h5'), sim.iteration) # Log simulation parameters with open(filename.format(experience, simulation_i, 'pickle'), 'wb') as param_file: pickle.dump(sim_parameters, param_file) # Save video if sim.options.record: if 'ffmpeg' in manimation.writers.avail: sim.interface.video.save( filename='salamandra_robotica_simulation.mp4', iteration=sim.iteration, writer='ffmpeg', ) elif 'html' in manimation.writers.avail: # FFmpeg might not be installed, use html instead sim.interface.video.save( filename='salamandra_robotica_simulation.html', iteration=sim.iteration, writer='html', ) else: pylog.error('No known writers, maybe you can use: {}'.format( manimation.writers.avail))
def exercise_8d2(timestep): """Exercise 8d2""" parameter_set = SimulationParameters( duration=10, # Simulation duration in [s] timestep=timestep, # Simulation timestep in [s] spawn_position=[0, 0, 0.1], # Robot position in [m] spawn_orientation=[0, 0, 0], # Orientation in Euler angles [rad] drive=3., # An example of parameter part of the grid search amplitudes=[0.3, 0.3], turn=0, pattern='swim', phase_lag=-0.2 * np.pi, #amplitude=1., # ... ) filename = './logs_8d/simulation_back.{}' sim, data = simulation( sim_parameters=parameter_set, # Simulation parameters, see above arena='water', # Can also be 'ground' or 'amphibious' fast=True, # For fast mode (not real-time) #record=True, ) data.to_file(filename.format('h5')) ''' sim.interface.video.save( filename='8d_backward.mp4', iteration=sim.iteration, writer='ffmpeg', ) ''' data = AnimatData.from_file(filename.format('h5')) links_positions = data.sensors.gps.urdf_positions() head_positions = links_positions[:, 0, :] osc_phases = data.state.phases_all() osc_amplitudes = data.state.amplitudes_all() times = data.times plt.figure() plot_results.plot_trajectory( head_positions, title='Head Trajectory of Salmandar Swimming Backward') plt.figure() labels = ['Spine Joint ' + str(i + 1) for i in range(10)] links_positions = data.sensors.gps.urdf_positions() plot_results.plot_spine_angles( osc_phases, osc_amplitudes, times, labels=labels, title='Spine Angles of Salmandar Swimming Backward')
def exercise_8d1(timestep): """Exercise 8d1""" # Use exercise_example.py for reference parameter_set = [ SimulationParameters( duration=10, timestep=timestep, spawn_position=[0, 0, 0.1], # Robot position in [m] spawn_orientation=[0, 0, 0], # Orientation in Euler angles [rad] amplitude_gradient=True, drive=4, amplitudes=[0.2, 1], phase_lag=2 * np.pi / 10, frequency=1, turn=[0.5, 'Right'], ) ] # Grid search for simulation_i, sim_parameters in enumerate(parameter_set): filename = './logs/exercise_8d1/simulation_{}.{}' sim, data = simulation( sim_parameters=sim_parameters, # Simulation parameters, see above arena='water', # Can also be 'ground' or 'amphibious' # fast=True, # For fast mode (not real-time) # headless=True, # For headless mode (No GUI, could be faster) # record=True, # Record video, see below for saving # video_distance=1.5, # Set distance of camera to robot # video_yaw=0, # Set camera yaw for recording # video_pitch=-45, # Set camera pitch for recording ) # Log robot data data.to_file(filename.format(simulation_i, 'h5'), sim.iteration) # Log simulation parameters with open(filename.format(simulation_i, 'pickle'), 'wb') as param_file: pickle.dump(sim_parameters, param_file) # Save video if sim.options.record: if 'ffmpeg' in manimation.writers.avail: sim.interface.video.save( filename='salamandra_robotica_simulation.mp4', iteration=sim.iteration, writer='ffmpeg', ) elif 'html' in manimation.writers.avail: # FFmpeg might not be installed, use html instead sim.interface.video.save( filename='salamandra_robotica_simulation.html', iteration=sim.iteration, writer='html', ) else: pylog.error('No known writers, maybe you can use: {}'.format( manimation.writers.avail))