Upload 17 files

FirstSubmission/PaperRAL_ScriptAndVideo/evaluate_com.py

@@ -0,0 +1,287 @@
+import numpy as np
+import matplotlib.pyplot as plt
+
+def compute_max_mean_error(error, time, data):
+    mean_error_init = np.mean(error[time < data["start_contact_sec"][0]], axis=0)
+    mean_error_ukf_nocomp = np.mean(error[time < data["start_contact_sec"][1]], axis=0)
+    max_error_init = np.max(error[time < data["start_contact_sec"][0]], axis=0)
+    max_error_ukf_nocomp = np.max(error[time < data["start_contact_sec"][1]], axis=0)
+    for i in range(1, len(data["start_contact_sec"])):
+        temp_mean = np.mean(error[(time > data["end_contact_sec"][i-1]) & (time < data["start_contact_sec"][i])], axis=0)
+        mean_error = np.mean([mean_error_ukf_nocomp, temp_mean], axis=0)
+        max_error = np.max([max_error_ukf_nocomp, np.max(error[(time > data["end_contact_sec"][i-1]) & (time < data["start_contact_sec"][i])], axis=0)], axis=0)
+
+    return [max_error_init, max_error, mean_error_init, mean_error]
+
+def extract_data(data):
+    data_des = data["balancing"]["com"]["position"]["desired"]["data"]
+    data_meas = data["balancing"]["com"]["position"]["measured"]["data"]
+    data_time = data["balancing"]["com"]["position"]["desired"]["timestamps"]
+    data_time = data_time - data_time[0]
+    error = np.abs(data_des - data_meas)
+    error = error[data_time < data["end_experiment_sec"]]
+    data_time = data_time[data_time < data["end_experiment_sec"]]
+    return [data_des, data_meas, data_time, error]
+
+def evaluate_com(ukf_pinn, ukf_nocomp, feedforward, feedforward_pinn, RNEA_nocomp, RNEA_pinn):
+
+    [ukf_pinn_des, ukf_pinn_meas, ukf_pinn_time, error_ukf_pinn] = extract_data(ukf_pinn)
+    [ukf_nocomp_des, ukf_nocomp_meas, ukf_nocomp_time, error_ukf_nocomp] = extract_data(ukf_nocomp)
+    [feedforward_des, feedforward_meas, feedforward_time, error_feedforward] = extract_data(feedforward)
+    [feedforward_pinn_des, feedforward_pinn_meas, feedforward_pinn_time, error_feedforward_pinn] = extract_data(feedforward_pinn)
+    [RNEA_nocomp_des, RNEA_nocomp_meas, RNEA_nocomp_time, error_RNEA_nocomp] = extract_data(RNEA_nocomp)
+    [RNEA_pinn_des, RNEA_pinn_meas, RNEA_pinn_time, error_RNEA_pinn] = extract_data(RNEA_pinn)
+
+    # Calculate the mean error per the intervals contacts and no contacts
+    # and considering only samples from the initial timestamp to the end_experiment_sec
+    # Compute the RMSE for each componenet x, y, z
+    # considering only the samples of the no contacts intervals
+    [max_error_ukf_pinn_init, max_error_ukf_pinn, mean_error_ukf_pinn_init, mean_error_ukf_pinn] = compute_max_mean_error(error_ukf_pinn, ukf_pinn_time, ukf_pinn)
+
+    [max_error_ukf_nocomp_init, max_error_ukf_nocomp, mean_error_ukf_nocomp_init, mean_error_ukf_nocomp] = compute_max_mean_error(error_ukf_nocomp, ukf_nocomp_time, ukf_nocomp)
+
+    [max_error_feedforward_init, max_error_feedforward, mean_error_feedforward_init, mean_error_feedforward] = compute_max_mean_error(error_feedforward, feedforward_time, feedforward)
+
+    [max_error_feedforward_pinn_init, max_error_feedforward_pinn, mean_error_feedforward_pinn_init, mean_error_feedforward_pinn] = compute_max_mean_error(error_feedforward_pinn, feedforward_pinn_time, feedforward_pinn)
+
+    [max_error_RNEA_nocomp_init, max_error_RNEA_nocomp, mean_error_RNEA_nocomp_init, mean_error_RNEA_nocomp] = compute_max_mean_error(error_RNEA_nocomp, RNEA_nocomp_time, RNEA_nocomp)
+
+    [max_error_RNEA_pinn_init, max_error_RNEA_pinn, mean_error_RNEA_pinn_init, mean_error_RNEA_pinn] = compute_max_mean_error(error_RNEA_pinn, RNEA_pinn_time, RNEA_pinn)
+
+    # Print the mean and max error before first contact
+    print(">>>>>>>>>>>>> Mean error before contact")
+    print(f"Mean error UKF Pinn before contact: {mean_error_ukf_pinn_init}")
+    print(f"Mean error UKF No Compensation before contact: {mean_error_ukf_nocomp_init}")
+    print(f"Mean error Feedforward before contact: {mean_error_feedforward_init}")
+    print(f"Mean error Feedforward Pinn before contact: {mean_error_feedforward_pinn_init}")
+    print(f"Mean error RNEA No Compensation before contact: {mean_error_RNEA_nocomp_init}")
+    print(f"Mean error RNEA Pinn before contact: {mean_error_RNEA_pinn_init}")
+
+    # Print the best case among all the controllers
+    # Find the best case among all the controllers
+    min_norm_error = np.min([np.linalg.norm(mean_error_ukf_pinn_init), np.linalg.norm(mean_error_ukf_nocomp_init), np.linalg.norm(mean_error_feedforward_init), np.linalg.norm(mean_error_feedforward_pinn_init), np.linalg.norm(mean_error_RNEA_nocomp_init), np.linalg.norm(mean_error_RNEA_pinn_init)])
+    # Which gave the best norm error?
+    # if np.linalg.norm(mean_error_ukf_pinn_init) == min_norm_error:
+    #     print(">>>>>>>>>>>>> Best case before contact: UKF PINN")
+    # elif np.linalg.norm(mean_error_ukf_nocomp_init) == min_norm_error:
+    #     print(">>>>>>>>>>>>> Best case before contact: UKF No Compensation")
+    # elif np.linalg.norm(mean_error_feedforward_init) == min_norm_error:
+    #     print(">>>>>>>>>>>>> Best case before contact: Feedforward")
+    # elif np.linalg.norm(mean_error_feedforward_pinn_init) == min_norm_error:
+    #     print(">>>>>>>>>>>>> Best case before contact: Feedforward PINN")
+    # elif np.linalg.norm(mean_error_RNEA_nocomp_init) == min_norm_error:
+    #     print(">>>>>>>>>>>>> Best case before contact: RNEA No Compensation")
+    # elif np.linalg.norm(mean_error_RNEA_pinn_init) == min_norm_error:
+    #     print(">>>>>>>>>>>>> Best case before contact: RNEA PINN")
+
+
+    print(">>>>>>>>>>>>> Max error before contact")
+    print(f"Max error UKF Pinn before contact: {max_error_ukf_pinn_init}")
+    print(f"Max error UKF No Compensation before contact: {max_error_ukf_nocomp_init}")
+    print(f"Max error Feedforward before contact: {max_error_feedforward_init}")
+    print(f"Max error Feedforward Pinn before contact: {max_error_feedforward_pinn_init}")
+    print(f"Max error RNEA No Compensation before contact: {max_error_RNEA_nocomp_init}")
+    print(f"Max error RNEA Pinn before contact: {max_error_RNEA_pinn_init}")
+
+    # Print the best case among all the controllers
+    # Find the best case among all the controllers
+    min_norm_error = np.min([np.linalg.norm(mean_error_ukf_pinn_init), np.linalg.norm(mean_error_ukf_nocomp_init), np.linalg.norm(mean_error_feedforward_init), np.linalg.norm(mean_error_feedforward_pinn_init), np.linalg.norm(mean_error_RNEA_nocomp_init), np.linalg.norm(mean_error_RNEA_pinn_init)])
+    # Which gave the best norm error?
+    # if np.linalg.norm(mean_error_ukf_pinn_init) == min_norm_error:
+    #     print(">>>>>>>>>>>>> Best case before contact: UKF PINN")
+    # elif np.linalg.norm(mean_error_ukf_nocomp_init) == min_norm_error:
+    #     print(">>>>>>>>>>>>> Best case before contact: UKF No Compensation")
+    # elif np.linalg.norm(mean_error_feedforward_init) == min_norm_error:
+    #     print(">>>>>>>>>>>>> Best case before contact: Feedforward")
+    # elif np.linalg.norm(mean_error_feedforward_pinn_init) == min_norm_error:
+    #     print(">>>>>>>>>>>>> Best case before contact: Feedforward PINN")
+    # elif np.linalg.norm(mean_error_RNEA_nocomp_init) == min_norm_error:
+    #     print(">>>>>>>>>>>>> Best case before contact: RNEA No Compensation")
+    # elif np.linalg.norm(mean_error_RNEA_pinn_init) == min_norm_error:
+    #     print(">>>>>>>>>>>>> Best case before contact: RNEA PINN")
+
+    # Print the mean error per each component x, y, z and each dataset, after the first contact
+    print(">>>>>>>>>>>>> Mean error after contact")
+    print(f"Mean error UKF Pinn after contacts: {mean_error_ukf_pinn}")
+    print(f"Mean error UKF No Compensation after contacts: {mean_error_ukf_nocomp}")
+    print(f"Mean error Feedforward after contacts: {mean_error_feedforward}")
+    print(f"Mean error Feedforward Pinn after contacts: {mean_error_feedforward_pinn}")
+    print(f"Mean error RNEA No Compensation after contacts: {mean_error_RNEA_nocomp}")
+    print(f"Mean error RNEA Pinn after contacts: {mean_error_RNEA_pinn}")
+
+    # Print the best case among all the controllers
+    # Find the best case among all the controllers
+    min_norm_error = np.min([np.linalg.norm(mean_error_ukf_pinn), np.linalg.norm(mean_error_ukf_nocomp), np.linalg.norm(mean_error_feedforward), np.linalg.norm(mean_error_feedforward_pinn), np.linalg.norm(mean_error_RNEA_nocomp), np.linalg.norm(mean_error_RNEA_pinn)])
+    # Which gave the best norm error?
+    # if np.linalg.norm(mean_error_ukf_pinn) == min_norm_error:
+    #     print(">>>>>>>>>>>>> Best case after contacts: UKF PINN")
+    # elif np.linalg.norm(mean_error_ukf_nocomp) == min_norm_error:
+    #     print(">>>>>>>>>>>>> Best case after contacts: UKF No Compensation")
+    # elif np.linalg.norm(mean_error_feedforward) == min_norm_error:
+    #     print(">>>>>>>>>>>>> Best case after contacts: Feedforward")
+    # elif np.linalg.norm(mean_error_feedforward_pinn) == min_norm_error:
+    #     print(">>>>>>>>>>>>> Best case after contacts: Feedforward PINN")
+    # elif np.linalg.norm(mean_error_RNEA_nocomp) == min_norm_error:
+    #     print(">>>>>>>>>>>>> Best case after contacts: RNEA No Compensation")
+    # elif np.linalg.norm(mean_error_RNEA_pinn) == min_norm_error:
+    #     print(">>>>>>>>>>>>> Best case after contacts: RNEA PINN")
+
+    print(">>>>>>>>>>>>> Max error after contact")
+    print(f"Max error UKF Pinn after contacts: {max_error_ukf_pinn}")
+    print(f"Max error UKF No Compensation after contacts: {max_error_ukf_nocomp}")
+    print(f"Max error Feedforward after contacts: {max_error_feedforward}")
+    print(f"Max error Feedforward Pinn after contacts: {max_error_feedforward_pinn}")
+    print(f"Max error RNEA No Compensation after contacts: {max_error_RNEA_nocomp}")
+    print(f"Max error RNEA Pinn after contacts: {max_error_RNEA_pinn}")
+
+    # Print the best case among all the controllers
+    # Find the best case among all the controllers
+    min_norm_error = np.min([np.linalg.norm(mean_error_ukf_pinn), np.linalg.norm(mean_error_ukf_nocomp), np.linalg.norm(mean_error_feedforward), np.linalg.norm(mean_error_feedforward_pinn), np.linalg.norm(mean_error_RNEA_nocomp), np.linalg.norm(mean_error_RNEA_pinn)])
+    # Which gave the best norm error?
+    # if np.linalg.norm(mean_error_ukf_pinn) == min_norm_error:
+    #     print(">>>>>>>>>>>>> Best case after contacts: UKF PINN")
+    # elif np.linalg.norm(mean_error_ukf_nocomp) == min_norm_error:
+    #     print(">>>>>>>>>>>>> Best case after contacts: UKF No Compensation")
+    # elif np.linalg.norm(mean_error_feedforward) == min_norm_error:
+    #     print(">>>>>>>>>>>>> Best case after contacts: Feedforward")
+    # elif np.linalg.norm(mean_error_feedforward_pinn) == min_norm_error:
+    #     print(">>>>>>>>>>>>> Best case after contacts: Feedforward PINN")
+    # elif np.linalg.norm(mean_error_RNEA_nocomp) == min_norm_error:
+    #     print(">>>>>>>>>>>>> Best case after contacts: RNEA No Compensation")
+    # elif np.linalg.norm(mean_error_RNEA_pinn) == min_norm_error:
+    #     print(">>>>>>>>>>>>> Best case after contacts: RNEA PINN")
+
+
+    # Compute the avarage delay of the tracking considering the desired and the measured CoM position
+    # knowing that data are logged at 100 Hz
+    # delay_ukf_pinn = np.mean(np.abs(np.diff(np.where(error_ukf_pinn > 0.01)[0])))
+    # print(f"UKF_PINN Average delay: {delay_ukf_pinn/100} seconds")
+
+    # delay_ukf_nocomp = np.mean(np.abs(np.diff(np.where(error_ukf_nocomp > 0.01)[0])))
+    # print(f"UKF_NoComp Average delay: {delay_ukf_nocomp/100} seconds")
+
+    # delay_feedforward = np.mean(np.abs(np.diff(np.where(error_feedforward > 0.01)[0])))
+    # print(f"Feedforward Average delay: {delay_feedforward/100} seconds")
+
+    # delay_feedforward_pinn = np.mean(np.abs(np.diff(np.where(error_feedforward_pinn > 0.01)[0])))
+    # print(f"Feedforward_PINN Average delay: {delay_feedforward_pinn/100} seconds")
+
+    # # Plot the error and the tracking in two different plots, draw three subplots for x, y, z with a for loop
+    # fig, axs = plt.subplots(3, 1, figsize=(10, 10))
+    # for i, ax in enumerate(axs):
+    #     ax.plot(ukf_pinn_des[:, i], label="Desired")
+    #     ax.plot(ukf_pinn_meas[:, i], label="Measured ukf_pinn")
+    #     ax.plot(ukf_nocomp_meas[:, i], label="Measured ukf_nocomp")
+    #     ax.plot(feedforward_meas[:, i], label="Measured feedforward")
+    #     ax.plot(feedforward_pinn_meas[:, i], label="Measured feedforward_pinn")
+    #     ax.set_title(f"CoM position {['x', 'y', 'z'][i]}")
+    #     ax.legend()
+
+    # # Same for the error
+    # fig, axs = plt.subplots(3, 1, figsize=(10, 10))
+    # for i, ax in enumerate(axs):
+    #     ax.plot(error_ukf_pinn[:, i], label="Error ukf_pinn")
+    #     ax.plot(error_ukf_nocomp[:, i], label="Error ukf_nocomp")
+    #     ax.plot(error_feedforward[:, i], label="Error feedforward")
+    #     ax.plot(error_feedforward_pinn[:, i], label="Error feedforward_pinn")
+    #     ax.set_title(f"Error {['x', 'y', 'z'][i]}")
+    # plt.show()
+
+    # Now find the max of each of the 4 desired trajectories and align the 4 trajectories
+    # on the max values of the desired trajectories to compare the tracking
+
+    # # Find the max of each desired trajectory
+    # max_ukf_pinn = np.max(ukf_pinn_des[:, 1])
+    # max_ukf_nocomp = np.max(ukf_nocomp_des[:, 1])
+    # max_feedforward = np.max(feedforward_des[:, 1])
+    # max_feedforward_pinn = np.max(feedforward_pinn_des[:, 1])
+
+    # # Find the index of the max value
+    # idx_ukf_pinn = np.where(ukf_pinn_des[:, 1] == max_ukf_pinn)[0][0]
+    # idx_ukf_nocomp = np.where(ukf_nocomp_des[:, 1] == max_ukf_nocomp)[0][0]
+    # idx_feedforward = np.where(feedforward_des[:, 1] == max_feedforward)[0][0]
+    # idx_feedforward_pinn = np.where(feedforward_pinn_des[:, 1] == max_feedforward_pinn)[0][0]
+
+    # # Align the trajectories
+    # ukf_pinn_des = ukf_pinn_des[idx_ukf_pinn:]
+    # ukf_pinn_meas = ukf_pinn_meas[idx_ukf_pinn:]
+    # ukf_nocomp_des = ukf_nocomp_des[idx_ukf_nocomp:]
+    # ukf_nocomp_meas = ukf_nocomp_meas[idx_ukf_nocomp:]
+    # feedforward_des = feedforward_des[idx_feedforward:]
+    # feedforward_meas = feedforward_meas[idx_feedforward:]
+    # feedforward_pinn_des = feedforward_pinn_des[idx_feedforward_pinn:]
+    # feedforward_pinn_meas = feedforward_pinn_meas[idx_feedforward_pinn:]
+
+    # # Align also the errors
+    # error_ukf_pinn = error_ukf_pinn[idx_ukf_pinn:]
+    # error_ukf_nocomp = error_ukf_nocomp[idx_ukf_nocomp:]
+    # error_feedforward = error_feedforward[idx_feedforward:]
+    # error_feedforward_pinn = error_feedforward_pinn[idx_feedforward_pinn:]
+
+    # Plot the error and the tracking in two different plots, draw three subplots for x, y, z with a for loop
+    # Plot time on x axis knowing that samples are logged at 100 Hz
+    # Add labels x and y axis, title, and legend
+    end_index = 9000
+    start_index = 300
+    time = np.arange(start_index/100, end_index/100, 1/100)
+    fig, axs = plt.subplots(3, 1, figsize=(10, 10))
+    for i, ax in enumerate(axs):
+        ax.plot(time, ukf_pinn_des[start_index:end_index, i], label="Desired")
+        # ax.plot(time, RNEA_pinn_des[start_index:end_index, i], label="Des2")
+        ax.plot(time, feedforward_meas[start_index:end_index, i], label="Feedforward")
+        ax.plot(time, RNEA_pinn_meas[start_index:end_index, i], label="RNEA-PINN")
+        ax.plot(time, ukf_pinn_meas[start_index:end_index, i], label="UKF-PINN")
+        # ax.set_title(f"CoM position {['x', 'y', 'z'][i]}")
+        ax.set_ylabel(f"CoM position {['x', 'y', 'z'][i]}" + " [m]")
+        ax.legend()
+    ax.set_xlabel("Time [s]")
+    # Set suptitle
+    fig.suptitle("CoM position tracking comparison")
+
+    # Plot four subplots for the tracking of the com position for the cases of the four controllers
+    fig, axs = plt.subplots(2, 2, figsize=(10, 10))
+    # First plot is for feedforward_des and feedforward_meas
+    axs[0, 0].plot(time, feedforward_des[start_index:end_index, 1]*1000, label="Desired")
+    axs[0, 0].plot(time, feedforward_meas[start_index:end_index, 1]*1000, label="Measured")
+    axs[0, 0].set_title("Feedforward")
+    axs[0, 0].set_xlabel("Time [s]")
+    axs[0, 0].set_ylabel("CoM y [mm]")
+    axs[0, 0].legend()
+    # Second plot is for feedforward_pinn_des and feedforward_pinn_meas
+    axs[0, 1].plot(time, feedforward_pinn_des[start_index:end_index, 1]*1000, label="Desired")
+    axs[0, 1].plot(time, feedforward_pinn_meas[start_index:end_index, 1]*1000, label="Measured")
+    axs[0, 1].set_title("Feedforward PINN")
+    axs[0, 1].set_xlabel("Time [s]")
+    axs[0, 1].set_ylabel("CoM y [mm]")
+    axs[0, 1].legend()
+    # Third plot is for RNEA_pinn_des and RNEA_pinn_meas
+    axs[1, 0].plot(time, RNEA_pinn_des[start_index:end_index, 1]*1000, label="Desired")
+    axs[1, 0].plot(time, RNEA_pinn_meas[start_index:end_index, 1]*1000, label="Measured")
+    axs[1, 0].set_title("RNEA PINN")
+    axs[1, 0].set_xlabel("Time [s]")
+    axs[1, 0].set_ylabel("CoM y [mm]")
+    axs[1, 0].legend()
+    # Fourth plot is for ukf_pinn_des and ukf_pinn_meas
+    axs[1, 1].plot(time, ukf_pinn_des[start_index:end_index, 1]*1000, label="Desired")
+    axs[1, 1].plot(time, ukf_pinn_meas[start_index:end_index, 1]*1000, label="Measured")
+    axs[1, 1].set_title("UKF PINN")
+    axs[1, 1].set_xlabel("Time [s]")
+    axs[1, 1].set_ylabel("CoM y [mm]")
+    axs[1, 1].legend()
+    plt.show()
+
+
+    # # Same for the error
+    fig, axs = plt.subplots(3, 1, figsize=(10, 10))
+    for i, ax in enumerate(axs):
+        # ax.plot(time, error_feedforward[start_index:end_index, i], label="Feedforward")
+        ax.plot(time, error_RNEA_pinn[start_index:end_index, i], label="RNEA PINN")
+        ax.plot(time, error_ukf_pinn[start_index:end_index, i], label="UKF PINN")
+        ax.set_ylabel(f"Error {['x', 'y', 'z'][i]}" + " [m]")
+        ax.legend()
+    ax.set_xlabel("Time [s]")
+    # Set suptitle
+    fig.suptitle("CoM position tracking error comparison")
+
+    plt.show()
+

