._dot .dot ._d changed to .d

Author: solangegbv

examples/benchmark_planar_pcs.py

@@ -52,8 +52,8 @@ def factory_fn(
     jacobian_end_effector_fn = jit(partial(jacobian_end_effector_fn, params))
 
     def residual_fn(q: Array, phi: Array) -> Array:
-        q_d = jnp.zeros_like(q)
-        _, _, G, K, _, alpha = dynamical_matrices_fn(q, q_d, phi=phi)
+        qd = jnp.zeros_like(q)
+        _, _, G, K, _, alpha = dynamical_matrices_fn(q, qd, phi=phi)
         res = alpha - G - K
         return jnp.square(res).mean()
 

examples/demo_planar_hsa_motor2ee_jacobian.py

@@ -191,7 +191,7 @@ def update_plot(frame_idx):
     # Solver
     solver = Tsit5()  # Runge-Kutta 5(4) method
 
-    ts, q_ts, q_d_ts = robot.resolve_upon_time(
+    ts, q_ts, qd_ts = robot.resolve_upon_time(
         q0=q0,
         qd0=qd0,
         actuation_args=actuation_args,
@@ -239,7 +239,7 @@ def update_plot(frame_idx):
     # Energy computation upon time
     # =====================================================
     U_ts = jax.vmap(jax.jit(partial(robot.potential_energy)))(q_ts)
-    T_ts = jax.vmap(jax.jit(partial(robot.kinetic_energy)))(q_ts, q_d_ts)
+    T_ts = jax.vmap(jax.jit(partial(robot.kinetic_energy)))(q_ts, qd_ts)
 
     plt.figure()
     plt.plot(ts, U_ts, label="Potential Energy")

examples/simulate_planar_pcs.py

@@ -148,7 +148,7 @@ def draw_robot(
     # the evolution of the generalized coordinates
     q_ts = sol.ys[:, :n_q]
     # the evolution of the generalized velocities
-    q_d_ts = sol.ys[:, n_q:]
+    qd_ts = sol.ys[:, n_q:]
 
     # evaluate the forward kinematics along the trajectory
     chi_ee_ts = vmap(forward_kinematics_fn, in_axes=(None, 0, None))(
@@ -213,7 +213,7 @@ def draw_robot(
         partial(auxiliary_fns["potential_energy_fn"], params)
     )
     U_ts = potential_energy_fn_vmapped(q_ts)
-    T_ts = kinetic_energy_fn_vmapped(q_ts, q_d_ts)
+    T_ts = kinetic_energy_fn_vmapped(q_ts, qd_ts)
     plt.figure()
     plt.plot(video_ts, U_ts, label="Potential energy")
     plt.plot(video_ts, T_ts, label="Kinetic energy")

examples/simulate_tendon_actuated_planar_pcs.py

@@ -8,12 +8,12 @@ def ode_factory(
     dynamical_matrices_fn: Callable, params: Dict[str, Array], tau: Array
 ) -> Callable[[float, Array], Array]:
     """
-    Make an ODE function of the form ode_fn(t, x) -> x_dot.
+    Make an ODE function of the form ode_fn(t, x) -> xd.
     This function assumes a constant torque input (i.e. zero-order hold).
     Args:
         dynamical_matrices_fn: Callable that returns the B, C, G, K, D, and A matrices. Needs to conform to the signature:
-            dynamical_matrices_fn(params, q, q_d) -> Tuple[B, C, G, K, D, A]
-            where q and q_d are the configuration and velocity vectors, respectively,
+            dynamical_matrices_fn(params, q, qd) -> Tuple[B, C, G, K, D, A]
+            where q and qd are the configuration and velocity vectors, respectively,
             B is the inertia matrix of shape (n_q, n_q),
             C is the Coriolis matrix of shape (n_q, n_q),
             G is the gravity vector of shape (n_q, ),
@@ -23,7 +23,7 @@ def ode_factory(
         params: Dictionary with robot parameters
         tau: torque vector of shape (n_tau, )
     Returns:
-        ode_fn: ODE function of the form ode_fn(t, x) -> x_dot
+        ode_fn: ODE function of the form ode_fn(t, x) -> xd
     """
 
     def ode_fn(t: float, x: Array, *args) -> Array:
@@ -34,15 +34,15 @@ def ode_fn(t: float, x: Array, *args) -> Array:
             x: state vector of shape (2 * n_q, )
             args: additional arguments
         Returns:
-            x_d: time-derivative of the state vector of shape (2 * n_q, )
+            xd: time-derivative of the state vector of shape (2 * n_q, )
         """
-        x_d = euler_lagrangian.nonlinear_state_space(
+        xd = euler_lagrangian.nonlinear_state_space(
             dynamical_matrices_fn,
             params,
             x,
             tau,
         )
-        return x_d
+        return xd
 
     return ode_fn
 
@@ -51,12 +51,12 @@ def ode_with_forcing_factory(
     dynamical_matrices_fn: Callable, params: Dict[str, Array]
 ) -> Callable[[float, Array], Array]:
     """
-    Make an ODE function of the form ode_fn(t, x) -> x_dot.
+    Make an ODE function of the form ode_fn(t, x) -> xd.
     This function assumes a constant torque input (i.e. zero-order hold).
     Args:
         dynamical_matrices_fn: Callable that returns the B, C, G, K, D, and A matrices. Needs to conform to the signature:
-            dynamical_matrices_fn(params, q, q_d) -> Tuple[B, C, G, K, D, A]
-            where q and q_d are the configuration and velocity vectors, respectively,
+            dynamical_matrices_fn(params, q, qd) -> Tuple[B, C, G, K, D, A]
+            where q and qd are the configuration and velocity vectors, respectively,
             B is the inertia matrix of shape (n_q, n_q),
             C is the Coriolis matrix of shape (n_q, n_q),
             G is the gravity vector of shape (n_q, ),
@@ -65,7 +65,7 @@ def ode_with_forcing_factory(
             A is the actuation matrix of shape (n_q, n_tau).
         params: Dictionary with robot parameters
     Returns:
-        ode_fn: ODE function of the form ode_fn(t, x, tau) -> x_dot
+        ode_fn: ODE function of the form ode_fn(t, x, tau) -> xd
     """
 
     def ode_fn(
@@ -80,14 +80,14 @@ def ode_fn(
             x: state vector of shape (2 * n_q, )
             tau: external torque vector of shape (n_tau, )
         Returns:
-            x_d: time-derivative of the state vector of shape (2 * n_q, )
+            xd: time-derivative of the state vector of shape (2 * n_q, )
         """
-        x_d = euler_lagrangian.nonlinear_state_space(
+        xd = euler_lagrangian.nonlinear_state_space(
             dynamical_matrices_fn,
             params,
             x,
             tau,
         )
-        return x_d
+        return xd
 
     return ode_fn

src/jsrm/integration.py

@@ -31,7 +31,7 @@ def symbolically_derive_pendulum_model(
 
     # configuration variables and their derivatives
     q_syms = list(sp.symbols(f"q1:{num_links + 1}"))  # joint angle
-    q_d_syms = list(sp.symbols(f"q_d1:{num_links + 1}"))  # joint velocity
+    qd_syms = list(sp.symbols(f"qd1:{num_links + 1}"))  # joint velocity
 
     # construct the symbolic matrices
     m = sp.Matrix(m_syms)  # mass of each link
@@ -42,7 +42,7 @@ def symbolically_derive_pendulum_model(
 
     # configuration variables and their derivatives
     q = sp.Matrix(q_syms)  # joint angle
-    q_d = sp.Matrix(q_d_syms)  # joint velocity
+    qd = sp.Matrix(qd_syms)  # joint velocity
 
     # matrix with tip of link and center of mass positions
     chi_ls, chic_ls = [], []
@@ -113,7 +113,7 @@ def symbolically_derive_pendulum_model(
     B = sp.simplify(B)
     print("B =\n", B)
 
-    C = compute_coriolis_matrix(B, q, q_d)
+    C = compute_coriolis_matrix(B, q, qd)
     print("C =\n", C)
 
     # compute the gravity force vector
@@ -131,7 +131,7 @@ def symbolically_derive_pendulum_model(
         },
         "state_syms": {
             "q": q_syms,
-            "q_d": q_d_syms,
+            "qd": qd_syms,
         },
         "exps": {
             "chi_ls": chi_ls,  # matrix with tip poses of shape (3, n_q)

src/jsrm/symbolic_derivation/pendulum.py

@@ -134,8 +134,8 @@ def symbolically_derive_planar_hsa_model(
 
     # planar strains and their derivatives
     xi_syms = list(sp.symbols(f"xi1:{num_dof + 1}", nonzero=True))  # strains
-    xi_d_syms = list(sp.symbols(f"xi_d1:{num_dof + 1}"))  # strain time derivatives
-    xi_dd_syms = list(sp.symbols(f"xi_dd1:{num_dof + 1}"))  # strain accelerations
+    xid_syms = list(sp.symbols(f"xid1:{num_dof + 1}"))  # strain time derivatives
+    xidd_syms = list(sp.symbols(f"xidd1:{num_dof + 1}"))  # strain accelerations
     phi_syms = list(
         sp.symbols(f"phi1:{num_segments * num_rods_per_segment + 1}")
     )  # twist angles
@@ -198,8 +198,8 @@ def symbolically_derive_planar_hsa_model(
 
     # configuration variables and their derivatives
     xi = sp.Matrix(xi_syms)  # strains
-    xi_d = sp.Matrix(xi_d_syms)  # strain time derivatives
-    xi_dd = sp.Matrix(xi_dd_syms)  # strain accelerations
+    xid = sp.Matrix(xid_syms)  # strain time derivatives
+    xidd = sp.Matrix(xidd_syms)  # strain accelerations
     # twist angle of rods
     phi = sp.Matrix(phi_syms)
 
@@ -493,8 +493,8 @@ def symbolically_derive_planar_hsa_model(
     print("chiee =\n", chiee)
     Jee = chiee.jacobian(xi)  # Jacobian of the end-effector
     print("Jee =\n", Jee)
-    Jee_d = compute_dAdt(Jee, xi, xi_d)  # time derivative of the end-effector Jacobian
-    print("Jee_d =\n", Jee_d)
+    Jeed = compute_dAdt(Jee, xi, xid)  # time derivative of the end-effector Jacobian
+    print("Jeed =\n", Jeed)
 
     # add contribution of the payload mass
     # the center of gravity of the payload mass should be specified relative to the end effector position
@@ -515,7 +515,7 @@ def symbolically_derive_planar_hsa_model(
         B = sp.simplify(B)
     print("B =\n", B)
 
-    C = compute_coriolis_matrix(B, xi, xi_d, simplify=simplify)
+    C = compute_coriolis_matrix(B, xi, xid, simplify=simplify)
     print("C =\n", C)
 
     # compute the gravity force vector
@@ -569,8 +569,8 @@ def symbolically_derive_planar_hsa_model(
         },
         "state_syms": {
             "xi": xi_syms,
-            "xi_d": xi_d_syms,
-            "xi_dd": xi_dd_syms,
+            "xid": xid_syms,
+            "xidd": xidd_syms,
             "phi": phi_syms,
             "s": s,
         },
@@ -587,7 +587,7 @@ def symbolically_derive_planar_hsa_model(
             "Jr_sms": Jr_sms,  # list of the Jacobians of the centerline of each rod
             "Jp_sms": Jp_sms,  # list of the platform Jacobians
             "Jee": Jee,  # Jacobian of the end-effector
-            "Jee_d": Jee_d,  # time derivative of the Jacobian of the end-effector
+            "Jeed": Jeed,  # time derivative of the Jacobian of the end-effector
             "B": B,
             "C": C,
             "G": G,

src/jsrm/symbolic_derivation/planar_hsa.py

@@ -44,7 +44,7 @@ def symbolically_derive_planar_pcs_model(
 
     # planar strains and their derivatives
     xi_syms = list(sp.symbols(f"xi1:{num_dof + 1}", nonzero=True))  # strains
-    xi_d_syms = list(sp.symbols(f"xi_d1:{num_dof + 1}"))  # strain time derivatives
+    xid_syms = list(sp.symbols(f"xid1:{num_dof + 1}"))  # strain time derivatives
 
     # construct the symbolic matrices
     rho = sp.Matrix(rho_syms)  # volumetric mass density [kg/m^3]
@@ -54,12 +54,12 @@ def symbolically_derive_planar_pcs_model(
 
     # configuration variables and their derivatives
     xi = sp.Matrix(xi_syms)  # strains
-    xi_d = sp.Matrix(xi_d_syms)  # strain time derivatives
+    xid = sp.Matrix(xid_syms)  # strain time derivatives
 
     # matrix with symbolic expressions to derive the poses along each segment
     chi_sms = []
     # Jacobians (positional + orientation) in each segment as a function of the point coordinate s and its time derivative
-    J_sms, J_d_sms = [], []
+    J_sms, Jd_sms = [], []
     # tendon lengths for each segment as a function of the point coordinate s
     L_tend_sms = []
     # tendon length jacobians for each segment as a function of the point coordinate s
@@ -127,8 +127,8 @@ def symbolically_derive_planar_pcs_model(
         J_sms.append(J)
 
         # compute the time derivative of the Jacobian
-        J_d = compute_dAdt(J, xi, xi_d)  # time derivative of the end-effector Jacobian
-        J_d_sms.append(J_d)
+        Jd = compute_dAdt(J, xi, xid)  # time derivative of the end-effector Jacobian
+        Jd_sms.append(Jd)
 
         # derivative of mass matrix with respect to the point coordinate s
         dB_ds = rho[i] * A[i] * Jp.T @ Jp + rho[i] * I[i] * Jo.T @ Jo
@@ -175,7 +175,7 @@ def symbolically_derive_planar_pcs_model(
         B = sp.simplify(B)
     print("B =\n", B)
 
-    C = compute_coriolis_matrix(B, xi, xi_d, simplify=simplify_expressions)
+    C = compute_coriolis_matrix(B, xi, xid, simplify=simplify_expressions)
     print("C =\n", C)
 
     # compute the gravity force vector
@@ -195,7 +195,7 @@ def symbolically_derive_planar_pcs_model(
         },
         "state_syms": {
             "xi": xi_syms,
-            "xi_d": xi_d_syms,
+            "xid": xid_syms,
             "s": s,
         },
         "exps": {
@@ -207,8 +207,8 @@ def symbolically_derive_planar_pcs_model(
             "Jee": J_sms[-1].subs(
                 s, l[-1]
             ),  # end-effector Jacobian of shape (3, num_dof)
-            "J_d_sms": J_d_sms,  # list of time derivatives of Jacobians (for each segment)
-            "Jee_d": J_d_sms[-1].subs(
+            "Jd_sms": Jd_sms,  # list of time derivatives of Jacobians (for each segment)
+            "Jeed": Jd_sms[-1].subs(
                 s, l[-1]
             ),  # time derivative of end-effector Jacobian of shape (3, num_dof)
             "B": B,  # mass matrix

src/jsrm/symbolic_derivation/planar_pcs.py

@@ -2,14 +2,14 @@
 
 
 def compute_coriolis_matrix(
-    B: sp.Matrix, q: sp.Matrix, q_d: sp.Matrix, simplify: bool = True
+    B: sp.Matrix, q: sp.Matrix, qd: sp.Matrix, simplify: bool = True
 ) -> sp.Matrix:
     """
-    Compute the matrix C(q, q_d) containing the coriolis and centrifugal terms using Christoffel symbols.
+    Compute the matrix C(q, qd) containing the coriolis and centrifugal terms using Christoffel symbols.
     Args:
         B: mass / inertial matrix of shape (num_dof, num_dof)
         q: vector of generalized coordinates of shape (num_dof,)
-        q_d: vector of generalized velocities of shape (num_dof,)
+        qd: vector of generalized velocities of shape (num_dof,)
         simplify: whether to simplify the result
     Returns:
         C: matrix of shape (num_dof, num_dof) containing the coriolis and centrifugal terms
@@ -36,18 +36,18 @@ def compute_coriolis_matrix(
     for i in range(num_dof):
         for j in range(num_dof):
             for k in range(num_dof):
-                C[i, j] = C[i, j] + Ch[i, j, k] * q_d[k]
+                C[i, j] = C[i, j] + Ch[i, j, k] * qd[k]
     if simplify:
         # simplify coriolis and centrifugal force matrix
         C = sp.simplify(C)
 
     return C
 
 
-def compute_dAdt(A: sp.Matrix, x: sp.Matrix, xdot: sp.Matrix) -> sp.Matrix:
+def compute_dAdt(A: sp.Matrix, x: sp.Matrix, xd: sp.Matrix) -> sp.Matrix:
     dAdt = sp.zeros(A.shape[0], A.shape[1])
     for j in range(A.shape[1]):
         # iterate through columns
-        dAdt[:, j] = A[:, j].jacobian(x) @ xdot
+        dAdt[:, j] = A[:, j].jacobian(x) @ xd
 
     return dAdt