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_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_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):
"""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_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_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_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_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_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_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_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_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_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_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_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 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_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_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_9c(world, timestep, reset):
"""Exercise 9c"""
# Parameters
outfile = TemporaryFile()
parameter_set = [
[
SimulationParameters(
simulation_duration=20,
drive=4.5,
amplitude_gradient=[head, tail],
phase_lag=2 * np.pi / 10,
# ...
) for head in np.linspace(0.1, 1.5, 15)
] for tail in np.linspace(0.1, 1.5, 15)
]
# for amplitudes in ...
pylog.warning(np.shape(parameter_set))
head = np.linspace(0.1, 1.5, 15)
tail = np.linspace(0.1, 1.5, 15)
pylog.warning(head)
energy = np.zeros((len(head), len(tail)))
for i in range(0, len(head)):
for j in range(0, len(tail)):
reset.reset()
parameters = parameter_set[i][j]
run_simulation(
world,
parameters,
timestep,
int(1000 * parameters.simulation_duration / timestep),
logs="./logs/simulation9c_more_head{}_tail{}.npz".format(
head[i], tail[j]))
data = np.load("logs/simulation9c_more_head{}_tail{}.npz".format(
head[i], tail[j]))
velocity = np.diff(data["joints"][:, :, 0], axis=0) / timestep
velocity = np.insert(velocity, 0, 0, axis=0)
torque = data["joints"][:, :, 2]
energy[i, j] = np.mean(np.trapz(velocity * torque, dx=timestep))
np.save(outfile, energy)
outfile.seek(0) #for when you want to open it again
plt.imshow(energy, extent=[0.1, 1, 0.1, 1])
plt.xlabel('head factor')
plt.ylabel('tail factor')
plt.title('Energy estimation')
plt.colorbar()
plt.show()
def exercise_9f(world, timestep, reset):
"""Exercise 9f"""
n_joints = 10
#ex9f1
# parameter_set = [
# SimulationParameters(
# simulation_duration=10,
# drive=1,
# amplitudesLimb=0.3,
# phase_lag_body_limb=phase_lag_body_limb,
# )
# for phase_lag_body_limb in np.linspace(0,2*np.pi,30)
# ]
#ex9f2
# parameter_set = [
# SimulationParameters(
# simulation_duration=10,
# drive=1,
#
# amplitudesLimb=amplitude,
# phase_lag_body_limb = 2.816
# )
# for amplitude in np.linspace(0,0.5,30)
# ]
#normal walking
parameter_set = [
SimulationParameters(
simulation_duration=40,
drive=1,
#amplitudesLimb=0.32,
#phase_lag_body_limb = 2.816,
)
#for amplitude in np.linspace(0,0.5,15)
]
# 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_9f_walking/simulation_{}.npz".format(
simulation_i))
def exercise_9d1(world, timestep, reset):
"""Exercise 9d1"""
parameters = SimulationParameters(
simulation_duration=10,
drive=4.5,
amplitude_gradient=[0.2, 1],
phase_lag=2 * np.pi / 10,
turn=[0.2, 'Right'],
# ...
)
run_simulation(world,
parameters,
timestep,
int(1000 * parameters.simulation_duration / timestep),
logs="./logs/simulation9d1.npz")
def exercise_9g(world, timestep, reset):
"""Exercise 9g"""
parameters = SimulationParameters(
simulation_duration=50,
drive=3,
walk=True,
)
reset.reset()
path = "./logs/9g/simulation_{}.npz".format(0)
run_simulation(world,
parameters,
timestep,
int(1000 * parameters.simulation_duration / timestep),
logs=path)
plot_results.plot_9g()
def exercise_9c(world, timestep, reset):
"""Exercise 9c"""
"""
Influence of:
- Rhead
- Rtail
on:
- speed (along the x axis)
- energy (integral of [torque * joint's speed])
-> Use frequency of 1 Hz and total phase lag of 2 pi along the whole body.
-> Run grid search on those parameters. For each run, evaluate:
- maximal energy (absolute value)
-> Display 2D plot of results of the grid search.
"""
# Parameters
n_joints = 10
# Search space definition
num_trials, rhead_set, rtail_set = get_search_space()
# Grid search
simulation_i = -1
for rhead in rhead_set:
for rtail in rtail_set:
simulation_i += 1
parameters = SimulationParameters(
drive=5,
amplitude=[rhead, rtail], # head, tail
phase_lag=0.5, # total phase lag of 2 pi along the body
turn=None,
couplingBody=10,
couplingLeg=30,
rate=20,
#cRBody = [0.025, 0.005],
simulation_duration=sim_time)
reset.reset()
run_simulation(
world,
parameters,
timestep,
int(1000 * parameters.simulation_duration / timestep),
logs="./logs/9c/simulation_{}.npz".format(simulation_i))
# Evaluate the grid search
compute_energy_speed()
def exercise_9b(world, timestep, reset):
"""Exercise 9b"""
"""
Influence of:
- phase lag
- amplitude
on:
- speed (along the x axis)
- energy (integral of [torque * joint's speed])
-> Run grid search on those parameters. For each run, evaluate:
- maximal energy (absolute value)
-> Display 2D plot of results of the grid search.
"""
# Parameters
n_joints = 10
# Search space definition
num_trials, amplitudes, phase_lags = get_search_space()
# Grid search
simulation_i = -1
for amplitude in amplitudes:
for phase_lag in phase_lags:
simulation_i += 1
parameters = SimulationParameters(
drive=5,
amplitude=[amplitude, amplitude], # head, tail
phase_lag=phase_lag,
turn=None,
couplingBody=10,
couplingLeg=30,
rate=20,
cRBody=[0.025, 0.005],
simulation_duration=sim_time)
reset.reset()
run_simulation(
world,
parameters,
timestep,
int(1000 * parameters.simulation_duration / timestep),
logs="./logs/9b/simulation_{}.npz".format(simulation_i))
# Evaluate the grid search
compute_energy_speed()
def exercise_9g(world, timestep, reset):
"""Exercise 9g"""
n_joints = 10
parameter_set = [SimulationParameters(
simulation_duration=40,
drive=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/test/simulation_{}.npz".format(simulation_i))
def exercise_9g(world, timestep, reset):
"""Exercise 9g"""
parameters = SimulationParameters(
simulation_duration=60,
amplitude_gradient = [1,1],
phase_lag=2*np.pi/10,
turn=[1, 'Right'],
# offset = 2*np.pi/10, #optimal phase lag
amp_factor = 1.0,
drive_mlr = 1.5
)
run_simulation(
world,
parameters,
timestep,
int(1000*parameters.simulation_duration/timestep),
logs="logs/simulation9g.npz"
)
def exercise_9d1(world, timestep, reset):
"""Exercise 9d1"""
parameters = SimulationParameters(
simulation_duration=10,
drive = 4,
turn = 0.,
)
reset.reset()
path = "./logs/9d1/simulation_{}.npz".format(0)
run_simulation(
world,
parameters,
timestep,
int(1000*parameters.simulation_duration/timestep),
logs=path
)
plot_results.plot_9d1()