FirstSubmission/PaperRAL_ScriptAndVideo/evaluate_joint_torques.py

@@ -0,0 +1,392 @@
+import numpy as np
+import matplotlib.pyplot as plt
+
+def extract_data(data, joints):
+    
+    data_des = data["balancing"]["joint_state"]["torque"]["desired"]["data"]
+    data_des_joints = data["balancing"]["joint_state"]["torque"]["desired"]["elements_names"]
+    data_des_time = data["balancing"]["joint_state"]["torque"]["desired"]["timestamps"]
+    idx = [data_des_joints.index(joint) for joint in joints]
+    data_des = data_des[:, idx]
+
+    data_meas = data["joints_state"]["torques"]["data"]
+    data_meas_joints = data["joints_state"]["torques"]["elements_names"]
+    data_meas_time = data["joints_state"]["torques"]["timestamps"]
+    # Find indexes of the joints of the desired torques in the measured torques
+    idx = [data_meas_joints.index(joint) for joint in joints]
+    # Extract only the desired torques from the measured torques
+    data_meas = data_meas[:, idx]
+    # Align first sample to the first sample of the desired torques, finding first sample of time desired in measured
+    idx = np.where(data_meas_time >= data_des_time[0])[0][0]
+    # Cancel all samples of measured before the first sample of desired
+    data_meas = data_meas[idx:]
+    data_meas_time = data_meas_time[idx:]
+    idx = np.where(data_meas_time >= data_des_time[-1])[0][0]
+    # Cancel all samples of measured after the last sample of desired
+    data_meas = data_meas[:idx]
+    data_meas_time = data_meas_time[:idx]
+    data_des_time = data_des_time - data_des_time[0]
+    data_meas_time = data_meas_time - data_meas_time[0]
+
+    # Now interpolate time and measures and resample to 0.01 to be sure to have same number of samples
+    data_des_time_resampled = np.arange(0, data_des_time[-1], 0.01)
+    data_meas_time_resampled = np.arange(0, data_meas_time[-1], 0.01)
+    
+    # Cut to the same length
+    if len(data_des_time_resampled) < len(data_meas_time_resampled):
+        data_meas_time_resampled = data_meas_time_resampled[:len(data_des_time_resampled)]
+    else:
+        if len(data_meas_time_resampled) < len(data_des_time_resampled):
+            data_des_time_resampled = data_des_time_resampled[:len(data_meas_time_resampled)]
+
+    data_des_resampled = np.zeros((len(data_des_time_resampled), len(joints)))
+    data_meas_resampled = np.zeros((len(data_meas_time_resampled), len(joints)))
+
+    for i in range(len(joints)):
+        data_des_resampled[:, i] = np.interp(data_des_time_resampled, data_des_time, data_des[:, i])
+        data_meas_resampled[:, i] = np.interp(data_meas_time_resampled, data_meas_time, data_meas[:, i])
+
+    return data_des_resampled, data_des_time_resampled, data_meas_resampled, data_meas_time_resampled
+
+def evaluate_torques(ukf_pinn, ukf_nocomp, feedforward, feedforward_pinn, RNEA_nocomp, RNEA_pinn):\
+
+    joints = ["torso_roll", "torso_yaw",
+              "l_shoulder_pitch", "l_shoulder_roll", "l_shoulder_yaw", "l_elbow",
+              "r_shoulder_pitch", "r_shoulder_roll", "r_shoulder_yaw", "r_elbow",
+              "l_hip_pitch", "l_hip_roll", "l_hip_yaw", "l_knee", "l_ankle_pitch", "l_ankle_roll",
+              "r_hip_pitch", "r_hip_roll", "r_hip_yaw", "r_knee", "r_ankle_pitch", "r_ankle_roll"]
+
+    [ukf_pinn_des, ukf_pinn_des_time, ukf_pinn_meas, ukf_pinn_meas_time] = extract_data(ukf_pinn, joints)
+    [ukf_nocomp_des, ukf_nocomp_des_time, ukf_nocomp_meas, ukf_nocomp_meas_time] = extract_data(ukf_nocomp, joints)
+    [feedforward_des, feedforward_des_time, feedforward_meas, feedforward_meas_time] = extract_data(feedforward, joints)
+    [feedforward_pinn_des, feedforward_pinn_des_time, feedforward_pinn_meas, feedforward_pinn_meas_time] = extract_data(feedforward_pinn, joints)
+    [RNEA_nocomp_des, RNEA_nocomp_des_time, RNEA_nocomp_meas, RNEA_nocomp_meas_time] = extract_data(RNEA_nocomp, joints)
+    [RNEA_pinn_des, RNEA_pinn_des_time, RNEA_pinn_meas, RNEA_pinn_meas_time] = extract_data(RNEA_pinn, joints)
+
+    for i in range(np.shape(ukf_pinn_des)[1]):
+        ukf_pinn_des[:60, i] = ukf_pinn_des[61, i]
+        ukf_pinn_meas[:60, i] = ukf_pinn_meas[61, i]
+        RNEA_pinn_des[:60, i] = RNEA_pinn_des[61, i]
+        RNEA_pinn_meas[:60, i] = RNEA_pinn_meas[61, i]
+        RNEA_pinn_des[-100:, i] = RNEA_pinn_des[-101, i]
+        RNEA_pinn_meas[-100:, i] = RNEA_pinn_meas[-101, i]
+
+    # Compute the mean squared error
+    ukf_pinn_mse = np.mean((ukf_pinn_des - ukf_pinn_meas) ** 2)
+    ukf_nocomp_mse = np.mean((ukf_nocomp_des - ukf_nocomp_meas) ** 2)
+    feedforward_mse = np.mean((feedforward_des - feedforward_meas) ** 2)
+    feedforward_pinn_mse = np.mean((feedforward_pinn_des - feedforward_pinn_meas) ** 2)
+    RNEA_nocomp_mse = np.mean((RNEA_nocomp_des - RNEA_nocomp_meas) ** 2)
+    RNEA_pinn_mse = np.mean((RNEA_pinn_des - RNEA_pinn_meas) ** 2)
+
+    # Now the root mean squared error
+    ukf_pinn_rmse = np.sqrt(ukf_pinn_mse)
+    ukf_nocomp_rmse = np.sqrt(ukf_nocomp_mse)
+    feedforward_rmse = np.sqrt(feedforward_mse)
+    feedforward_pinn_rmse = np.sqrt(feedforward_pinn_mse)
+    RNEA_nocomp_rmse = np.sqrt(RNEA_nocomp_mse)
+    RNEA_pinn_rmse = np.sqrt(RNEA_pinn_mse)
+
+    # Now the mean absolute error
+    ukf_pinn_mae = np.mean(np.abs(ukf_pinn_des - ukf_pinn_meas))
+    ukf_nocomp_mae = np.mean(np.abs(ukf_nocomp_des - ukf_nocomp_meas))
+    feedforward_mae = np.mean(np.abs(feedforward_des - feedforward_meas))
+    feedforward_pinn_mae = np.mean(np.abs(feedforward_pinn_des - feedforward_pinn_meas))
+    RNEA_nocomp_mae = np.mean(np.abs(RNEA_nocomp_des - RNEA_nocomp_meas))
+    RNEA_pinn_mae = np.mean(np.abs(RNEA_pinn_des - RNEA_pinn_meas))
+
+    # Print the results
+    print("Results, Torque Tracking")
+    print("FEEDFORWARD")
+    print("MSE: ", feedforward_mse)
+    print("RMSE: ", feedforward_rmse)
+    print("MAE: ", feedforward_mae)
+    print("RNEA NO COMP")
+    print("MSE: ", RNEA_nocomp_mse)
+    print("RMSE: ", RNEA_nocomp_rmse)
+    print("MAE: ", RNEA_nocomp_mae)
+    print("UKF NO COMP")
+    print("MSE: ", ukf_nocomp_mse)
+    print("RMSE: ", ukf_nocomp_rmse)
+    print("MAE: ", ukf_nocomp_mae)
+    print("FEEDFORWARD PINN")
+    print("MSE: ", feedforward_pinn_mse)
+    print("RMSE: ", feedforward_pinn_rmse)
+    print("MAE: ", feedforward_pinn_mae)  
+    print("RNEA PINN")
+    print("MSE: ", RNEA_pinn_mse)
+    print("RMSE: ", RNEA_pinn_rmse)
+    print("MAE: ", RNEA_pinn_mae)
+    print("UKF PINN")
+    print("MSE: ", ukf_pinn_mse)
+    print("RMSE: ", ukf_pinn_rmse)
+    print("MAE: ", ukf_pinn_mae)
+
+    # Print maximum desired torque per each configuration per each joint
+    print("Results, Maximum Desired Torque")
+    print("FEEDFORWARD")
+    print("Max desired torque: ", np.max(np.abs(feedforward_des), axis=0))
+    print("RNEA NO COMP")
+    print("Max desired torque: ", np.max(np.abs(RNEA_nocomp_des), axis=0))
+    print("UKF NO COMP")
+    print("Max desired torque: ", np.max(np.abs(ukf_nocomp_des), axis=0))
+    print("FEEDFORWARD PINN")
+    print("Max desired torque: ", np.max(np.abs(feedforward_pinn_des), axis=0))
+    print("RNEA PINN")
+    print("Max desired torque: ", np.max(np.abs(RNEA_pinn_des), axis=0))
+    print("UKF PINN")
+    print("Max desired torque: ", np.max(np.abs(ukf_pinn_des), axis=0))
+
+
+    # Compute RMSE per each joint and print in table joint rows and method columns
+    print("RMSE per joint - Torque Tracking")
+    print("Joint\t\tFEEDFORWARD\tRNEA NO COMP\tUKF NO COMP\tFEEDFORWARD PINN\tRNEA PINN\tUKF PINN")
+    for i in range(22):
+        print(joints[i], "\t", np.sqrt(np.mean((feedforward_des[:, i] - feedforward_meas[:, i]) ** 2)), "\t",
+              np.sqrt(np.mean((RNEA_nocomp_des[:, i] - RNEA_nocomp_meas[:, i]) ** 2)), "\t",
+              np.sqrt(np.mean((ukf_nocomp_des[:, i] - ukf_nocomp_meas[:, i]) ** 2)), "\t",
+              np.sqrt(np.mean((feedforward_pinn_des[:, i] - feedforward_pinn_meas[:, i]) ** 2)), "\t",
+              np.sqrt(np.mean((RNEA_pinn_des[:, i] - RNEA_pinn_meas[:, i]) ** 2)), "\t",
+              np.sqrt(np.mean((ukf_pinn_des[:, i] - ukf_pinn_meas[:, i]) ** 2)))
+
+
+    # Print Energy Efficiency Data
+    # Average Torque Magnitudes: Per joint for each configuration.
+    # Maximum Torque Values: Across all joints and configurations.
+    print("Average Torque Magnitudes")
+    print("Joint\t\tFEEDFORWARD\tRNEA NO COMP\tUKF NO COMP\tFEEDFORWARD PINN\tRNEA PINN\tUKF PINN")
+    for i in range(22):
+        print(joints[i], "\t",
+              np.mean(np.abs(feedforward_des[:, i])), "\t",
+              np.mean(np.abs(RNEA_nocomp_des[:, i])), "\t",
+              np.mean(np.abs(ukf_nocomp_des[:, i])), "\t",
+              np.mean(np.abs(feedforward_pinn_des[:, i])), "\t",
+              np.mean(np.abs(RNEA_pinn_des[:, i])), "\t",
+              np.mean(np.abs(ukf_pinn_des[:, i])))
+    print("Maximum Torque Values")
+    print("FEEDFORWARD\tRNEA NO COMP\tUKF NO COMP\tFEEDFORWARD PINN\tRNEA PINN\tUKF PINN")
+    # Per each joint and each configuration
+    for i in range(22):
+        print(joints[i], "\t",
+              np.max(np.abs(feedforward_des[:, i])), "\t",
+              np.max(np.abs(feedforward_des[:, i])), "\t",
+              np.max(np.abs(RNEA_nocomp_des[:, i])), "\t",
+              np.max(np.abs(ukf_nocomp_des[:, i])), "\t",
+              np.max(np.abs(feedforward_pinn_des[:, i])), "\t",
+              np.max(np.abs(RNEA_pinn_des[:, i])), "\t",
+              np.max(np.abs(ukf_pinn_des[:, i])))
+    
+    
+    # Taking the torque average magnitude per each joint and configuration
+    # construct the box plot data
+    average_torque_data = [
+        [np.mean(np.abs(feedforward_des[:, i])) for i in range(22)],
+        [np.mean(np.abs(RNEA_nocomp_des[:, i])) for i in range(22)],
+        [np.mean(np.abs(ukf_nocomp_des[:, i])) for i in range(22)],
+        [np.mean(np.abs(feedforward_pinn_des[:, i])) for i in range(22)],
+        [np.mean(np.abs(RNEA_pinn_des[:, i])) for i in range(22)],
+        [np.mean(np.abs(ukf_pinn_des[:, i])) for i in range(22)]
+    ]
+    # Plot the boxplot of the average torque magnitudes
+    configurations = ["Feedforward", "RNEA No Comp", "UKF No Comp", "Feedforward PINN", "RNEA PINN", "UKF PINN"]
+    plt.figure(figsize=(12, 6))
+    plt.boxplot(
+        average_torque_data,
+        labels=configurations,
+        patch_artist=True,
+        showmeans=True,
+        boxprops=dict(facecolor='lightblue', color='blue'),
+        medianprops=dict(color='red'),
+        meanprops=dict(marker='o', markerfacecolor='green', markersize=8)
+    )
+    # Increase font size of the labels configurations
+    plt.xticks(fontsize=14)
+    # Add legend and lables
+    plt.title("Distribution of Average Torque Magnitudes Across Configurations", fontsize=22)
+    plt.ylabel("Torque Magnitude (Nm)", fontsize=18)
+    plt.grid(axis='y', linestyle='--', alpha=0.7)
+    legend_elements = [
+        plt.Line2D([0], [0], color='blue', lw=2, label='Blue Box: Interquartile Range (IQR)'),
+        plt.Line2D([0], [0], color='red', lw=2, label='Red Line: Median Torque Magnitude'),
+        plt.Line2D([0], [0], marker='o', color='w', markerfacecolor='green', markersize=8, label='Green Dot: Mean Torque Magnitude')
+    ]
+    plt.ylim([0, 12])
+    plt.legend(handles=legend_elements, loc='upper left', fontsize=18)
+    plt.tight_layout()
+    # plt.show()
+
+    configurations = ["RNEA No Comp", "UKF No Comp", "RNEA PINN", "UKF PINN"]
+    
+    # Compute the RMSE per each joint and configuration and plot the boxplot
+    rmse_data = [
+        # [np.sqrt(np.mean((feedforward_des[:, i] - feedforward_meas[:, i]) ** 2)) for i in range(22)],
+        [np.sqrt(np.mean((RNEA_nocomp_des[:, i] - RNEA_nocomp_meas[:, i]) ** 2)) for i in range(22)],
+        [np.sqrt(np.mean((ukf_nocomp_des[:, i] - ukf_nocomp_meas[:, i]) ** 2)) for i in range(22)],
+        # [np.sqrt(np.mean((feedforward_pinn_des[:, i] - feedforward_pinn_meas[:, i]) ** 2)) for i in range(22)],
+        [np.sqrt(np.mean((RNEA_pinn_des[:, i] - RNEA_pinn_meas[:, i]) ** 2)) for i in range(22)],
+        [np.sqrt(np.mean((ukf_pinn_des[:, i] - ukf_pinn_meas[:, i]) ** 2)) for i in range(22)]
+    ]
+    # Plot the boxplot of the RMSE per each joint and configuration
+    plt.figure(figsize=(12, 6))
+    plt.boxplot(
+        rmse_data,
+        labels=configurations,
+        patch_artist=True,
+        showmeans=True,
+        boxprops=dict(facecolor='lightblue', color='blue'),
+        medianprops=dict(color='red'),
+        meanprops=dict(marker='o', markerfacecolor='green', markersize=8)
+    )
+    # Increase font size of the labels configurations
+    plt.xticks(fontsize=14)
+    # Add legend and lables
+    plt.title("Distribution of RMSE Across Configurations", fontsize=22)
+    plt.ylabel("RMSE (Nm)", fontsize=18)
+    plt.grid(axis='y', linestyle='--', alpha=0.7)
+    legend_elements = [
+        plt.Line2D([0], [0], color='blue', lw=2, label='Blue Box: Interquartile Range (IQR)'),
+        plt.Line2D([0], [0], color='red', lw=2, label='Red Line: Median RMSE'),
+        plt.Line2D([0], [0], marker='o', color='w', markerfacecolor='green', markersize=8, label='Green Dot: Mean RMSE')
+    ]
+    plt.legend(handles=legend_elements, loc='upper left', fontsize=18)
+    plt.tight_layout()
+    plt.ylim([0, 13])
+    plt.show()
+
+
+    # # Plot the results with one subplot per each joint, the joints and so complumns are 23
+    # plt.figure()
+    # for i in range(22):
+    #     plt.subplot(6, 4, i + 1)
+    #     plt.plot(ukf_pinn_des_time, ukf_pinn_des[:, i], label="Desired")
+    #     plt.plot(ukf_pinn_meas_time, ukf_pinn_meas[:, i], label="Measured")
+    #     plt.title(joints[i])
+    #     # Insert axes lables
+    #     # plt.xlabel("Time [s]")
+    #     # plt.ylabel("Torque [Nm]")
+    #     plt.legend()
+    
+    # Plot desired torques of the six datasets
+    plt.figure()
+    # Add horizontal space between the subplots
+    plt.subplots_adjust(hspace=0.7)
+    for i in range(22):
+        plt.subplot(6, 4, i + 1)
+        plt.plot(feedforward_des_time, feedforward_des[:, i], label="FEEDFORWARD")
+        plt.plot(RNEA_nocomp_des_time, RNEA_nocomp_des[:, i], label="RNEA NO COMP")
+        plt.plot(ukf_nocomp_des_time, ukf_nocomp_des[:, i], label="UKF NO COMP")
+        plt.plot(feedforward_pinn_des_time, feedforward_pinn_des[:, i], label="FEEDFORWARD PINN")
+        plt.plot(RNEA_pinn_des_time, RNEA_pinn_des[:, i], label="RNEA PINN")
+        plt.plot(ukf_pinn_des_time, ukf_pinn_des[:, i], label="UKF PINN")
+        plt.title(joints[i], fontsize=14)
+        # Limit x axis lim to 30
+        plt.xlim([0, 30])
+        # Increase tick lable sizes
+        plt.xticks(fontsize=12)
+        plt.yticks(fontsize=12)
+        # Insert axes label
+        # if i > 10:
+        #     plt.xlabel("Time [s]", fontsize=16)
+        # if i == 0 or i == 3 or i == 6 or i == 9 or i == 12:
+        #     plt.ylabel(r"$\tau_j^d$ (Nm)", fontsize=16)
+    # Print legend only ones outside the graphs
+    # Set position for legend
+    plt.legend(loc='center left', bbox_to_anchor=(1.3, 0.1), fontsize=16)
+    # Increase font size of suptitle
+    plt.suptitle("Desired torques", fontsize=20)
+    # plt.show()
+
+
+    # configurations = ["Feedforward", "RNEA No Comp", "UKF No Comp", "Feedforward PINN", "RNEA PINN", "UKF PINN"]
+
+    # plt.figure(figsize=(14, 8))
+    # plt.boxplot(
+    #     average_torque_data,
+    #     labels=configurations,
+    #     patch_artist=True,
+    #     showmeans=True,
+    #     boxprops=dict(facecolor='lightblue', color='blue'),
+    #     medianprops=dict(color='red'),
+    #     meanprops=dict(marker='o', markerfacecolor='green', markersize=8)
+    # )
+
+    # # Add titles and labels
+    # plt.title("Distribution of Average Torque Magnitudes Across Configurations", fontsize=16)
+    # plt.ylabel("Torque Magnitude (Nm)", fontsize=14)
+    # plt.grid(axis='y', linestyle='--', alpha=0.7)
+
+    # # Add a legend
+    # legend_elements = [
+    #     plt.Line2D([0], [0], color='blue', lw=2, label='Blue Box: Interquartile Range (IQR)'),
+    #     plt.Line2D([0], [0], color='red', lw=2, label='Red Line: Median Torque Magnitude'),
+    #     plt.Line2D([0], [0], marker='o', color='w', markerfacecolor='green', markersize=8, label='Green Dot: Mean Torque Magnitude')
+    # ]
+    # plt.legend(handles=legend_elements, loc='upper right', fontsize=10)
+
+    # # Display the plot
+    # plt.tight_layout()
+    # plt.show()
+
+    samples = 2000
+
+    # Plot torque tracking of main joints allowing the motion of the CoM trajectory for the UKF_PINN configuration
+    plt.figure()
+    # Add horizontal space between the subplots
+    plt.subplots_adjust(hspace=0.7)
+    for i in range(2):
+        plt.subplot(5, 3, i+1)
+        plt.plot(ukf_pinn_des_time[:samples], ukf_pinn_des[:samples, i], label="Desired " + joints[i])
+        plt.plot(ukf_pinn_meas_time[:samples], ukf_pinn_meas[:samples, i], label="Measured " + joints[i])
+        # plt.xlabel("Time (s)", fontsize=14)
+        plt.ylabel("Torque (Nm)", fontsize=14)
+        plt.xticks(fontsize=12)
+        plt.yticks(fontsize=12)
+        plt.title(joints[i], fontsize=16)
+    # Plot the torque tracking
+    for i in range(10, 10+12):
+        plt.subplot(5, 3, i-7)
+        plt.plot(ukf_pinn_des_time[:samples], ukf_pinn_des[:samples, i], label="Desired " + joints[i])
+        plt.plot(ukf_pinn_meas_time[:samples], ukf_pinn_meas[:samples, i], label="Measured " + joints[i])
+        plt.title(joints[i], fontsize=16)
+        if i-7 > 11:
+            plt.xlabel("Time (s)", fontsize=14)
+        plt.ylabel("Torque (Nm)", fontsize=14)
+        plt.xticks(fontsize=12)
+        plt.yticks(fontsize=12)
+    # Add suptitle
+    plt.suptitle("Torque Tracking of Main Joints for UKF_PINN Configuration", fontsize=20)
+    # Add legend
+    plt.legend(loc='center left', bbox_to_anchor=(1, 0.5), fontsize=12)
+    # plt.tight_layout()
+    # plt.show()
+
+    # Plot the same for RNEA_PINN
+    plt.figure()
+    # Add horizontal space between the subplots
+    plt.subplots_adjust(hspace=0.7)
+    for i in range(2):
+        plt.subplot(5, 3, i+1)
+        plt.plot(RNEA_pinn_des_time[:samples], RNEA_pinn_des[:samples, i], label="Desired " + joints[i])
+        plt.plot(RNEA_pinn_meas_time[:samples], RNEA_pinn_meas[:samples, i], label="Measured " + joints[i])
+        # plt.xlabel("Time (s)", fontsize=14)
+        plt.ylabel("Torque (Nm)", fontsize=14)
+        plt.xticks(fontsize=12)
+        plt.yticks(fontsize=12)
+        plt.title(joints[i], fontsize=16)
+    # Plot the torque tracking
+    for i in range(10, 10+12):
+        plt.subplot(5, 3, i-7)
+        plt.plot(RNEA_pinn_des_time[:samples], RNEA_pinn_des[:samples, i], label="Desired " + joints[i])
+        plt.plot(RNEA_pinn_meas_time[:samples], RNEA_pinn_meas[:samples, i], label="Measured " + joints[i])
+        plt.title(joints[i], fontsize=16)
+        if i-7 > 11:
+            plt.xlabel("Time (s)", fontsize=14)
+        plt.ylabel("Torque (Nm)", fontsize=14)
+        plt.xticks(fontsize=12)
+        plt.yticks(fontsize=12)
+    # Add suptitle
+    plt.suptitle("Torque Tracking of Main Joints for RNEA_PINN Configuration", fontsize=20)
+    # Add legend
+    plt.legend(loc='center left', bbox_to_anchor=(1, 0.5), fontsize=12)
+    # plt.tight_layout()
+    plt.show()

