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))