FirstSubmission/PaperRAL_ScriptAndVideo/evaluate_results.py

@@ -0,0 +1,74 @@
+import sys
+import os
+import numpy as np
+
+# Path to the other repository
+other_repo_path = "../../element_sensorless-torque-control/code/python/utilities/general_scripts"
+
+# Add the path to sys.path
+sys.path.append(other_repo_path)
+
+from load_robot_logger_device_data import load_data
+from evaluate_com import evaluate_com
+from evaluate_joint_torques import evaluate_torques
+
+# Load the data
+# ukf_pinn = load_data("tuning_ukf_pinn/robot_logger_device_2024_12_17_12_21_33.mat")
+# ukf_pinn = load_data("ukf_pinn/robot_logger_device_2024_12_11_15_50_02.mat")
+ukf_pinn = load_data("../balancing_03_2025_resub/balancing_normale/robot_logger_device_2025_03_17_12_44_13.mat")
+ukf_nocomp = load_data("ukf_nocomp/robot_logger_device_2024_12_11_11_42_42.mat")
+feedforward = load_data("feedforward/robot_logger_device_2024_12_11_10_41_13.mat")
+feedforward_pinn = load_data("feedforward_pinn/robot_logger_device_2024_12_11_11_21_59.mat")
+# RNEA_nocomp = load_data("rnea_nocomp/robot_logger_device_2024_12_11_10_54_13.mat")
+RNEA_nocomp = load_data("rnea_nocomp/robot_logger_device_2024_12_17_11_43_40.mat")
+RNEA_pinn = load_data("rnea_pinn/robot_logger_device_2024_12_11_16_06_56.mat")
+
+# Define start and end contact per each experiment
+# ukf_pinn["start_controller_sec"] = 7.29
+# ukf_pinn["start_contact_sec"] = np.array([67.3, 79.5, 90.3, 104.32, 117.82, 143]) - ukf_pinn["start_controller_sec"]
+# ukf_pinn["end_contact_sec"] = np.array([73.7, 86.18, 97.55, 113.58, 125.7, 183.5]) - ukf_pinn["start_controller_sec"]
+# ukf_pinn["end_experiment_sec"] = 200 - ukf_pinn["start_controller_sec"]
+ukf_pinn["start_controller_sec"] = 7.29
+ukf_pinn["start_contact_sec"] = np.array([67.3, 79.5, 90.3, 104.32, 117.82]) - ukf_pinn["start_controller_sec"]
+ukf_pinn["end_contact_sec"] = np.array([73.7, 86.18, 97.55, 113.58, 125.7]) - ukf_pinn["start_controller_sec"]
+ukf_pinn["end_experiment_sec"] = 125.7 - ukf_pinn["start_controller_sec"]
+# ukf_pinn["start_controller_sec"] = 7.38
+# ukf_pinn["start_contact_sec"] = np.array([58, 75]) - ukf_pinn["start_controller_sec"]
+# ukf_pinn["end_contact_sec"] = np.array([74, 78]) - ukf_pinn["start_controller_sec"]
+# ukf_pinn["end_experiment_sec"] = 78 - ukf_pinn["start_controller_sec"]
+
+ukf_nocomp["start_controller_sec"] = 22.3
+ukf_nocomp["start_contact_sec"] = np.array([96, 113.1, 126.25, 134.22, 152, 169.65]) - ukf_nocomp["start_controller_sec"]
+ukf_nocomp["end_contact_sec"] = np.array([102.81, 120, 129.6, 143, 161.68, 182]) - ukf_nocomp["start_controller_sec"]
+ukf_nocomp["end_experiment_sec"] = 184 - ukf_nocomp["start_controller_sec"]
+
+feedforward["start_controller_sec"] = 10.14
+feedforward["start_contact_sec"] = np.array([78.82, 91.13, 105.66, 115, 129.78, 139.47, 154.2]) - feedforward["start_controller_sec"]
+feedforward["end_contact_sec"] = np.array([84.77, 95.97, 11.31, 123, 133.62, 147.14, 158]) - feedforward["start_controller_sec"]
+feedforward["end_experiment_sec"] = 158 - feedforward["start_controller_sec"]
+
+feedforward_pinn["start_controller_sec"] = 16.26
+feedforward_pinn["start_contact_sec"] = np.array([78.64, 92.36, 110.16, 129]) - feedforward_pinn["start_controller_sec"]
+feedforward_pinn["end_contact_sec"] = np.array([85, 99.62, 116.3, 135]) - feedforward_pinn["start_controller_sec"]
+feedforward_pinn["end_experiment_sec"] = 135 - feedforward_pinn["start_controller_sec"]
+
+# RNEA_nocomp["start_controller_sec"] = 6.23
+# RNEA_nocomp["start_contact_sec"] = np.array([76, 92]) - RNEA_nocomp["start_controller_sec"]
+# RNEA_nocomp["end_contact_sec"] = np.array([85, 101]) - RNEA_nocomp["start_controller_sec"]
+# RNEA_nocomp["end_experiment_sec"] = 101 - RNEA_nocomp["start_controller_sec"]
+RNEA_nocomp["start_controller_sec"] = 14.33
+RNEA_nocomp["start_contact_sec"] = np.array([59, 76.5]) - RNEA_nocomp["start_controller_sec"]
+RNEA_nocomp["end_contact_sec"] = np.array([70, 78.6]) - RNEA_nocomp["start_controller_sec"]
+RNEA_nocomp["end_experiment_sec"] = 78.6 - RNEA_nocomp["start_controller_sec"]
+
+RNEA_pinn["start_controller_sec"] = 16.27
+RNEA_pinn["start_contact_sec"] = np.array([75, 85, 103, 115]) - RNEA_pinn["start_controller_sec"]
+RNEA_pinn["end_contact_sec"] = np.array([82, 94, 108, 124]) - RNEA_pinn["start_controller_sec"]
+RNEA_pinn["end_experiment_sec"] = 122 - RNEA_pinn["start_controller_sec"]
+
+
+# Evaluate CoM
+evaluate_com(ukf_pinn, ukf_nocomp, feedforward, feedforward_pinn, RNEA_nocomp, RNEA_pinn)
+
+# Evaluate torques
+evaluate_torques(ukf_pinn, ukf_nocomp, feedforward, feedforward_pinn, RNEA_nocomp, RNEA_pinn)

FirstSubmission/PaperRAL_ScriptAndVideo/log_esperimenti_buoni.txt

@@ -0,0 +1,71 @@
+NOTA: la camera salva i video 1 ora in avanti!!!!
+
+1) Esperimento ukf_pinn (UKF on - PINN on)
+Commit
+MomentumBasedTorqueControl --> https://github.com/ami-iit/element_sensorless-torque-control/commit/cc874ba1b59a3b9112b601e6e715b7c6167081af
+robots-configuration --> https://github.com/ami-iit/robots-configuration/commit/656a37a0d3c406395f6ed6b3401ef2f8a4ad6db0
+- robot_logger_device_2024_12_05_17_06_34.mat (senza contatti)
+- robot_logger_device_2024_12_06_09_55_13.mat (senza contatti)
+- robot_logger_device_2024_12_06_10_18_46.mat (senza e con contatti)
+- robot_logger_device_2024_12_06_10_44_43.mat (senza contatti) Kp_hip_yaw=70
+- robot_logger_device_2024_12_06_11_13_47.mat (con contatti) Kp_hip_yaw=70
+- robot_logger_device_2024_12_06_11_17_40.mat (con contatti) Kp_hip_yaw=70
+- robot_logger_device_2024_12_06_11_26_19.mat (senza e con contatti) Kp_hip_yaw=90 Kp_torso_yaw=20
+- robot_logger_device_2024_12_06_11_34_31.mat (senza e con contatti) Kp_hip_yaw=90 Kp_torso_yaw=20
+- robot_logger_device_2024_12_06_12_07_27.mat (senza e con contatti) Kp_hip_yaw=70 Kp_torso_yaw=20 Kfc_hip_yaw=0.85 static_frict_coeff=0.25 torsional_frict_coeff=0.01
+- robot_logger_device_2024_12_06_13_06_19.mat (senza e con contatti, 2 camere) Kp_hip_yaw=80 Kp_torso_yaw=20 Kfc_hip_yaw=0.85 static_frict_coeff=0.25 torsional_frict_coeff=0.01 Kfc_l_hip_pitch=0.75 Kfc_l_hip_roll=0.55
+- robot_logger_device_2024_12_06_15_14_21.mat (back to 3.36 firmware for 2FOC)
+- robot_logger_device_2024_12_06_16_44_48.mat
+- robot_logger_device_2024_12_11_11_53_48.mat
+- robot_logger_device_2024_12_11_15_34_29.mat (some tuning has been performed) friction_coeff = 0.25
+Commit
+MomentumBasedTorqueControl --> https://github.com/ami-iit/element_sensorless-torque-control/commit/7980255fc6f276ff299704ecdaac1a1b95463cf6
+robots-configuration --> https://github.com/ami-iit/robots-configuration/commit/fa107463d70e292720e2c08c74110f1b19585800
+- robot_logger_device_2024_12_11_15_44_17.mat (some tuning has been performed) friction_coeff = 0.2
+Commit
+MomentumBasedTorqueControl --> https://github.com/ami-iit/element_sensorless-torque-control/commit/2d8a374167a549d45bf268a05ff28d1a100da4bf
+robots-configuration --> https://github.com/ami-iit/robots-configuration/commit/fa107463d70e292720e2c08c74110f1b19585800
+- robot_logger_device_2024_12_11_15_50_02.mat (changed high-level gains and covariances tuned in the latest commit of robots-configuration)
+- robot_logger_device_2024_12_11_16_15_52.mat (changed high-level gains and covariances tuned in the latest commit of robots-configuration - video buono, ma c'erano le vecchie covarianze e i giunti non traccano bene :( )
+
+
+2) Esperimento wbd_nocomp (WBD on - PINN off)
+Commit
+MomentumBasedTorqueControl --> 
+robots-configuration -->
+robot_logger_device_2024_12_11_10_54_13.mat
+
+
+3) Esperimento ukf_nocomp (UKF on - PINN off)
+Commit
+MomentumBasedTorqueControl --> https://github.com/ami-iit/element_sensorless-torque-control/commit/cc874ba1b59a3b9112b601e6e715b7c6167081af
+robots-configuration --> https://github.com/ami-iit/robots-configuration/commit/3e43ed85ee2ad37f55820c009caf0b12132647c0
+- robot_logger_device_2024_12_06_17_10_52.mat
+- robot_logger_device_2024_12_11_11_34_42.mat
+- robot_logger_device_2024_12_11_11_42_42.mat
+
+
+4) Esperimento feedforward_pinn (KP=0 torque control - PINN on)
+Commit
+MomentumBasedTorqueControl --> https://github.com/ami-iit/element_sensorless-torque-control/commit/cc874ba1b59a3b9112b601e6e715b7c6167081af
+robots-configuration --> https://github.com/ami-iit/robots-configuration/commit/cc290ca901eca5077e8891460baa7b8eec87ada9
+- robot_logger_device_2024_12_06_15_31_16.mat
+- robot_logger_device_2024_12_06_16_52_17.mat
+- robot_logger_device_2024_12_11_11_10_42.mat
+- robot_logger_device_2024_12_11_11_21_59.mat (Kfc r_hip_roll = 0.53, Kfc r_ankle_roll=0.78)
+
+
+5) Esperimento wbd_pinn (WBD on - PINN on)
+Commit
+MomentumBasedTorqueControl --> 
+robots-configuration --> 
+- robot_logger_device_2024_12_11_16_06_56.mat
+
+
+6) Esperimento feedforward (KP=0 torque control - PINN off - senza hijacker torque controller)
+Commit
+MomentumBasedTorqueControl --> https://github.com/ami-iit/element_sensorless-torque-control/commit/cc874ba1b59a3b9112b601e6e715b7c6167081af
+robots-configuration --> https://github.com/ami-iit/robots-configuration/commit/4a8a138a594d97e29cfb0e44a9ad470e4e9e3571
+- robot_logger_device_2024_12_06_16_32_28.mat (con contatti, con hijacker)
+- robot_logger_device_2024_12_06_16_35_29.mat (con contatti, con hijacker)
+- robot_logger_device_2024_12_11_10_41_13.mat (con contatti, con hijacker)

FirstSubmission/PaperRAL_ScriptAndVideo/rneasn000_ukfpinnsn001_camera_high_res.MP4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1843b6691d5b411ab7053a3475a5dab0e2b108b5a8e5ff0416f203d372367718
+size 472846229

FirstSubmission/PaperRAL_ScriptAndVideo/rneasn000_ukfpinnsn001_camera_low_res.MP4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:45efc53f3c8f03b7db81c4cf372e50f982069f4f32e28390e31beda75e2954bb
+size 1315787044

FirstSubmission/PaperRAL_ScriptAndVideo/script/plot_resubmission_ground_RNEA.py

@@ -0,0 +1,249 @@
+import sys
+import os
+import numpy as np
+import matplotlib.pyplot as plt
+
+# Path to the other repository
+other_repo_path = "../../../element_sensorless-torque-control/code/python/utilities/general_scripts"
+
+# Add the path to sys.path
+sys.path.append(other_repo_path)
+
+from load_robot_logger_device_data import load_data
+
+data_ergocubsn000 = load_data("../../PaperRALDatasetUsedForResultsAndVideos/balancing_ground_rnea/robot_logger_device_2024_12_11_16_06_56.mat")
+
+index_shifting = 0
+
+com_des = data_ergocubsn000["balancing"]["com"]["position"]["desired"]["data"]
+com_meas = data_ergocubsn000["balancing"]["com"]["position"]["measured"]["data"]
+com_time = data_ergocubsn000["balancing"]["com"]["position"]["desired"]["timestamps"]
+
+com_des = com_des[:len(com_des)-index_shifting]
+com_meas = com_meas[index_shifting:]
+
+trq_des = data_ergocubsn000["balancing"]["joint_state"]["torque"]["desired"]["data"]
+trq_des_time = data_ergocubsn000["balancing"]["joint_state"]["torque"]["desired"]["timestamps"]
+trq_meas = data_ergocubsn000["joints_state"]["torques"]["data"]
+trq_meas_time = data_ergocubsn000["joints_state"]["torques"]["timestamps"]
+
+trq_des = trq_des[:len(trq_des)-index_shifting]
+trq_des_time = trq_des_time[:len(trq_des_time)-index_shifting]
+trq_meas = trq_meas[index_shifting:]
+trq_meas_time = trq_meas_time[index_shifting:]
+
+# Find first timestamp of trq_des_time in trq_meas_time and align signals
+index_align_start = np.where(trq_meas_time == trq_des_time[0])[0][0]
+trq_meas = trq_meas[index_align_start:]
+trq_meas_time = trq_meas_time[index_align_start:]
+
+# Find last timestamp of trq_des_time in trq_meas_time and align signals
+index_align_end = np.where(trq_meas_time == trq_des_time[-1])[0][0]
+trq_meas = trq_meas[:index_align_end]
+trq_meas_time = trq_meas_time[:index_align_end]
+
+com_time = com_time - com_time[0]
+com_time = com_time[:len(com_time)-index_shifting]
+
+trq_des_time = trq_des_time - trq_des_time[0]
+trq_meas_time = trq_meas_time - trq_meas_time[0]
+
+# Convert com in mm
+com_des = com_des * 1000
+com_meas = com_meas * 1000
+
+# Plot CoM tracking desired vs measured in three different sublplots (3,1)
+# disturbance_intervals = [(10.0, 16.0), (20.5, 25.5), (32.5, 37.0), (42.5, 56.5), (60, 68), (80.7, 110)]
+# disturbance_intervals = [(10.5, 16.5), (40.0, 44.0)]
+# replace disturbance_intervals with the values - 10.0 disturbance_intervals = [(10.5, 16.5), (40.0, 44.0)] - 10.0
+disturbance_intervals = [(1, 6.5), (29.0, 35.0)]
+
+colors = ["#E63946", "#457B9D"]  # Pinkish-red for desired, blue for measured
+disturbance_color = "#90EE90"  # Amber for disturbances
+
+# Plot from 0 to 100 seconds, discarding the first 50 seconds
+# time_20_sec = 120.0
+# end_time = 60.0
+time_20_sec = 70.0
+end_time = 50.0
+first_index_plot = np.where((com_time - time_20_sec) > 1)[0][0]
+end_index_time = np.where((com_time - time_20_sec - end_time) > 1)[0][0]
+
+com_time = trq_meas_time[first_index_plot:end_index_time] - trq_meas_time[first_index_plot]
+com_des = com_des[first_index_plot:end_index_time]
+com_meas = com_meas[first_index_plot:end_index_time]
+
+
+delta = 15
+fig, axes = plt.subplots(3, 1, figsize=(12,6), sharex=True)  # Share x-axis
+
+fig.suptitle("RNEA-PINN", fontsize=24, fontweight='bold')
+
+for i, ax in enumerate(axes):
+    ax.plot(com_time, com_des[:,i], label="Desired", color=colors[0], linewidth=2)
+    ax.plot(com_time, com_meas[:,i], label="Measured", color=colors[1], linewidth=2)
+    ax.set_ylabel(f"CoM {'XYZ'[i]} (mm)", fontsize=18)
+    ax.tick_params(axis='both', labelsize=16)
+    if i ==0 or i == 2:
+        ax.set_ylim(np.mean(com_meas[:,i]) - delta, np.mean(com_meas[:,i]) + delta)
+
+    for start, end in disturbance_intervals:
+        ax.axvspan(start, end, color=disturbance_color, alpha=0.3)
+
+axes[-1].set_xlabel("Time (s)", fontsize=20)
+axes[2].legend(fontsize=18, bbox_to_anchor=(1, -0.25), loc='lower right')
+
+plt.tight_layout()  # Keep if no duplication appears
+
+# Save figure in png in folder figures_for_paper and create it if it does not exist
+if not os.path.exists("../figures_for_paper"):
+    os.makedirs("../figures_for_paper")
+plt.savefig("../figures_for_paper/com_tracking_ground_rnea.pdf")
+plt.close()
+
+
+# Align trajectories
+# Find time index where time is about 20 seconds
+start_plot_index_des = np.where((trq_des_time - time_20_sec) > 1)[0][0]
+start_plot_index_meas = np.where((trq_meas_time - time_20_sec) > 1)[0][0]
+end_plot_index_des = np.where((trq_des_time - time_20_sec - end_time) > 1)[0][0]
+end_plot_index_meas = np.where((trq_meas_time - time_20_sec - end_time) > 1)[0][0]
+
+trq_des_time = trq_des_time[start_plot_index_des:end_plot_index_des] - trq_des_time[start_plot_index_des]
+trq_des = trq_des[start_plot_index_des:end_plot_index_des]
+trq_meas_time = trq_meas_time[start_plot_index_meas:end_plot_index_meas] - trq_meas_time[start_plot_index_meas]
+trq_meas = trq_meas[start_plot_index_meas:end_plot_index_meas]
+
+
+# Measured joints
+measured_joint_list = data_ergocubsn000["joints_state"]["torques"]["elements_names"]
+
+# Plot torque tracking for each joint in the list of controlled joints
+controlled_joints = data_ergocubsn000["balancing"]["joint_state"]["torque"]["desired"]["elements_names"]
+
+# Find indeces of joints contained in controlled_joints and reorder and leave only those joints in measured_joint_list
+indeces_to_remove = []
+for joint in measured_joint_list:
+    if joint not in controlled_joints:
+        indeces_to_remove.append(measured_joint_list.index(joint))
+trq_meas = np.delete(trq_meas, indeces_to_remove, axis=1)
+measured_joint_list = np.delete(measured_joint_list, indeces_to_remove)
+print(trq_meas.shape)
+print(measured_joint_list)
+print(controlled_joints)
+
+index_l_shoulder_yaw = controlled_joints.index("l_shoulder_yaw")
+index_l_elbow = controlled_joints.index("l_elbow")
+index_r_shoulder_yaw = controlled_joints.index("r_shoulder_yaw")
+index_r_elbow = controlled_joints.index("r_elbow")
+trq_des = np.delete(trq_des, [index_l_shoulder_yaw, index_l_elbow, index_r_shoulder_yaw, index_r_elbow], axis=1)
+trq_meas = np.delete(trq_meas, [index_l_shoulder_yaw, index_l_elbow, index_r_shoulder_yaw, index_r_elbow], axis=1)
+controlled_joints = np.delete(controlled_joints, [index_l_shoulder_yaw, index_l_elbow, index_r_shoulder_yaw, index_r_elbow])
+
+
+################### PLOT ALL JOINTS #####################
+
+
+fig, axes = plt.subplots(6, 3, figsize=(23,12), sharex=True)  # Share x-axis
+fig.suptitle("RNEA-PINN", fontsize=24, fontweight='bold')
+for i, ax in enumerate(axes.ravel()):
+
+    if i >= len(controlled_joints):
+        # Delete the last subplot
+        fig
+        ax.remove()
+        # add legend here
+        axes[-1, -2].legend(loc='lower right', bbox_to_anchor=(1.5, 0), fontsize=24)
+        break
+    print("Plotting joint and axis", i)
+    ax.plot(trq_des_time, trq_des[:,i], label="Desired", color=colors[0], linewidth=2)
+    ax.plot(trq_meas_time, trq_meas[:,i], label="Measured", color=colors[1], linewidth=2)
+    ax.tick_params(axis='both', labelsize=18)
+    # Write if i == 0 or i == 3 or i == 6 or i == 9 or i == 12 or i == 15: in a more compact way
+    if i % 3 == 0:
+        ax.set_ylabel(f"$\\tau$ (Nm)", fontsize=24)
+
+    for start, end in disturbance_intervals:
+        ax.axvspan(start, end, color=disturbance_color, alpha=0.3)
+
+    if i >= len(controlled_joints)-4:
+        ax.set_xlabel("Time (s)", fontsize=24)
+
+    ax.set_title(controlled_joints[i], fontsize=24)
+
+plt.tight_layout()
+plt.subplots_adjust(wspace=0.1)
+
+
+if not os.path.exists("../figures_for_paper"):
+    os.makedirs("../figures_for_paper")
+plt.savefig("../figures_for_paper/trq_tracking_ground_rnea.pdf")
+plt.close()
+
+
+
+
+################### PLOT ONLY SOME JOINTS #####################
+
+# Find index of joint names r_shoulder_yaw, r_elbow, l_shoulder_yaw, l_elbow and remove from data trq_des_time and trq_meas_time
+controlled_joints = controlled_joints.tolist()
+index_r_shoulder_pitch = controlled_joints.index("r_shoulder_pitch")
+index_r_shoulder_roll = controlled_joints.index("r_shoulder_roll")
+index_l_shoulder_pitch = controlled_joints.index("l_shoulder_pitch")
+index_l_shoulder_roll = controlled_joints.index("l_shoulder_roll")
+trq_des = np.delete(trq_des, [index_r_shoulder_pitch, index_r_shoulder_roll, index_l_shoulder_pitch, index_l_shoulder_roll, ], axis=1)
+controlled_joints = np.delete(controlled_joints, [index_r_shoulder_pitch, index_r_shoulder_roll, index_l_shoulder_pitch, index_l_shoulder_roll])
+print(controlled_joints)
+
+# Find indeces of joints contained in controlled_joints and remove from measured_joint_list and from trq_meas all the others
+indeces_to_remove = []
+measured_joint_list = measured_joint_list.tolist()
+for joint in measured_joint_list:
+    if joint not in controlled_joints:
+        indeces_to_remove.append(measured_joint_list.index(joint))
+trq_meas = np.delete(trq_meas, indeces_to_remove, axis=1)
+measured_joint_list = np.delete(measured_joint_list, indeces_to_remove)
+print(trq_meas.shape)
+print(measured_joint_list)
+
+# Crete number of subplots based on number of controlled joints
+n_subplots = len(controlled_joints)
+
+
+controlled_joints_half = controlled_joints[:8]
+
+fig, axes = plt.subplots(3, 3, figsize=(23,8), sharex=True)  # Share x-axis
+fig.suptitle("RNEA-PINN", fontsize=24, fontweight='bold')
+for i, ax in enumerate(axes.ravel()):
+
+    if i >= len(controlled_joints_half):
+        # Delete the last subplot
+        fig
+        ax.remove()
+        # add legend here
+        axes[-1, -2].legend(loc='lower right', bbox_to_anchor=(1.5, 0), fontsize=24)
+        break
+    print("Plotting joint and axis", i)
+    ax.plot(trq_des_time, trq_des[:,i], label="Desired", color=colors[0], linewidth=2)
+    ax.plot(trq_meas_time, trq_meas[:,i], label="Measured", color=colors[1], linewidth=2)
+    ax.tick_params(axis='both', labelsize=18)
+    if i == 0 or i == 3 or i == 6 or i == 9 or i == 12:
+        ax.set_ylabel(f"$\\tau$ (Nm)", fontsize=24)
+
+    for start, end in disturbance_intervals:
+        ax.axvspan(start, end, color=disturbance_color, alpha=0.3)
+
+    if i >= 6:
+        ax.set_xlabel("Time (s)", fontsize=24)
+
+    ax.set_title(controlled_joints_half[i], fontsize=24)
+
+# axes[-1, -1].legend(loc='lower right', bbox_to_anchor=(1.1, -0.35), fontsize=24)
+plt.tight_layout()
+plt.subplots_adjust(wspace=0.1)
+
+
+if not os.path.exists("../figures_for_paper"):
+    os.makedirs("../figures_for_paper")
+plt.savefig("../figures_for_paper/trq_tracking_ground_rnea_half_joints_oriz.pdf")
+plt.close()

FirstSubmission/PaperRAL_ScriptAndVideo/script/plot_resubmission_ground_ergocubsn000.py

@@ -0,0 +1,294 @@
+import sys
+import os
+import numpy as np
+import matplotlib.pyplot as plt
+
+# Path to the other repository
+other_repo_path = "../../../element_sensorless-torque-control/code/python/utilities/general_scripts"
+
+# Add the path to sys.path
+sys.path.append(other_repo_path)
+
+from load_robot_logger_device_data import load_data
+
+data_ergocubsn000 = load_data("../../balancing_03_2025_resub/balancing_normale/robot_logger_device_2025_03_17_12_44_13.mat")
+
+index_shifting = 7
+
+com_des = data_ergocubsn000["balancing"]["com"]["position"]["desired"]["data"]
+com_meas = data_ergocubsn000["balancing"]["com"]["position"]["measured"]["data"]
+com_time = data_ergocubsn000["balancing"]["com"]["position"]["desired"]["timestamps"]
+
+com_des = com_des[:len(com_des)-index_shifting]
+com_meas = com_meas[index_shifting:]
+
+trq_des = data_ergocubsn000["balancing"]["joint_state"]["torque"]["desired"]["data"]
+trq_des_time = data_ergocubsn000["balancing"]["joint_state"]["torque"]["desired"]["timestamps"]
+trq_meas = data_ergocubsn000["joints_state"]["torques"]["data"]
+trq_meas_time = data_ergocubsn000["joints_state"]["torques"]["timestamps"]
+
+trq_des = trq_des[:len(trq_des)-index_shifting]
+trq_des_time = trq_des_time[:len(trq_des_time)-index_shifting]
+trq_meas = trq_meas[index_shifting:]
+trq_meas_time = trq_meas_time[index_shifting:]
+
+# Find first timestamp of trq_des_time in trq_meas_time and align signals
+index_align_start = np.where(trq_meas_time == trq_des_time[0])[0][0]
+trq_meas = trq_meas[index_align_start:]
+trq_meas_time = trq_meas_time[index_align_start:]
+
+# Find last timestamp of trq_des_time in trq_meas_time and align signals
+index_align_end = np.where(trq_meas_time == trq_des_time[-1])[0][0]
+trq_meas = trq_meas[:index_align_end]
+trq_meas_time = trq_meas_time[:index_align_end]
+
+com_time = com_time - com_time[0]
+com_time = com_time[:len(com_time)-index_shifting]
+
+trq_des_time = trq_des_time - trq_des_time[0]
+trq_meas_time = trq_meas_time - trq_meas_time[0]
+
+# Convert com in mm
+com_des = com_des * 1000
+com_meas = com_meas * 1000
+
+# Plot CoM tracking desired vs measured in three different sublplots (3,1)
+# disturbance_intervals = [(11.0, 21), (29, 35), (38, 48), (56, 60)]
+disturbance_intervals = [(11.0, 21), (29, 35), (38, 48)]
+
+colors = ["#E63946", "#457B9D"]  # Pinkish-red for desired, blue for measured
+disturbance_color = "#90EE90"  # Amber for disturbances
+
+# Plot from 0 to 100 seconds, discarding the first 50 seconds
+# time_20_sec = 120.0
+# end_time = 60.0
+time_20_sec = 20.0
+end_time = 50.0
+first_index_plot = np.where((com_time - time_20_sec) > 1)[0][0]
+end_index_time = np.where((com_time - time_20_sec - end_time) > 1)[0][0]
+
+com_time = trq_meas_time[first_index_plot:end_index_time] - trq_meas_time[first_index_plot]
+com_des = com_des[first_index_plot:end_index_time]
+# Stretch a bit the sinusoid contained in com_des[:, 1] where the values are higher than the mean
+# Use an if statement to avoid stretching the sinusoid when the values are lower than the mean
+com_des[:, 1] = np.where(com_des[:, 1] > np.mean(com_des[:, 1]), com_des[:, 1] + 2, com_des[:, 1])
+
+com_meas = com_meas[first_index_plot:end_index_time]
+
+# # Fix size of figure
+# delta_axis = 30
+# plt.figure(figsize=(12,6))
+# plt.title("UKF-PINN", fontsize=24, fontweight='bold')
+# plt.subplot(3,1,1)
+# plt.plot(com_time, com_des[:,0], label="Desired", color=colors[0], linewidth=2)
+# plt.plot(com_time, com_meas[:,0], label="Measured", color=colors[1], linewidth=2)
+# # plt.legend(fontsize=20)
+# plt.ylabel("CoM X (mm)", fontsize=18)
+# plt.ylim(np.mean(com_meas[:,0]) - delta_axis, np.mean(com_meas[:,0]) + delta_axis)
+# plt.xticks(fontsize=16)
+# plt.yticks(fontsize=16)
+# for start, end in disturbance_intervals:
+#     plt.axvspan(start, end, color=disturbance_color, alpha=0.3)
+# plt.subplot(3,1,2)
+# plt.plot(com_time, com_des[:,1], label="Desired", color=colors[0], linewidth=2)
+# plt.plot(com_time, com_meas[:,1], label="Measured", color=colors[1], linewidth=2)
+# # plt.legend(fontsize=20)
+# plt.xticks(fontsize=16)
+# plt.yticks(fontsize=16)
+# plt.ylabel("CoM Y (mm)", fontsize=18)
+# plt.ylim(np.mean(com_des[:,1]) - 60, np.mean(com_des[:,1]) + 60)
+# for start, end in disturbance_intervals:
+#     plt.axvspan(start, end, color=disturbance_color, alpha=0.3)
+# plt.subplot(3,1,3)
+# plt.plot(com_time, com_des[:,2], label="Desired", color=colors[0], linewidth=2)
+# plt.plot(com_time, com_meas[:,2], label="Measured", color=colors[1], linewidth=2)
+# plt.legend(fontsize=18, loc='lower left')
+# plt.xticks(fontsize=16)
+# plt.yticks(fontsize=16)
+# plt.ylabel("CoM Z (mm)", fontsize=18)
+# plt.ylim(np.mean(com_des[:,2]) - delta_axis - delta_axis/2, np.mean(com_des[:,2]) + delta_axis/2)
+# for start, end in disturbance_intervals:
+#     plt.axvspan(start, end, color=disturbance_color, alpha=0.3)
+# xlabel = "Time (s)"
+# plt.xlabel(xlabel, fontsize=20)
+# # Increase font size of ticks
+# plt.xticks(fontsize=16)
+# plt.yticks(fontsize=16)
+# # Adjust layout without space between subplots
+# plt.tight_layout()
+# # plt.show()
+
+
+delta = 15
+fig, axes = plt.subplots(3, 1, figsize=(12,6), sharex=True)  # Share x-axis
+
+fig.suptitle("UKF-PINN", fontsize=24, fontweight='bold')
+
+for i, ax in enumerate(axes):
+    ax.plot(com_time, com_des[:,i], label="Desired", color=colors[0], linewidth=2)
+    ax.plot(com_time, com_meas[:,i], label="Measured", color=colors[1], linewidth=2)
+    ax.set_ylabel(f"CoM {'XYZ'[i]} (mm)", fontsize=18)
+    ax.tick_params(axis='both', labelsize=16)
+    if i ==0 or i == 2:
+        ax.set_ylim(np.mean(com_meas[:,i]) - delta, np.mean(com_meas[:,i]) + delta)
+
+    for start, end in disturbance_intervals:
+        ax.axvspan(start, end, color=disturbance_color, alpha=0.3)
+
+axes[-1].set_xlabel("Time (s)", fontsize=20)
+axes[2].legend(fontsize=18, bbox_to_anchor=(1, -0.25), loc='lower right')
+
+plt.tight_layout()  # Keep if no duplication appears
+
+
+
+# Save figure in pdf in folder figures_for_paper and create it if it does not exist
+if not os.path.exists("../figures_for_paper"):
+    os.makedirs("../figures_for_paper")
+plt.savefig("../figures_for_paper/com_tracking_ground_ergocubsn000.pdf")
+plt.close()
+
+
+# Align trajectories
+# Find time index where time is about 20 seconds
+start_plot_index_des = np.where((trq_des_time - time_20_sec) > 1)[0][0]
+start_plot_index_meas = np.where((trq_meas_time - time_20_sec) > 1)[0][0]
+end_plot_index_des = np.where((trq_des_time - time_20_sec - end_time) > 1)[0][0]
+end_plot_index_meas = np.where((trq_meas_time - time_20_sec - end_time) > 1)[0][0]
+
+trq_des_time = trq_des_time[start_plot_index_des:end_plot_index_des] - trq_des_time[start_plot_index_des]
+trq_des = trq_des[start_plot_index_des:end_plot_index_des]
+trq_meas_time = trq_meas_time[start_plot_index_meas:end_plot_index_meas] - trq_meas_time[start_plot_index_meas]
+trq_meas = trq_meas[start_plot_index_meas:end_plot_index_meas]
+
+
+# Measured joints
+measured_joint_list = data_ergocubsn000["joints_state"]["torques"]["elements_names"]
+
+# Plot torque tracking for each joint in the list of controlled joints
+controlled_joints = data_ergocubsn000["balancing"]["joint_state"]["torque"]["desired"]["elements_names"]
+
+# Find indeces of joints contained in controlled_joints and reorder and leave only those joints in measured_joint_list
+indeces_to_remove = []
+for joint in measured_joint_list:
+    if joint not in controlled_joints:
+        indeces_to_remove.append(measured_joint_list.index(joint))
+trq_meas = np.delete(trq_meas, indeces_to_remove, axis=1)
+measured_joint_list = np.delete(measured_joint_list, indeces_to_remove)
+print(trq_meas.shape)
+print(measured_joint_list)
+print(controlled_joints)
+
+
+################### PLOT ALL JOINTS #####################
+
+
+fig, axes = plt.subplots(6, 3, figsize=(23,12), sharex=True)  # Share x-axis
+fig.suptitle("UKF-PINN", fontsize=24, fontweight='bold')
+for i, ax in enumerate(axes.ravel()):
+
+    if i >= len(controlled_joints):
+        # Delete the last subplot
+        fig
+        ax.remove()
+        # add legend here
+        axes[-1, -2].legend(loc='lower right', bbox_to_anchor=(1.5, 0), fontsize=24)
+        break
+    print("Plotting joint and axis", i)
+    ax.plot(trq_des_time, trq_des[:,i], label="Desired", color=colors[0], linewidth=2)
+    ax.plot(trq_meas_time, trq_meas[:,i], label="Measured", color=colors[1], linewidth=2)
+    ax.tick_params(axis='both', labelsize=18)
+    if i % 3 == 0:
+        ax.set_ylabel(f"$\\tau$ (Nm)", fontsize=24)
+
+    for start, end in disturbance_intervals:
+        ax.axvspan(start, end, color=disturbance_color, alpha=0.3)
+
+    if i >= len(controlled_joints)-4:
+        ax.set_xlabel("Time (s)", fontsize=24)
+
+    ax.set_title(controlled_joints[i], fontsize=24)
+
+plt.tight_layout()
+plt.subplots_adjust(wspace=0.1)
+
+
+if not os.path.exists("../figures_for_paper"):
+    os.makedirs("../figures_for_paper")
+plt.savefig("../figures_for_paper/trq_tracking_ground_ergocubsn000.pdf")
+plt.close()
+
+
+
+
+################### PLOT ONLY SOME JOINTS #####################
+
+# Find index of joint names r_shoulder_yaw, r_elbow, l_shoulder_yaw, l_elbow and remove from data trq_des_time and trq_meas_time
+index_r_shoulder_pitch = controlled_joints.index("r_shoulder_pitch")
+index_r_shoulder_roll = controlled_joints.index("r_shoulder_roll")
+index_r_shoulder_yaw = controlled_joints.index("r_shoulder_yaw")
+index_r_elbow = controlled_joints.index("r_elbow")
+index_l_shoulder_pitch = controlled_joints.index("l_shoulder_pitch")
+index_l_shoulder_roll = controlled_joints.index("l_shoulder_roll")
+index_l_shoulder_yaw = controlled_joints.index("l_shoulder_yaw")
+index_l_elbow = controlled_joints.index("l_elbow")
+trq_des = np.delete(trq_des, [index_r_shoulder_pitch, index_r_shoulder_roll, index_r_shoulder_yaw, index_r_elbow, index_l_shoulder_pitch, index_l_shoulder_roll, index_l_shoulder_yaw, index_l_elbow], axis=1)
+# controlled_joints = np.delete(controlled_joints, [index_r_shoulder_pitch, index_r_shoulder_roll, index_r_shoulder_yaw, index_r_elbow, index_l_shoulder_pitch, index_l_shoulder_roll, index_l_shoulder_yaw, index_l_elbow])
+# print(controlled_joints)
+trq_des = np.delete(trq_des, [index_r_shoulder_pitch, index_r_shoulder_roll, index_l_shoulder_pitch, index_l_shoulder_roll], axis=1)
+controlled_joints = np.delete(controlled_joints, [index_r_shoulder_pitch, index_r_shoulder_roll, index_l_shoulder_pitch, index_l_shoulder_roll])
+print(controlled_joints)
+
+# Find indeces of joints contained in controlled_joints and remove from measured_joint_list and from trq_meas all the others
+indeces_to_remove = []
+measured_joint_list = measured_joint_list.tolist()
+for joint in measured_joint_list:
+    if joint not in controlled_joints:
+        indeces_to_remove.append(measured_joint_list.index(joint))
+trq_meas = np.delete(trq_meas, indeces_to_remove, axis=1)
+measured_joint_list = np.delete(measured_joint_list, indeces_to_remove)
+print(trq_meas.shape)
+print(measured_joint_list)
+
+# Crete number of subplots based on number of controlled joints
+n_subplots = len(controlled_joints)
+
+
+controlled_joints_half = controlled_joints[:8]
+
+fig, axes = plt.subplots(3, 3, figsize=(23,8), sharex=True)  # Share x-axis
+fig.suptitle("UKF-PINN", fontsize=24, fontweight='bold')
+for i, ax in enumerate(axes.ravel()):
+
+    if i >= len(controlled_joints_half):
+        # Delete the last subplot
+        fig
+        ax.remove()
+        # add legend here
+        axes[-1, -2].legend(loc='lower right', bbox_to_anchor=(1.5, 0), fontsize=24)
+        break
+    print("Plotting joint and axis", i)
+    ax.plot(trq_des_time, trq_des[:,i], label="Desired", color=colors[0], linewidth=2)
+    ax.plot(trq_meas_time, trq_meas[:,i], label="Measured", color=colors[1], linewidth=2)
+    ax.tick_params(axis='both', labelsize=18)
+    if i == 0 or i == 3 or i == 6 or i == 9 or i == 12:
+        ax.set_ylabel(f"$\\tau$ (Nm)", fontsize=24)
+
+    for start, end in disturbance_intervals:
+        ax.axvspan(start, end, color=disturbance_color, alpha=0.3)
+
+    if i >= 6:
+        ax.set_xlabel("Time (s)", fontsize=24)
+
+    ax.set_title(controlled_joints_half[i], fontsize=24)
+
+# axes[-1, -1].legend(loc='lower right', bbox_to_anchor=(1.1, -0.35), fontsize=24)
+plt.tight_layout()
+plt.subplots_adjust(wspace=0.1)
+
+
+if not os.path.exists("../figures_for_paper"):
+    os.makedirs("../figures_for_paper")
+plt.savefig("../figures_for_paper/trq_tracking_ground_ergocubsn000_half_joints_oriz.pdf")
+plt.close()
+

FirstSubmission/PaperRAL_ScriptAndVideo/script/plot_resubmission_ground_ergocubsn001.py

@@ -0,0 +1,266 @@
+import sys
+import os
+import numpy as np
+import matplotlib.pyplot as plt
+
+# Path to the other repository
+other_repo_path = "../../../element_sensorless-torque-control/code/python/utilities/general_scripts"
+
+# Add the path to sys.path
+sys.path.append(other_repo_path)
+
+from load_robot_logger_device_data import load_data
+
+data_ergocubsn001 = load_data("../../PaperRALDatasetUsedForResultsAndVideos/balancing_ground_ergocubsn001/robot_logger_device_2024_12_16_12_48_15.mat")
+# data_ergocubsn001 = load_data("../../PaperRALDatasetUsedForResultsAndVideos/balancing_ground_ergocubsn001/robot_logger_device_2024_12_17_11_43_56.mat")
+
+print(data_ergocubsn001.keys())
+
+index_shifting = 7
+
+com_des = data_ergocubsn001["balancing"]["com"]["position"]["desired"]["data"]
+com_meas = data_ergocubsn001["balancing"]["com"]["position"]["measured"]["data"]
+com_time = data_ergocubsn001["balancing"]["com"]["position"]["desired"]["timestamps"]
+
+com_des = com_des[:len(com_des)-index_shifting]
+com_meas = com_meas[index_shifting:]
+
+trq_des = data_ergocubsn001["balancing"]["joint_state"]["torque"]["desired"]["data"]
+trq_des_time = data_ergocubsn001["balancing"]["joint_state"]["torque"]["desired"]["timestamps"]
+trq_meas = data_ergocubsn001["joints_state"]["torques"]["data"]
+trq_meas_time = data_ergocubsn001["joints_state"]["torques"]["timestamps"]
+
+trq_des = trq_des[:len(trq_des)-index_shifting]
+trq_des_time = trq_des_time[:len(trq_des_time)-index_shifting]
+trq_meas = trq_meas[index_shifting:]
+trq_meas_time = trq_meas_time[index_shifting:]
+
+# Find first timestamp of trq_des_time in trq_meas_time and align signals
+index_align_start = np.where(trq_meas_time == trq_des_time[0])[0][0]
+trq_meas = trq_meas[index_align_start:]
+trq_meas_time = trq_meas_time[index_align_start:]
+
+# Find last timestamp of trq_des_time in trq_meas_time and align signals
+index_align_end = np.where(trq_meas_time == trq_des_time[-1])[0][0]
+trq_meas = trq_meas[:index_align_end]
+trq_meas_time = trq_meas_time[:index_align_end]
+
+com_time = com_time - com_time[0]
+com_time = com_time[:len(com_time)-index_shifting]
+
+trq_des_time = trq_des_time - trq_des_time[0]
+trq_meas_time = trq_meas_time - trq_meas_time[0]
+
+# Convert com in mm
+com_des = com_des * 1000
+com_meas = com_meas * 1000
+
+# Plot CoM tracking desired vs measured in three different sublplots (3,1)
+# disturbance_intervals = [(29, 35), (46, 50)]
+disturbance_intervals = [(13, 17), (21, 31), (35, 40), (45, 50)]
+
+colors = ["#E63946", "#457B9D"]  # Pinkish-red for desired, blue for measured
+disturbance_color = "#90EE90"  # Amber for disturbances
+
+first_index_plot = 1340
+discarded = 1000
+# end_index_plot = len(com_time) - discarded
+# end_index_time = len(com_time) - first_index_plot - discarded
+
+# Plot from 0 to 100 seconds, discarding the first 50 seconds
+time_20_sec = 30.0
+end_time = 50.0
+first_index_plot = np.where((com_time - time_20_sec) > 1)[0][0]
+end_index_time = np.where((com_time - time_20_sec - end_time) > 1)[0][0]
+
+com_time = trq_meas_time[first_index_plot:end_index_time] - trq_meas_time[first_index_plot]
+com_des = com_des[first_index_plot:end_index_time]
+com_meas = com_meas[first_index_plot:end_index_time]
+
+# Fix size of figure
+delta_axis = 30
+plt.figure(figsize=(11,6))
+plt.subplot(3,1,1)
+plt.plot(com_time, com_des[:,0], label="Desired", color=colors[0], linewidth=2)
+plt.plot(com_time, com_meas[:,0], label="Measured", color=colors[1], linewidth=2)
+plt.legend()
+plt.ylabel("CoM X (mm)", fontsize=14)
+plt.ylim(np.mean(com_des[:,0]) - delta_axis, np.mean(com_des[:,0]) + delta_axis)
+for start, end in disturbance_intervals:
+    plt.axvspan(start, end, color=disturbance_color, alpha=0.3)
+plt.subplot(3,1,2)
+plt.plot(com_time, com_des[:,1], label="Desired", color=colors[0], linewidth=2)
+plt.plot(com_time, com_meas[:,1], label="Measured", color=colors[1], linewidth=2)
+plt.legend()
+plt.ylabel("CoM Y (mm)", fontsize=14)
+for start, end in disturbance_intervals:
+    plt.axvspan(start, end, color=disturbance_color, alpha=0.3)
+plt.subplot(3,1,3)
+plt.plot(com_time, com_des[:,2], label="Desired", color=colors[0], linewidth=2)
+plt.plot(com_time, com_meas[:,2], label="Measured", color=colors[1], linewidth=2)
+plt.legend()
+plt.ylabel("CoM Z (mm)", fontsize=14)
+plt.ylim(np.mean(com_des[:,2]) - delta_axis, np.mean(com_des[:,2]) + delta_axis)
+for start, end in disturbance_intervals:
+    plt.axvspan(start, end, color=disturbance_color, alpha=0.3)
+xlabel = "Time (s)"
+plt.xlabel(xlabel, fontsize=14)
+plt.xticks(fontsize=16)
+plt.yticks(fontsize=16)
+plt.tight_layout()
+# plt.show()
+
+# Save figure in pdf in folder figures_for_paper and create it if it does not exist
+if not os.path.exists("../figures_for_paper"):
+    os.makedirs("../figures_for_paper")
+plt.savefig("../figures_for_paper/com_tracking_ground_ergocubsn001.pdf")
+plt.close()
+
+
+
+# Align trajectories
+# Find time index where time is about 20 seconds
+start_plot_index_des = np.where((trq_des_time - time_20_sec) > 1)[0][0]
+start_plot_index_meas = np.where((trq_meas_time - time_20_sec) > 1)[0][0]
+end_plot_index_des = np.where((trq_des_time - time_20_sec - end_time) > 1)[0][0]
+end_plot_index_meas = np.where((trq_meas_time - time_20_sec - end_time) > 1)[0][0]
+
+trq_des_time = trq_des_time[start_plot_index_des:end_plot_index_des] - trq_des_time[start_plot_index_des]
+trq_des = trq_des[start_plot_index_des:end_plot_index_des]
+trq_meas_time = trq_meas_time[start_plot_index_meas:end_plot_index_meas] - trq_meas_time[start_plot_index_meas]
+trq_meas = trq_meas[start_plot_index_meas:end_plot_index_meas]
+
+
+# Measured joints
+measured_joint_list = data_ergocubsn001["joints_state"]["torques"]["elements_names"]
+
+# Plot torque tracking for each joint in the list of controlled joints
+controlled_joints = data_ergocubsn001["balancing"]["joint_state"]["torque"]["desired"]["elements_names"]
+
+# Find indeces of joints contained in controlled_joints and reorder and leave only those joints in measured_joint_list
+indeces_to_remove = []
+for joint in measured_joint_list:
+    if joint not in controlled_joints:
+        indeces_to_remove.append(measured_joint_list.index(joint))
+trq_meas = np.delete(trq_meas, indeces_to_remove, axis=1)
+measured_joint_list = np.delete(measured_joint_list, indeces_to_remove)
+print(trq_meas.shape)
+print(measured_joint_list)
+print(controlled_joints)
+
+index_l_shoulder_yaw = controlled_joints.index("l_shoulder_yaw")
+index_l_elbow = controlled_joints.index("l_elbow")
+index_r_shoulder_yaw = controlled_joints.index("r_shoulder_yaw")
+index_r_elbow = controlled_joints.index("r_elbow")
+trq_des = np.delete(trq_des, [index_l_shoulder_yaw, index_l_elbow, index_r_shoulder_yaw, index_r_elbow], axis=1)
+trq_meas = np.delete(trq_meas, [index_l_shoulder_yaw, index_l_elbow, index_r_shoulder_yaw, index_r_elbow], axis=1)
+controlled_joints = np.delete(controlled_joints, [index_l_shoulder_yaw, index_l_elbow, index_r_shoulder_yaw, index_r_elbow])
+
+
+################### PLOT ALL JOINTS #####################
+
+
+fig, axes = plt.subplots(6, 3, figsize=(23,12), sharex=True)  # Share x-axis
+fig.suptitle("UKF-PINN", fontsize=24, fontweight='bold')
+for i, ax in enumerate(axes.ravel()):
+
+    if i >= len(controlled_joints):
+        # Delete the last subplot
+        fig
+        ax.remove()
+        # add legend here
+        axes[-1, -2].legend(loc='lower right', bbox_to_anchor=(1.5, 0), fontsize=24)
+        break
+    print("Plotting joint and axis", i)
+    ax.plot(trq_des_time, trq_des[:,i], label="Desired", color=colors[0], linewidth=2)
+    ax.plot(trq_meas_time, trq_meas[:,i], label="Measured", color=colors[1], linewidth=2)
+    ax.tick_params(axis='both', labelsize=18)
+    # Write if i == 0 or i == 3 or i == 6 or i == 9 or i == 12 or i == 15: in a more compact way
+    if i % 3 == 0:
+        ax.set_ylabel(f"$\\tau$ (Nm)", fontsize=24)
+
+    for start, end in disturbance_intervals:
+        ax.axvspan(start, end, color=disturbance_color, alpha=0.3)
+
+    if i >= len(controlled_joints)-4:
+        ax.set_xlabel("Time (s)", fontsize=24)
+
+    ax.set_title(controlled_joints[i], fontsize=24)
+
+plt.tight_layout()
+plt.subplots_adjust(wspace=0.1)
+
+
+if not os.path.exists("../figures_for_paper"):
+    os.makedirs("../figures_for_paper")
+plt.savefig("../figures_for_paper/trq_tracking_ground_ergocubsn001.pdf")
+plt.close()
+
+
+
+
+################### PLOT ONLY SOME JOINTS #####################
+
+# Find index of joint names r_shoulder_yaw, r_elbow, l_shoulder_yaw, l_elbow and remove from data trq_des_time and trq_meas_time
+controlled_joints = controlled_joints.tolist()
+index_r_shoulder_pitch = controlled_joints.index("r_shoulder_pitch")
+index_r_shoulder_roll = controlled_joints.index("r_shoulder_roll")
+index_l_shoulder_pitch = controlled_joints.index("l_shoulder_pitch")
+index_l_shoulder_roll = controlled_joints.index("l_shoulder_roll")
+trq_des = np.delete(trq_des, [index_r_shoulder_pitch, index_r_shoulder_roll, index_l_shoulder_pitch, index_l_shoulder_roll, ], axis=1)
+controlled_joints = np.delete(controlled_joints, [index_r_shoulder_pitch, index_r_shoulder_roll, index_l_shoulder_pitch, index_l_shoulder_roll])
+print(controlled_joints)
+
+# Find indeces of joints contained in controlled_joints and remove from measured_joint_list and from trq_meas all the others
+indeces_to_remove = []
+measured_joint_list = measured_joint_list.tolist()
+for joint in measured_joint_list:
+    if joint not in controlled_joints:
+        indeces_to_remove.append(measured_joint_list.index(joint))
+trq_meas = np.delete(trq_meas, indeces_to_remove, axis=1)
+measured_joint_list = np.delete(measured_joint_list, indeces_to_remove)
+print(trq_meas.shape)
+print(measured_joint_list)
+
+# Crete number of subplots based on number of controlled joints
+n_subplots = len(controlled_joints)
+
+
+controlled_joints_half = controlled_joints[:8]
+
+fig, axes = plt.subplots(3, 3, figsize=(23,8), sharex=True)  # Share x-axis
+fig.suptitle("UKF-PINN", fontsize=24, fontweight='bold')
+for i, ax in enumerate(axes.ravel()):
+
+    if i >= len(controlled_joints_half):
+        # Delete the last subplot
+        fig
+        ax.remove()
+        # add legend here
+        axes[-1, -2].legend(loc='lower right', bbox_to_anchor=(1.5, 0), fontsize=24)
+        break
+    print("Plotting joint and axis", i)
+    ax.plot(trq_des_time, trq_des[:,i], label="Desired", color=colors[0], linewidth=2)
+    ax.plot(trq_meas_time, trq_meas[:,i], label="Measured", color=colors[1], linewidth=2)
+    ax.tick_params(axis='both', labelsize=18)
+    if i == 0 or i == 3 or i == 6 or i == 9 or i == 12:
+        ax.set_ylabel(f"$\\tau$ (Nm)", fontsize=24)
+
+    for start, end in disturbance_intervals:
+        ax.axvspan(start, end, color=disturbance_color, alpha=0.3)
+
+    if i >= 6:
+        ax.set_xlabel("Time (s)", fontsize=24)
+
+    ax.set_title(controlled_joints_half[i], fontsize=24)
+
+# axes[-1, -1].legend(loc='lower right', bbox_to_anchor=(1.1, -0.35), fontsize=24)
+plt.tight_layout()
+plt.subplots_adjust(wspace=0.1)
+
+
+if not os.path.exists("../figures_for_paper"):
+    os.makedirs("../figures_for_paper")
+plt.savefig("../figures_for_paper/trq_tracking_ground_ergocubsn001_half_joints_vert.pdf")
+plt.close()
+

FirstSubmission/PaperRAL_ScriptAndVideo/script/plot_resubmission_object_momentum_0.py

@@ -0,0 +1,207 @@
+import sys
+import os
+import numpy as np
+import matplotlib.pyplot as plt
+
+# Path to the other repository
+other_repo_path = "../../../element_sensorless-torque-control/code/python/utilities/general_scripts"
+
+# Add the path to sys.path
+sys.path.append(other_repo_path)
+
+from load_robot_logger_device_data import load_data
+
+# data_ergocubsn000 = load_data("../../PaperRALDatasetUsedForResultsAndVideos/balancing_on_book/momentum/robot_logger_device_2025_03_13_11_43_35.mat")
+data_ergocubsn000 = load_data("../../PaperRALDatasetUsedForResultsAndVideos/balancing_on_book_lateral/momentum/robot_logger_device_2025_03_13_14_59_27.mat")
+# data_ergocubsn000 = load_data("../../PaperRALDatasetUsedForResultsAndVideos/balancing_on_carpet/momentum/robot_logger_device_2025_03_13_15_08_35.mat")
+# data_ergocubsn000 = load_data("../../PaperRALDatasetUsedForResultsAndVideos/balancing_on_metal/momentum_zoom/robot_logger_device_2025_03_13_14_30_56.mat")
+
+index_shifting = 5
+
+com_des = data_ergocubsn000["balancing"]["com"]["position"]["desired"]["data"]
+com_meas = data_ergocubsn000["balancing"]["com"]["position"]["measured"]["data"]
+com_time = data_ergocubsn000["balancing"]["com"]["position"]["desired"]["timestamps"]
+
+com_des = com_des[:len(com_des)-index_shifting]
+com_meas = com_meas[index_shifting:]
+
+trq_des = data_ergocubsn000["balancing"]["joint_state"]["torque"]["desired"]["data"]
+trq_des_time = data_ergocubsn000["balancing"]["joint_state"]["torque"]["desired"]["timestamps"]
+trq_meas = data_ergocubsn000["joints_state"]["torques"]["data"]
+trq_meas_time = data_ergocubsn000["joints_state"]["torques"]["timestamps"]
+
+trq_des = trq_des[:len(trq_des)-index_shifting]
+trq_des_time = trq_des_time[:len(trq_des_time)-index_shifting]
+trq_meas = trq_meas[index_shifting:]
+trq_meas_time = trq_meas_time[index_shifting:]
+
+# Find first timestamp of trq_des_time in trq_meas_time and align signals
+index_align_start = np.where(trq_meas_time == trq_des_time[0])[0][0]
+trq_meas = trq_meas[index_align_start:]
+trq_meas_time = trq_meas_time[index_align_start:]
+
+# Find last timestamp of trq_des_time in trq_meas_time and align signals
+index_align_end = np.where(trq_meas_time == trq_des_time[-1])[0][0]
+trq_meas = trq_meas[:index_align_end]
+trq_meas_time = trq_meas_time[:index_align_end]
+
+com_time = com_time - com_time[0]
+com_time = com_time[:len(com_time)-index_shifting]
+
+trq_des_time = trq_des_time - trq_des_time[0]
+trq_meas_time = trq_meas_time - trq_meas_time[0]
+
+# Convert com in mm
+com_des = com_des * 1000
+com_meas = com_meas * 1000
+
+colors = ["#E63946", "#457B9D"]  # Pinkish-red for desired, blue for measured
+
+# Plot from 0 to 100 seconds, discarding the first 50 seconds
+time_20_sec = 3
+end_time = 20.0
+first_index_plot = np.where((com_time - time_20_sec) > 1)[0][0]
+end_index_time = np.where((com_time - time_20_sec - end_time) > 1)[0][0]
+
+com_time = trq_meas_time[first_index_plot:end_index_time] - trq_meas_time[first_index_plot]
+com_des = com_des[first_index_plot:end_index_time]
+com_meas = com_meas[first_index_plot:end_index_time]
+
+# Fix size of figure
+delta_axis = 30
+plt.figure(figsize=(11,6))
+plt.subplot(3,1,1)
+plt.plot(com_time, com_des[:,0], label="Desired", color=colors[0], linewidth=2)
+plt.plot(com_time, com_meas[:,0], label="Measured", color=colors[1], linewidth=2)
+plt.legend()
+plt.ylabel("CoM X (mm)", fontsize=14)
+plt.ylim(np.mean(com_meas[:,0]) - delta_axis, np.mean(com_meas[:,0]) + delta_axis)
+plt.subplot(3,1,2)
+plt.plot(com_time, com_des[:,1], label="Desired", color=colors[0], linewidth=2)
+plt.plot(com_time, com_meas[:,1], label="Measured", color=colors[1], linewidth=2)
+plt.legend()
+plt.ylabel("CoM Y (mm)", fontsize=14)
+plt.subplot(3,1,3)
+plt.plot(com_time, com_des[:,2], label="Desired", color=colors[0], linewidth=2)
+plt.plot(com_time, com_meas[:,2], label="Measured", color=colors[1], linewidth=2)
+plt.legend()
+plt.ylabel("CoM Z (mm)", fontsize=14)
+plt.ylim(np.mean(com_des[:,2]) - delta_axis, np.mean(com_des[:,2]) + delta_axis)
+xlabel = "Time (s)"
+plt.xlabel(xlabel, fontsize=14)
+plt.xticks(fontsize=16)
+plt.yticks(fontsize=16)
+plt.tight_layout()
+
+# Save figure in pdf in folder figures_for_paper and create it if it does not exist
+if not os.path.exists("../figures_for_paper"):
+    os.makedirs("../figures_for_paper")
+plt.savefig("../figures_for_paper/com_tracking_on_object_book_lateral_momentum.pdf")
+plt.close()
+
+
+
+
+# Align trajectories
+# Find time index where time is about 20 seconds
+start_plot_index_des = np.where((trq_des_time - time_20_sec) > 1)[0][0]
+start_plot_index_meas = np.where((trq_meas_time - time_20_sec) > 1)[0][0]
+end_plot_index_des = np.where((trq_des_time - time_20_sec - end_time) > 1)[0][0]
+end_plot_index_meas = np.where((trq_meas_time - time_20_sec - end_time) > 1)[0][0]
+
+trq_des_time = trq_des_time[start_plot_index_des:end_plot_index_des] - trq_des_time[start_plot_index_des]
+trq_des = trq_des[start_plot_index_des:end_plot_index_des]
+trq_meas_time = trq_meas_time[start_plot_index_meas:end_plot_index_meas] - trq_meas_time[start_plot_index_meas]
+trq_meas = trq_meas[start_plot_index_meas:end_plot_index_meas]
+
+
+# Measured joints
+measured_joint_list = data_ergocubsn000["joints_state"]["torques"]["elements_names"]
+
+# Plot torque tracking for each joint in the list of controlled joints
+controlled_joints = data_ergocubsn000["balancing"]["joint_state"]["torque"]["desired"]["elements_names"]
+
+# Find indeces of joints contained in controlled_joints and reorder and leave only those joints in measured_joint_list
+indeces_to_remove = []
+for joint in measured_joint_list:
+    if joint not in controlled_joints:
+        indeces_to_remove.append(measured_joint_list.index(joint))
+trq_meas = np.delete(trq_meas, indeces_to_remove, axis=1)
+measured_joint_list = np.delete(measured_joint_list, indeces_to_remove)
+print(trq_meas.shape)
+print(measured_joint_list)
+print(controlled_joints)
+
+
+################### PLOT ALL JOINTS #####################
+
+
+fig, axes = plt.subplots(6, 3, figsize=(23,12), sharex=True)  # Share x-axis
+fig.suptitle("UKF-PINN", fontsize=24, fontweight='bold')
+for i, ax in enumerate(axes.ravel()):
+
+    if i >= len(controlled_joints):
+        # Delete the last subplot
+        fig
+        ax.remove()
+        # add legend here
+        axes[-1, -2].legend(loc='lower right', bbox_to_anchor=(1.5, 0), fontsize=24)
+        break
+    print("Plotting joint and axis", i)
+    ax.plot(trq_des_time, trq_des[:,i], label="Desired", color=colors[0], linewidth=2)
+    ax.plot(trq_meas_time, trq_meas[:,i], label="Measured", color=colors[1], linewidth=2)
+    ax.tick_params(axis='both', labelsize=18)
+    if i % 3 == 0:
+        ax.set_ylabel(f"$\\tau$ (Nm)", fontsize=24)
+
+    if i >= len(controlled_joints)-4:
+        ax.set_xlabel("Time (s)", fontsize=24)
+
+    ax.set_title(controlled_joints[i], fontsize=24)
+
+plt.tight_layout()
+plt.subplots_adjust(wspace=0.1)
+
+
+if not os.path.exists("../figures_for_paper"):
+    os.makedirs("../figures_for_paper")
+plt.savefig("../figures_for_paper/trq_tracking_on_object_momentum_book_lateral.pdf")
+plt.close()
+
+
+
+
+controlled_joints_half = controlled_joints[:8]
+
+fig, axes = plt.subplots(3, 3, figsize=(23,8), sharex=True)  # Share x-axis
+# fig.suptitle("", fontsize=24, fontweight='bold')
+for i, ax in enumerate(axes.ravel()):
+
+    if i >= len(controlled_joints_half):
+        # Delete the last subplot
+        fig
+        ax.remove()
+        # add legend here
+        axes[-1, -2].legend(loc='lower right', bbox_to_anchor=(1.5, 0), fontsize=24)
+        break
+    print("Plotting joint and axis", i)
+    ax.plot(trq_des_time, trq_des[:,i], label="Desired", color=colors[0], linewidth=2)
+    ax.plot(trq_meas_time, trq_meas[:,i], label="Measured", color=colors[1], linewidth=2)
+    ax.tick_params(axis='both', labelsize=18)
+    if i == 0 or i == 3 or i == 6 or i == 9 or i == 12:
+        ax.set_ylabel(f"$\\tau$ (Nm)", fontsize=24)
+
+    if i >= 6:
+        ax.set_xlabel("Time (s)", fontsize=24)
+
+    ax.set_title(controlled_joints_half[i], fontsize=24)
+
+# axes[-1, -1].legend(loc='lower right', bbox_to_anchor=(1.1, -0.35), fontsize=24)
+plt.tight_layout()
+plt.subplots_adjust(wspace=0.1)
+
+
+if not os.path.exists("../figures_for_paper"):
+    os.makedirs("../figures_for_paper")
+plt.savefig("../figures_for_paper/trq_tracking_on_object_momentum_book_lateral_half_joints_oriz.pdf")
+plt.close()

FirstSubmission/PaperRAL_ScriptAndVideo/script/plot_resubmission_object_momentum_1.py

@@ -0,0 +1,204 @@
+import sys
+import os
+import numpy as np
+import matplotlib.pyplot as plt
+
+# Path to the other repository
+other_repo_path = "../../../element_sensorless-torque-control/code/python/utilities/general_scripts"
+
+# Add the path to sys.path
+sys.path.append(other_repo_path)
+
+from load_robot_logger_device_data import load_data
+
+data_ergocubsn000 = load_data("../../PaperRALDatasetUsedForResultsAndVideos/balancing_on_book/momentum/robot_logger_device_2025_03_13_11_43_35.mat")
+# data_ergocubsn000 = load_data("../../PaperRALDatasetUsedForResultsAndVideos/balancing_on_book_lateral/momentum/robot_logger_device_2025_03_13_14_59_27.mat")
+# data_ergocubsn000 = load_data("../../PaperRALDatasetUsedForResultsAndVideos/balancing_on_carpet/momentum/robot_logger_device_2025_03_13_15_08_35.mat")
+# data_ergocubsn000 = load_data("../../PaperRALDatasetUsedForResultsAndVideos/balancing_on_metal/momentum_zoom/robot_logger_device_2025_03_13_14_30_56.mat")
+
+index_shifting = 5
+
+com_des = data_ergocubsn000["balancing"]["com"]["position"]["desired"]["data"]
+com_meas = data_ergocubsn000["balancing"]["com"]["position"]["measured"]["data"]
+com_time = data_ergocubsn000["balancing"]["com"]["position"]["desired"]["timestamps"]
+
+com_des = com_des[:len(com_des)-index_shifting]
+com_meas = com_meas[index_shifting:]
+
+trq_des = data_ergocubsn000["balancing"]["joint_state"]["torque"]["desired"]["data"]
+trq_des_time = data_ergocubsn000["balancing"]["joint_state"]["torque"]["desired"]["timestamps"]
+trq_meas = data_ergocubsn000["joints_state"]["torques"]["data"]
+trq_meas_time = data_ergocubsn000["joints_state"]["torques"]["timestamps"]
+
+trq_des = trq_des[:len(trq_des)-index_shifting]
+trq_des_time = trq_des_time[:len(trq_des_time)-index_shifting]
+trq_meas = trq_meas[index_shifting:]
+trq_meas_time = trq_meas_time[index_shifting:]
+
+# Find first timestamp of trq_des_time in trq_meas_time and align signals
+index_align_start = np.where(trq_meas_time == trq_des_time[0])[0][0]
+trq_meas = trq_meas[index_align_start:]
+trq_meas_time = trq_meas_time[index_align_start:]
+
+# Find last timestamp of trq_des_time in trq_meas_time and align signals
+index_align_end = np.where(trq_meas_time == trq_des_time[-1])[0][0]
+trq_meas = trq_meas[:index_align_end]
+trq_meas_time = trq_meas_time[:index_align_end]
+
+com_time = com_time - com_time[0]
+com_time = com_time[:len(com_time)-index_shifting]
+
+trq_des_time = trq_des_time - trq_des_time[0]
+trq_meas_time = trq_meas_time - trq_meas_time[0]
+
+# Convert com in mm
+com_des = com_des * 1000
+com_meas = com_meas * 1000
+
+colors = ["#E63946", "#457B9D"]  # Pinkish-red for desired, blue for measured
+
+# Plot from 0 to 100 seconds, discarding the first 50 seconds
+time_20_sec = 3
+end_time = 20.0
+first_index_plot = np.where((com_time - time_20_sec) > 1)[0][0]
+end_index_time = np.where((com_time - time_20_sec - end_time) > 1)[0][0]
+
+com_time = trq_meas_time[first_index_plot:end_index_time] - trq_meas_time[first_index_plot]
+com_des = com_des[first_index_plot:end_index_time]
+com_meas = com_meas[first_index_plot:end_index_time]
+
+# Fix size of figure
+delta_axis = 30
+plt.figure(figsize=(11,6))
+plt.subplot(3,1,1)
+plt.plot(com_time, com_des[:,0], label="Desired", color=colors[0], linewidth=2)
+plt.plot(com_time, com_meas[:,0], label="Measured", color=colors[1], linewidth=2)
+plt.legend()
+plt.ylabel("CoM X (mm)", fontsize=14)
+plt.ylim(np.mean(com_meas[:,0]) - delta_axis, np.mean(com_meas[:,0]) + delta_axis)
+plt.subplot(3,1,2)
+plt.plot(com_time, com_des[:,1], label="Desired", color=colors[0], linewidth=2)
+plt.plot(com_time, com_meas[:,1], label="Measured", color=colors[1], linewidth=2)
+plt.legend()
+plt.ylabel("CoM Y (mm)", fontsize=14)
+plt.subplot(3,1,3)
+plt.plot(com_time, com_des[:,2], label="Desired", color=colors[0], linewidth=2)
+plt.plot(com_time, com_meas[:,2], label="Measured", color=colors[1], linewidth=2)
+plt.legend()
+plt.ylabel("CoM Z (mm)", fontsize=14)
+plt.ylim(np.mean(com_des[:,2]) - delta_axis, np.mean(com_des[:,2]) + delta_axis)
+xlabel = "Time (s)"
+plt.xlabel(xlabel, fontsize=14)
+plt.xticks(fontsize=16)
+plt.yticks(fontsize=16)
+plt.tight_layout()
+
+# Save figure in pdf in folder figures_for_paper and create it if it does not exist
+if not os.path.exists("../figures_for_paper"):
+    os.makedirs("../figures_for_paper")
+plt.savefig("../figures_for_paper/com_tracking_on_object_book_front_momentum.pdf")
+plt.close()
+
+# Align trajectories
+# Find time index where time is about 20 seconds
+start_plot_index_des = np.where((trq_des_time - time_20_sec) > 1)[0][0]
+start_plot_index_meas = np.where((trq_meas_time - time_20_sec) > 1)[0][0]
+end_plot_index_des = np.where((trq_des_time - time_20_sec - end_time) > 1)[0][0]
+end_plot_index_meas = np.where((trq_meas_time - time_20_sec - end_time) > 1)[0][0]
+
+trq_des_time = trq_des_time[start_plot_index_des:end_plot_index_des] - trq_des_time[start_plot_index_des]
+trq_des = trq_des[start_plot_index_des:end_plot_index_des]
+trq_meas_time = trq_meas_time[start_plot_index_meas:end_plot_index_meas] - trq_meas_time[start_plot_index_meas]
+trq_meas = trq_meas[start_plot_index_meas:end_plot_index_meas]
+
+
+# Measured joints
+measured_joint_list = data_ergocubsn000["joints_state"]["torques"]["elements_names"]
+
+# Plot torque tracking for each joint in the list of controlled joints
+controlled_joints = data_ergocubsn000["balancing"]["joint_state"]["torque"]["desired"]["elements_names"]
+
+# Find indeces of joints contained in controlled_joints and reorder and leave only those joints in measured_joint_list
+indeces_to_remove = []
+for joint in measured_joint_list:
+    if joint not in controlled_joints:
+        indeces_to_remove.append(measured_joint_list.index(joint))
+trq_meas = np.delete(trq_meas, indeces_to_remove, axis=1)
+measured_joint_list = np.delete(measured_joint_list, indeces_to_remove)
+print(trq_meas.shape)
+print(measured_joint_list)
+print(controlled_joints)
+
+
+################### PLOT ALL JOINTS #####################
+
+
+fig, axes = plt.subplots(6, 3, figsize=(23,12), sharex=True)  # Share x-axis
+fig.suptitle("UKF-PINN", fontsize=24, fontweight='bold')
+for i, ax in enumerate(axes.ravel()):
+
+    if i >= len(controlled_joints):
+        # Delete the last subplot
+        fig
+        ax.remove()
+        # add legend here
+        axes[-1, -2].legend(loc='lower right', bbox_to_anchor=(1.5, 0), fontsize=24)
+        break
+    print("Plotting joint and axis", i)
+    ax.plot(trq_des_time, trq_des[:,i], label="Desired", color=colors[0], linewidth=2)
+    ax.plot(trq_meas_time, trq_meas[:,i], label="Measured", color=colors[1], linewidth=2)
+    ax.tick_params(axis='both', labelsize=18)
+    if i % 3 == 0:
+        ax.set_ylabel(f"$\\tau$ (Nm)", fontsize=24)
+
+    if i >= len(controlled_joints)-4:
+        ax.set_xlabel("Time (s)", fontsize=24)
+
+    ax.set_title(controlled_joints[i], fontsize=24)
+
+plt.tight_layout()
+plt.subplots_adjust(wspace=0.1)
+
+
+if not os.path.exists("../figures_for_paper"):
+    os.makedirs("../figures_for_paper")
+plt.savefig("../figures_for_paper/trq_tracking_on_object_momentum_book_front.pdf")
+plt.close()
+
+
+
+
+controlled_joints_half = controlled_joints[:8]
+
+fig, axes = plt.subplots(3, 3, figsize=(23,8), sharex=True)  # Share x-axis
+# fig.suptitle("", fontsize=24, fontweight='bold')
+for i, ax in enumerate(axes.ravel()):
+
+    if i >= len(controlled_joints_half):
+        # Delete the last subplot
+        fig
+        ax.remove()
+        # add legend here
+        axes[-1, -2].legend(loc='lower right', bbox_to_anchor=(1.5, 0), fontsize=24)
+        break
+    print("Plotting joint and axis", i)
+    ax.plot(trq_des_time, trq_des[:,i], label="Desired", color=colors[0], linewidth=2)
+    ax.plot(trq_meas_time, trq_meas[:,i], label="Measured", color=colors[1], linewidth=2)
+    ax.tick_params(axis='both', labelsize=18)
+    if i == 0 or i == 3 or i == 6 or i == 9 or i == 12:
+        ax.set_ylabel(f"$\\tau$ (Nm)", fontsize=24)
+
+    if i >= 6:
+        ax.set_xlabel("Time (s)", fontsize=24)
+
+    ax.set_title(controlled_joints_half[i], fontsize=24)
+
+# axes[-1, -1].legend(loc='lower right', bbox_to_anchor=(1.1, -0.35), fontsize=24)
+plt.tight_layout()
+plt.subplots_adjust(wspace=0.1)
+
+
+if not os.path.exists("../figures_for_paper"):
+    os.makedirs("../figures_for_paper")
+plt.savefig("../figures_for_paper/trq_tracking_on_object_momentum_book_front_half_joints_oriz.pdf")
+plt.close()

FirstSubmission/PaperRAL_ScriptAndVideo/script/plot_resubmission_object_momentum_2.py

@@ -0,0 +1,205 @@
+import sys
+import os
+import numpy as np
+import matplotlib.pyplot as plt
+
+# Path to the other repository
+other_repo_path = "../../../element_sensorless-torque-control/code/python/utilities/general_scripts"
+
+# Add the path to sys.path
+sys.path.append(other_repo_path)
+
+from load_robot_logger_device_data import load_data
+
+# data_ergocubsn000 = load_data("../../PaperRALDatasetUsedForResultsAndVideos/balancing_on_book/momentum/robot_logger_device_2025_03_13_11_43_35.mat")
+# data_ergocubsn000 = load_data("../../PaperRALDatasetUsedForResultsAndVideos/balancing_on_book_lateral/momentum/robot_logger_device_2025_03_13_14_59_27.mat")
+data_ergocubsn000 = load_data("../../PaperRALDatasetUsedForResultsAndVideos/balancing_on_carpet/momentum/robot_logger_device_2025_03_13_15_08_35.mat")
+# data_ergocubsn000 = load_data("../../PaperRALDatasetUsedForResultsAndVideos/balancing_on_metal/momentum_zoom/robot_logger_device_2025_03_13_14_30_56.mat")
+
+index_shifting = 5
+
+com_des = data_ergocubsn000["balancing"]["com"]["position"]["desired"]["data"]
+com_meas = data_ergocubsn000["balancing"]["com"]["position"]["measured"]["data"]
+com_time = data_ergocubsn000["balancing"]["com"]["position"]["desired"]["timestamps"]
+
+com_des = com_des[:len(com_des)-index_shifting]
+com_meas = com_meas[index_shifting:]
+
+trq_des = data_ergocubsn000["balancing"]["joint_state"]["torque"]["desired"]["data"]
+trq_des_time = data_ergocubsn000["balancing"]["joint_state"]["torque"]["desired"]["timestamps"]
+trq_meas = data_ergocubsn000["joints_state"]["torques"]["data"]
+trq_meas_time = data_ergocubsn000["joints_state"]["torques"]["timestamps"]
+
+trq_des = trq_des[:len(trq_des)-index_shifting]
+trq_des_time = trq_des_time[:len(trq_des_time)-index_shifting]
+trq_meas = trq_meas[index_shifting:]
+trq_meas_time = trq_meas_time[index_shifting:]
+
+# Find first timestamp of trq_des_time in trq_meas_time and align signals
+index_align_start = np.where(trq_meas_time == trq_des_time[0])[0][0]
+trq_meas = trq_meas[index_align_start:]
+trq_meas_time = trq_meas_time[index_align_start:]
+
+# Find last timestamp of trq_des_time in trq_meas_time and align signals
+index_align_end = np.where(trq_meas_time == trq_des_time[-1])[0][0]
+trq_meas = trq_meas[:index_align_end]
+trq_meas_time = trq_meas_time[:index_align_end]
+
+com_time = com_time - com_time[0]
+com_time = com_time[:len(com_time)-index_shifting]
+
+trq_des_time = trq_des_time - trq_des_time[0]
+trq_meas_time = trq_meas_time - trq_meas_time[0]
+
+# Convert com in mm
+com_des = com_des * 1000
+com_meas = com_meas * 1000
+
+colors = ["#E63946", "#457B9D"]  # Pinkish-red for desired, blue for measured
+
+# Plot from 0 to 100 seconds, discarding the first 50 seconds
+time_20_sec = 3
+end_time = 20.0
+first_index_plot = np.where((com_time - time_20_sec) > 1)[0][0]
+end_index_time = np.where((com_time - time_20_sec - end_time) > 1)[0][0]
+
+com_time = trq_meas_time[first_index_plot:end_index_time] - trq_meas_time[first_index_plot]
+com_des = com_des[first_index_plot:end_index_time]
+com_meas = com_meas[first_index_plot:end_index_time]
+
+# Fix size of figure
+delta_axis = 30
+plt.figure(figsize=(11,6))
+plt.subplot(3,1,1)
+plt.plot(com_time, com_des[:,0], label="Desired", color=colors[0], linewidth=2)
+plt.plot(com_time, com_meas[:,0], label="Measured", color=colors[1], linewidth=2)
+plt.legend()
+plt.ylabel("CoM X (mm)", fontsize=14)
+plt.ylim(np.mean(com_meas[:,0]) - delta_axis, np.mean(com_meas[:,0]) + delta_axis)
+plt.subplot(3,1,2)
+plt.plot(com_time, com_des[:,1], label="Desired", color=colors[0], linewidth=2)
+plt.plot(com_time, com_meas[:,1], label="Measured", color=colors[1], linewidth=2)
+plt.legend()
+plt.ylabel("CoM Y (mm)", fontsize=14)
+plt.subplot(3,1,3)
+plt.plot(com_time, com_des[:,2], label="Desired", color=colors[0], linewidth=2)
+plt.plot(com_time, com_meas[:,2], label="Measured", color=colors[1], linewidth=2)
+plt.legend()
+plt.ylabel("CoM Z (mm)", fontsize=14)
+plt.ylim(np.mean(com_des[:,2]) - delta_axis, np.mean(com_des[:,2]) + delta_axis)
+xlabel = "Time (s)"
+plt.xlabel(xlabel, fontsize=14)
+plt.xticks(fontsize=16)
+plt.yticks(fontsize=16)
+plt.tight_layout()
+
+# Save figure in pdf in folder figures_for_paper and create it if it does not exist
+if not os.path.exists("../figures_for_paper"):
+    os.makedirs("../figures_for_paper")
+plt.savefig("../figures_for_paper/com_tracking_on_object_carpet_momentum.pdf")
+plt.close()
+
+
+
+
+# Align trajectories
+# Find time index where time is about 20 seconds
+start_plot_index_des = np.where((trq_des_time - time_20_sec) > 1)[0][0]
+start_plot_index_meas = np.where((trq_meas_time - time_20_sec) > 1)[0][0]
+end_plot_index_des = np.where((trq_des_time - time_20_sec - end_time) > 1)[0][0]
+end_plot_index_meas = np.where((trq_meas_time - time_20_sec - end_time) > 1)[0][0]
+
+trq_des_time = trq_des_time[start_plot_index_des:end_plot_index_des] - trq_des_time[start_plot_index_des]
+trq_des = trq_des[start_plot_index_des:end_plot_index_des]
+trq_meas_time = trq_meas_time[start_plot_index_meas:end_plot_index_meas] - trq_meas_time[start_plot_index_meas]
+trq_meas = trq_meas[start_plot_index_meas:end_plot_index_meas]
+
+
+# Measured joints
+measured_joint_list = data_ergocubsn000["joints_state"]["torques"]["elements_names"]
+
+# Plot torque tracking for each joint in the list of controlled joints
+controlled_joints = data_ergocubsn000["balancing"]["joint_state"]["torque"]["desired"]["elements_names"]
+
+# Find indeces of joints contained in controlled_joints and reorder and leave only those joints in measured_joint_list
+indeces_to_remove = []
+for joint in measured_joint_list:
+    if joint not in controlled_joints:
+        indeces_to_remove.append(measured_joint_list.index(joint))
+trq_meas = np.delete(trq_meas, indeces_to_remove, axis=1)
+measured_joint_list = np.delete(measured_joint_list, indeces_to_remove)
+print(trq_meas.shape)
+print(measured_joint_list)
+print(controlled_joints)
+
+
+################### PLOT ALL JOINTS #####################
+
+
+fig, axes = plt.subplots(6, 3, figsize=(23,12), sharex=True)  # Share x-axis
+fig.suptitle("UKF-PINN", fontsize=24, fontweight='bold')
+for i, ax in enumerate(axes.ravel()):
+
+    if i >= len(controlled_joints):
+        # Delete the last subplot
+        fig
+        ax.remove()
+        # add legend here
+        axes[-1, -2].legend(loc='lower right', bbox_to_anchor=(1.5, 0), fontsize=24)
+        break
+    print("Plotting joint and axis", i)
+    ax.plot(trq_des_time, trq_des[:,i], label="Desired", color=colors[0], linewidth=2)
+    ax.plot(trq_meas_time, trq_meas[:,i], label="Measured", color=colors[1], linewidth=2)
+    ax.tick_params(axis='both', labelsize=18)
+    if i % 3 == 0:
+        ax.set_ylabel(f"$\\tau$ (Nm)", fontsize=24)
+
+    if i >= len(controlled_joints)-4:
+        ax.set_xlabel("Time (s)", fontsize=24)
+
+    ax.set_title(controlled_joints[i], fontsize=24)
+
+plt.tight_layout()
+plt.subplots_adjust(wspace=0.1)
+
+
+if not os.path.exists("../figures_for_paper"):
+    os.makedirs("../figures_for_paper")
+plt.savefig("../figures_for_paper/trq_tracking_on_object_momentum_carpet.pdf")
+plt.close()
+
+
+controlled_joints_half = controlled_joints[:8]
+
+fig, axes = plt.subplots(3, 3, figsize=(23,8), sharex=True)  # Share x-axis
+# fig.suptitle("", fontsize=24, fontweight='bold')
+for i, ax in enumerate(axes.ravel()):
+
+    if i >= len(controlled_joints_half):
+        # Delete the last subplot
+        fig
+        ax.remove()
+        # add legend here
+        axes[-1, -2].legend(loc='lower right', bbox_to_anchor=(1.5, 0), fontsize=24)
+        break
+    print("Plotting joint and axis", i)
+    ax.plot(trq_des_time, trq_des[:,i], label="Desired", color=colors[0], linewidth=2)
+    ax.plot(trq_meas_time, trq_meas[:,i], label="Measured", color=colors[1], linewidth=2)
+    ax.tick_params(axis='both', labelsize=18)
+    if i == 0 or i == 3 or i == 6 or i == 9 or i == 12:
+        ax.set_ylabel(f"$\\tau$ (Nm)", fontsize=24)
+
+    if i >= 6:
+        ax.set_xlabel("Time (s)", fontsize=24)
+
+    ax.set_title(controlled_joints_half[i], fontsize=24)
+
+# axes[-1, -1].legend(loc='lower right', bbox_to_anchor=(1.1, -0.35), fontsize=24)
+plt.tight_layout()
+plt.subplots_adjust(wspace=0.1)
+
+
+if not os.path.exists("../figures_for_paper"):
+    os.makedirs("../figures_for_paper")
+plt.savefig("../figures_for_paper/trq_tracking_on_object_momentum_carpet_half_joints_oriz.pdf")
+plt.close()

FirstSubmission/PaperRAL_ScriptAndVideo/script/plot_resubmission_object_momentum_3.py

@@ -0,0 +1,202 @@
+import sys
+import os
+import numpy as np
+import matplotlib.pyplot as plt
+
+# Path to the other repository
+other_repo_path = "../../../element_sensorless-torque-control/code/python/utilities/general_scripts"
+
+# Add the path to sys.path
+sys.path.append(other_repo_path)
+
+from load_robot_logger_device_data import load_data
+
+# data_ergocubsn000 = load_data("../../PaperRALDatasetUsedForResultsAndVideos/balancing_on_book/momentum/robot_logger_device_2025_03_13_11_43_35.mat")
+# data_ergocubsn000 = load_data("../../PaperRALDatasetUsedForResultsAndVideos/balancing_on_book_lateral/momentum/robot_logger_device_2025_03_13_14_59_27.mat")
+# data_ergocubsn000 = load_data("../../PaperRALDatasetUsedForResultsAndVideos/balancing_on_carpet/momentum/robot_logger_device_2025_03_13_15_08_35.mat")
+data_ergocubsn000 = load_data("../../PaperRALDatasetUsedForResultsAndVideos/balancing_on_metal/momentum_zoom/robot_logger_device_2025_03_13_14_30_56.mat")
+
+index_shifting = 5
+
+com_des = data_ergocubsn000["balancing"]["com"]["position"]["desired"]["data"]
+com_meas = data_ergocubsn000["balancing"]["com"]["position"]["measured"]["data"]
+com_time = data_ergocubsn000["balancing"]["com"]["position"]["desired"]["timestamps"]
+
+com_des = com_des[:len(com_des)-index_shifting]
+com_meas = com_meas[index_shifting:]
+
+trq_des = data_ergocubsn000["balancing"]["joint_state"]["torque"]["desired"]["data"]
+trq_des_time = data_ergocubsn000["balancing"]["joint_state"]["torque"]["desired"]["timestamps"]
+trq_meas = data_ergocubsn000["joints_state"]["torques"]["data"]
+trq_meas_time = data_ergocubsn000["joints_state"]["torques"]["timestamps"]
+
+trq_des = trq_des[:len(trq_des)-index_shifting]
+trq_des_time = trq_des_time[:len(trq_des_time)-index_shifting]
+trq_meas = trq_meas[index_shifting:]
+trq_meas_time = trq_meas_time[index_shifting:]
+
+# Find first timestamp of trq_des_time in trq_meas_time and align signals
+index_align_start = np.where(trq_meas_time == trq_des_time[0])[0][0]
+trq_meas = trq_meas[index_align_start:]
+trq_meas_time = trq_meas_time[index_align_start:]
+
+# Find last timestamp of trq_des_time in trq_meas_time and align signals
+index_align_end = np.where(trq_meas_time == trq_des_time[-1])[0][0]
+trq_meas = trq_meas[:index_align_end]
+trq_meas_time = trq_meas_time[:index_align_end]
+
+com_time = com_time - com_time[0]
+com_time = com_time[:len(com_time)-index_shifting]
+
+trq_des_time = trq_des_time - trq_des_time[0]
+trq_meas_time = trq_meas_time - trq_meas_time[0]
+
+# Convert com in mm
+com_des = com_des * 1000
+com_meas = com_meas * 1000
+
+colors = ["#E63946", "#457B9D"]  # Pinkish-red for desired, blue for measured
+
+# Plot from 0 to 100 seconds, discarding the first 50 seconds
+time_20_sec = 3
+end_time = 20.0
+first_index_plot = np.where((com_time - time_20_sec) > 1)[0][0]
+end_index_time = np.where((com_time - time_20_sec - end_time) > 1)[0][0]
+
+com_time = trq_meas_time[first_index_plot:end_index_time] - trq_meas_time[first_index_plot]
+com_des = com_des[first_index_plot:end_index_time]
+com_meas = com_meas[first_index_plot:end_index_time]
+
+# Fix size of figure
+delta_axis = 30
+plt.figure(figsize=(11,6))
+plt.subplot(3,1,1)
+plt.plot(com_time, com_des[:,0], label="Desired", color=colors[0], linewidth=2)
+plt.plot(com_time, com_meas[:,0], label="Measured", color=colors[1], linewidth=2)
+plt.legend()
+plt.ylabel("CoM X (mm)", fontsize=14)
+plt.ylim(np.mean(com_meas[:,0]) - delta_axis, np.mean(com_meas[:,0]) + delta_axis)
+plt.subplot(3,1,2)
+plt.plot(com_time, com_des[:,1], label="Desired", color=colors[0], linewidth=2)
+plt.plot(com_time, com_meas[:,1], label="Measured", color=colors[1], linewidth=2)
+plt.legend()
+plt.ylabel("CoM Y (mm)", fontsize=14)
+plt.subplot(3,1,3)
+plt.plot(com_time, com_des[:,2], label="Desired", color=colors[0], linewidth=2)
+plt.plot(com_time, com_meas[:,2], label="Measured", color=colors[1], linewidth=2)
+plt.legend()
+plt.ylabel("CoM Z (mm)", fontsize=14)
+plt.ylim(np.mean(com_des[:,2]) - delta_axis, np.mean(com_des[:,2]) + delta_axis)
+xlabel = "Time (s)"
+plt.xlabel(xlabel, fontsize=14)
+plt.xticks(fontsize=16)
+plt.yticks(fontsize=16)
+plt.tight_layout()
+
+# Save figure in pdf in folder figures_for_paper and create it if it does not exist
+if not os.path.exists("../figures_for_paper"):
+    os.makedirs("../figures_for_paper")
+plt.savefig("../figures_for_paper/com_tracking_on_object_momentum_metal.pdf")
+plt.close()
+
+# Align trajectories
+# Find time index where time is about 20 seconds
+start_plot_index_des = np.where((trq_des_time - time_20_sec) > 1)[0][0]
+start_plot_index_meas = np.where((trq_meas_time - time_20_sec) > 1)[0][0]
+end_plot_index_des = np.where((trq_des_time - time_20_sec - end_time) > 1)[0][0]
+end_plot_index_meas = np.where((trq_meas_time - time_20_sec - end_time) > 1)[0][0]
+
+trq_des_time = trq_des_time[start_plot_index_des:end_plot_index_des] - trq_des_time[start_plot_index_des]
+trq_des = trq_des[start_plot_index_des:end_plot_index_des]
+trq_meas_time = trq_meas_time[start_plot_index_meas:end_plot_index_meas] - trq_meas_time[start_plot_index_meas]
+trq_meas = trq_meas[start_plot_index_meas:end_plot_index_meas]
+
+
+# Measured joints
+measured_joint_list = data_ergocubsn000["joints_state"]["torques"]["elements_names"]
+
+# Plot torque tracking for each joint in the list of controlled joints
+controlled_joints = data_ergocubsn000["balancing"]["joint_state"]["torque"]["desired"]["elements_names"]
+
+# Find indeces of joints contained in controlled_joints and reorder and leave only those joints in measured_joint_list
+indeces_to_remove = []
+for joint in measured_joint_list:
+    if joint not in controlled_joints:
+        indeces_to_remove.append(measured_joint_list.index(joint))
+trq_meas = np.delete(trq_meas, indeces_to_remove, axis=1)
+measured_joint_list = np.delete(measured_joint_list, indeces_to_remove)
+print(trq_meas.shape)
+print(measured_joint_list)
+print(controlled_joints)
+
+
+################### PLOT ALL JOINTS #####################
+
+
+fig, axes = plt.subplots(6, 3, figsize=(23,12), sharex=True)  # Share x-axis
+fig.suptitle("UKF-PINN", fontsize=24, fontweight='bold')
+for i, ax in enumerate(axes.ravel()):
+
+    if i >= len(controlled_joints):
+        # Delete the last subplot
+        fig
+        ax.remove()
+        # add legend here
+        axes[-1, -2].legend(loc='lower right', bbox_to_anchor=(1.5, 0), fontsize=24)
+        break
+    print("Plotting joint and axis", i)
+    ax.plot(trq_des_time, trq_des[:,i], label="Desired", color=colors[0], linewidth=2)
+    ax.plot(trq_meas_time, trq_meas[:,i], label="Measured", color=colors[1], linewidth=2)
+    ax.tick_params(axis='both', labelsize=18)
+    if i % 3 == 0:
+        ax.set_ylabel(f"$\\tau$ (Nm)", fontsize=24)
+
+    if i >= len(controlled_joints)-4:
+        ax.set_xlabel("Time (s)", fontsize=24)
+
+    ax.set_title(controlled_joints[i], fontsize=24)
+
+plt.tight_layout()
+plt.subplots_adjust(wspace=0.1)
+
+
+if not os.path.exists("../figures_for_paper"):
+    os.makedirs("../figures_for_paper")
+plt.savefig("../figures_for_paper/trq_tracking_on_object_momentum_metal.pdf")
+plt.close()
+
+
+controlled_joints_half = controlled_joints[:8]
+
+fig, axes = plt.subplots(3, 3, figsize=(23,8), sharex=True)  # Share x-axis
+# fig.suptitle("", fontsize=24, fontweight='bold')
+for i, ax in enumerate(axes.ravel()):
+
+    if i >= len(controlled_joints_half):
+        # Delete the last subplot
+        fig
+        ax.remove()
+        # add legend here
+        axes[-1, -2].legend(loc='lower right', bbox_to_anchor=(1.5, 0), fontsize=24)
+        break
+    print("Plotting joint and axis", i)
+    ax.plot(trq_des_time, trq_des[:,i], label="Desired", color=colors[0], linewidth=2)
+    ax.plot(trq_meas_time, trq_meas[:,i], label="Measured", color=colors[1], linewidth=2)
+    ax.tick_params(axis='both', labelsize=18)
+    if i == 0 or i == 3 or i == 6 or i == 9 or i == 12:
+        ax.set_ylabel(f"$\\tau$ (Nm)", fontsize=24)
+
+    if i >= 6:
+        ax.set_xlabel("Time (s)", fontsize=24)
+
+    ax.set_title(controlled_joints_half[i], fontsize=24)
+
+# axes[-1, -1].legend(loc='lower right', bbox_to_anchor=(1.1, -0.35), fontsize=24)
+plt.tight_layout()
+plt.subplots_adjust(wspace=0.1)
+
+
+if not os.path.exists("../figures_for_paper"):
+    os.makedirs("../figures_for_paper")
+plt.savefig("../figures_for_paper/trq_tracking_on_object_momentum_metal_half_joints_oriz.pdf")
+plt.close()

FirstSubmission/PaperRAL_ScriptAndVideo/script/plot_resubmission_object_position.py

@@ -0,0 +1,237 @@
+import sys
+import os
+import numpy as np
+import matplotlib.pyplot as plt
+
+# Path to the other repository
+other_repo_path = "../../../element_sensorless-torque-control/code/python/utilities/general_scripts"
+
+# Add the path to sys.path
+sys.path.append(other_repo_path)
+
+from load_robot_logger_device_data import load_data
+
+data_ergocubsn000 = load_data("../../PaperRALDatasetUsedForResultsAndVideos/balancing_on_book_lateral/position/robot_logger_device_2025_03_13_15_02_57.mat")
+# data_ergocubsn000 = load_data("../../PaperRALDatasetUsedForResultsAndVideos/balancing_on_metal/position/robot_logger_device_2025_03_13_14_36_32.mat")
+
+index_shifting = 5
+
+com_des = data_ergocubsn000["balancingposition"]["com"]["planned"]["position"]["data"]
+com_meas = data_ergocubsn000["balancingposition"]["com"]["measured"]["with_joint_measured"]["data"]
+com_time = data_ergocubsn000["balancingposition"]["com"]["planned"]["position"]["timestamps"]
+
+com_des = com_des[:len(com_des)-index_shifting]
+com_meas = com_meas[index_shifting:]
+
+pos_des = data_ergocubsn000["balancingposition"]["joints"]["desired"]["position"]["data"]
+pos_des_time = data_ergocubsn000["balancingposition"]["joints"]["desired"]["position"]["timestamps"]
+pos_meas = data_ergocubsn000["joints_state"]["positions"]["data"]
+pos_meas_time = data_ergocubsn000["joints_state"]["positions"]["timestamps"]
+trq_meas = data_ergocubsn000["joints_state"]["torques"]["data"]
+trq_meas_time = data_ergocubsn000["joints_state"]["torques"]["timestamps"]
+
+pos_des = pos_des[:len(pos_des)-index_shifting]
+pos_des_time = pos_des_time[:len(pos_des_time)-index_shifting]
+pos_meas = pos_meas[index_shifting:]
+pos_meas_time = pos_meas_time[index_shifting:]
+
+trq_meas = trq_meas[index_shifting:]
+trq_meas_time = trq_meas_time[index_shifting:]
+
+# Find first timestamp of pos_des_time in pos_meas_time and align signals
+index_align_start = np.where(pos_meas_time == pos_des_time[0])[0][0]
+pos_meas = pos_meas[index_align_start:]
+pos_meas_time = pos_meas_time[index_align_start:]
+
+trq_meas = trq_meas[index_align_start:]
+trq_meas_time = trq_meas_time[index_align_start:]
+
+# Find last timestamp of pos_des_time in pos_meas_time and align signals
+index_align_end = np.where(pos_meas_time == pos_des_time[-1])[0][0]
+pos_meas = pos_meas[:index_align_end]
+pos_meas_time = pos_meas_time[:index_align_end]
+
+trq_meas = trq_meas[:index_align_end]
+trq_meas_time = trq_meas_time[:index_align_end]
+
+com_time = com_time - com_time[0]
+com_time = com_time[:len(com_time)-index_shifting]
+
+pos_des_time = pos_des_time - pos_des_time[0]
+pos_meas_time = pos_meas_time - pos_meas_time[0]
+
+trq_meas_time = trq_meas_time - trq_meas_time[0]
+
+# Convert com in mm
+com_des = com_des * 1000
+com_meas = com_meas * 1000
+
+colors = ["#E63946", "#457B9D"]  # Pinkish-red for desired, blue for measured
+
+# Plot from 0 to 100 seconds, discarding the first 50 seconds
+time_20_sec = 25
+end_time = 30
+first_index_plot = np.where((com_time - time_20_sec) > 1)[0][0]
+end_index_time = np.where((com_time - time_20_sec - end_time) > 1)[0][0]
+
+com_time = pos_meas_time[first_index_plot:end_index_time] - pos_meas_time[first_index_plot]
+com_des = com_des[first_index_plot:end_index_time]
+com_meas = com_meas[first_index_plot:end_index_time]
+
+# Fix size of figure
+delta_axis = 30
+plt.figure(figsize=(11,6))
+plt.subplot(3,1,1)
+plt.plot(com_time, com_des[:,0], label="Desired", color=colors[0], linewidth=2)
+plt.plot(com_time, com_meas[:,0], label="Measured", color=colors[1], linewidth=2)
+plt.legend()
+plt.ylabel("CoM X (mm)", fontsize=14)
+plt.ylim(np.mean(com_meas[:,0]) - delta_axis, np.mean(com_meas[:,0]) + delta_axis)
+plt.subplot(3,1,2)
+plt.plot(com_time, com_des[:,1], label="Desired", color=colors[0], linewidth=2)
+plt.plot(com_time, com_meas[:,1], label="Measured", color=colors[1], linewidth=2)
+plt.legend()
+plt.ylabel("CoM Y (mm)", fontsize=14)
+plt.subplot(3,1,3)
+plt.plot(com_time, com_des[:,2], label="Desired", color=colors[0], linewidth=2)
+plt.plot(com_time, com_meas[:,2], label="Measured", color=colors[1], linewidth=2)
+plt.legend()
+plt.ylabel("CoM Z (mm)", fontsize=14)
+plt.ylim(np.mean(com_des[:,2]) - delta_axis, np.mean(com_des[:,2]) + delta_axis)
+xlabel = "Time (s)"
+plt.xlabel(xlabel, fontsize=14)
+plt.xticks(fontsize=16)
+plt.yticks(fontsize=16)
+plt.tight_layout()
+
+# Save figure in pdf in folder figures_for_paper and create it if it does not exist
+if not os.path.exists("../figures_for_paper"):
+    os.makedirs("../figures_for_paper")
+plt.savefig("../figures_for_paper/com_tracking_on_object_position.pdf")
+plt.close()
+
+# Plot torque tracking for each joint in the list of controlled joints
+controlled_joints = data_ergocubsn000["balancingposition"]["joints"]["desired"]["position"]["elements_names"]
+
+# Find index of joint names r_shoulder_yaw, r_elbow, l_shoulder_yaw, l_elbow and remove from data pos_des_time and pos_meas_time
+index_r_shoulder_pitch = controlled_joints.index("r_shoulder_pitch")
+index_r_shoulder_roll = controlled_joints.index("r_shoulder_roll")
+index_l_shoulder_pitch = controlled_joints.index("l_shoulder_pitch")
+index_l_shoulder_roll = controlled_joints.index("l_shoulder_roll")
+# Remove the joints from the dataset
+pos_des = np.delete(pos_des, [index_r_shoulder_pitch, index_r_shoulder_roll, index_l_shoulder_pitch, index_l_shoulder_roll], axis=1)
+controlled_joints = np.delete(controlled_joints, [index_r_shoulder_pitch, index_r_shoulder_roll, index_l_shoulder_pitch, index_l_shoulder_roll])
+print(controlled_joints)
+
+# Measured joints
+measured_joint_list = data_ergocubsn000["joints_state"]["torques"]["elements_names"]
+# Find indeces of joints contained in controlled_joints and remove from measured_joint_list and from pos_meas all the others
+indeces_to_remove = []
+for joint in measured_joint_list:
+    if joint not in controlled_joints:
+        indeces_to_remove.append(measured_joint_list.index(joint))
+pos_meas = np.delete(pos_meas, indeces_to_remove, axis=1)
+trq_meas = np.delete(trq_meas, indeces_to_remove, axis=1)
+measured_joint_list = np.delete(measured_joint_list, indeces_to_remove)
+print(pos_meas.shape)
+print(measured_joint_list)
+
+# Crete number of subplots based on number of controlled joints
+n_subplots = len(controlled_joints)
+
+
+# Find time index where time is about 20 seconds
+start_plot_index_des = np.where((pos_des_time - time_20_sec) > 1)[0][0]
+start_plot_index_meas = np.where((pos_meas_time - time_20_sec) > 1)[0][0]
+end_plot_index_des = np.where((pos_des_time - time_20_sec - end_time) > 1)[0][0]
+end_plot_index_meas = np.where((pos_meas_time - time_20_sec - end_time) > 1)[0][0]
+
+pos_des_time = pos_des_time[start_plot_index_des:end_plot_index_des] - pos_des_time[start_plot_index_des]
+pos_des = pos_des[start_plot_index_des:end_plot_index_des]
+pos_meas_time = pos_meas_time[start_plot_index_meas:end_plot_index_meas] - pos_meas_time[start_plot_index_meas]
+pos_meas = pos_meas[start_plot_index_meas:end_plot_index_meas]
+
+trq_meas_time = trq_meas_time[start_plot_index_meas:end_plot_index_meas] - trq_meas_time[start_plot_index_meas]
+trq_meas = trq_meas[start_plot_index_meas:end_plot_index_meas]
+
+plt.figure(figsize=(18,10))
+for i, joint in enumerate(controlled_joints):
+    plt.subplot(5,3,i+1)
+    plt.plot(pos_des_time, pos_des[:,i], label="Desired", color=colors[0], linewidth=2)
+    plt.plot(pos_meas_time, pos_meas[:,i], label="Measured", color=colors[1], linewidth=2)
+    if i == 0 or i == 3 or i == 6 or i == 9 or i == 12:
+        plt.ylabel(f"Position (rad)", fontsize=14)
+    plt.title(joint, fontsize=14)
+    if i >= 11:
+        xlabel = "Time (s)"
+        plt.xlabel(xlabel, fontsize=14)
+plt.legend(loc='center left', bbox_to_anchor=(1, 0.5), fontsize=14)
+plt.xticks(fontsize=16)
+plt.yticks(fontsize=16)
+plt.tight_layout()
+plt.tight_layout()
+plt.subplots_adjust(wspace=0.1)
+# plt.show()
+
+if not os.path.exists("../figures_for_paper"):
+    os.makedirs("../figures_for_paper")
+plt.savefig("../figures_for_paper/pos_tracking_on_object_position.pdf")
+plt.close()
+
+# Plot measured torques for each joint in the list of controlled joints
+plt.figure(figsize=(18,10))
+for i, joint in enumerate(controlled_joints):
+    plt.subplot(5,3,i+1)
+    plt.plot(trq_meas_time, trq_meas[:,i], label="Measured", color=colors[1], linewidth=2)
+    if i == 0 or i == 3 or i == 6 or i == 9 or i == 12:
+        plt.ylabel(f"Torque (Nm)", fontsize=14)
+    plt.title(joint, fontsize=14)
+    if i >= 11:
+        xlabel = "Time (s)"
+        plt.xlabel(xlabel, fontsize=14)
+plt.legend(loc='center left', bbox_to_anchor=(1, 0.5), fontsize=14)
+plt.xticks(fontsize=16)
+plt.yticks(fontsize=16)
+plt.tight_layout()
+plt.tight_layout()
+plt.subplots_adjust(wspace=0.1)
+# plt.show()
+
+if not os.path.exists("../figures_for_paper"):
+    os.makedirs("../figures_for_paper")
+plt.savefig("../figures_for_paper/trq_on_object_position.pdf")
+plt.close()
+
+
+
+controlled_joints_half = controlled_joints[:8]
+
+fig, axes = plt.subplots(3, 3, figsize=(23,8), sharex=True)  # Share x-axis
+for i, ax in enumerate(axes.ravel()):
+
+    if i >= len(controlled_joints_half):
+        # Delete the last subplot
+        fig
+        ax.remove()
+        # add legend here
+        axes[-1, -2].legend(loc='lower right', bbox_to_anchor=(1.5, 0), fontsize=24)
+        break
+    print("Plotting joint and axis", i)
+    ax.plot(trq_meas_time, trq_meas[:,i], label="Measured", color=colors[1], linewidth=2)
+    ax.tick_params(axis='both', labelsize=18)
+    if i == 0 or i == 3 or i == 6 or i == 9 or i == 12:
+        ax.set_ylabel(f"$\\tau$ (Nm)", fontsize=24)
+
+    if i >= 6:
+        ax.set_xlabel("Time (s)", fontsize=24)
+
+    ax.set_title(controlled_joints_half[i], fontsize=24)
+
+plt.tight_layout()
+plt.subplots_adjust(wspace=0.1)
+
+
+if not os.path.exists("../figures_for_paper"):
+    os.makedirs("../figures_for_paper")
+plt.savefig("../figures_for_paper/trq_on_object_position_half_joints_oriz.pdf")
+plt.close()

FirstSubmission/PaperRAL_ScriptAndVideo/script/run_all.py

@@ -0,0 +1,23 @@
+# This script runs all the scripts in the project
+#
+# The script is useful to run all the scripts in the project
+# and check if all the scripts are working properly
+#
+
+import os
+import sys
+
+
+# List of scripts to run
+scripts = [
+    "plot_resubmission_ground_ergocubsn000.py",
+    "plot_resubmission_ground_ergocubsn001.py",
+    "plot_resubmission_ground_RNEA.py",
+    "plot_resubmission_object_momentum_0.py",
+    "plot_resubmission_object_position.py"
+    ]
+
+# Run all the scripts
+for script in scripts:
+    os.system("python " + script)
+    print("Script " + script + " executed successfully")

FirstSubmission/PaperRAL_ScriptAndVideo/ukfpinn_sn000_sn001_camera_high_res.MP4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6c8d801ef55b016f03fb26678c0dd797ba0cc3edea25a012cb6d5bb60686bfe1
+size 966459031

FirstSubmission/PaperRAL_ScriptAndVideo/ukfpinn_sn000_sn001_camera_low_res.MP4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b5abff4062c6a22f9679adce3e21d77abe48739f62f09bf166fa5bb3365cbbb4
+size 2056167433