---
kind: concept
slug: multibody-dynamics
title: Multibody dynamics of closed-loop mechanisms
summary: >-
  Motion equations for parallel robots whose limbs contain closed kinematic loops. Each loop is solved locally, so the limb acts as a serial chain, and the robot gets one task-space model. Two author-reported variants: a screw/Lie-group model with a linearised loop map, and a numerical loop solver with Newton correction. Each is shown on one example, with no error figures.
tags: [dynamics, kinematics, parallel-manipulators, closed-kinematic-chain, lie-group, screw-theory]
papers: ["2412.13638", "2412.13681"]
related: [constraint-embedding, inverse-kinematics, inverse-dynamics-control]
status: draft
updated_at: 2026-10-25
---

## Overview

A multibody model writes the motion equations of linked rigid bodies. A
serial robot is a tree, so its equations are direct. A parallel manipulator
holds its tool with several limbs, and some limbs contain closed loops of
rods. Each loop adds constraints that must hold at every moment
[arxiv:2412.13638 §1]. The problem is how to write these equations without
simplifying the loops.

Both cards share one plan. Remove one cut-joint per loop, which leaves a
spanning tree. Solve the loop constraints locally, so the limb acts as a
serial chain in its independent coordinates. Then sum the limb terms into one
task-space equation of motion [arxiv:2412.13681 §3.1–3.3] [arxiv:2412.13638
§2, §3.4, eq. 39]. The two cards differ in how the loop constraints are
handled. One linearises them into a rate map [arxiv:2412.13681 §3.3.2]. The
other solves them numerically at each position, with a Newton correction
[arxiv:2412.13638 alg. 2].

Both cards are by the same author, were posted on the same day, and are draft
compilations. Each reports one robot example. Neither reports error norms.

## Variants

### Screw and Lie-group model with a linearised loop map

Bodies are described by product-of-exponentials poses along the tree, and
the joint rates of a limb are a linear map of its independent rates. For a
loop, the dependent rates follow from the independent ones through a block
split of the loop Jacobian, and the result is stacked into one matrix H
[arxiv:2412.13681 §3.3.2]. The limb terms are then projected with the
task-space Jacobian, and the platform follows the Newton-Euler equations
[arxiv:2412.13681 §6.4–6.5]. A limb that is structurally identical to another
is modelled once, in construction frames, and reused at each mount position
[arxiv:2412.13681 §7]. Each limb's contribution to the inverse dynamics depends only on that limb's
coordinates, so the limb terms can run on separate nodes [arxiv:2412.13681 §8.2].
The worked example is a Delta-type robot with three limbs, and it reports
2.74 µs for inverse kinematics plus inverse dynamics on one node
[arxiv:2412.13681 tab. 1]. Card: [Modular screw-theory model for parallel robots with complex limbs](/papers/2412.13681).

### Numerical loop solver with Newton correction (constraint embedding)

Each loop's constraints are solved numerically inside its limb, and the limb
then serves as a serial chain in the remaining variables [arxiv:2412.13638
§3.4]. The loop solver first moves the independent variables by a given
increment and takes one linearised step for the dependent ones. It then
applies Newton corrections until the loop residual is below a tolerance
[arxiv:2412.13638 alg. 2]. Limb inverse kinematics is an outer iteration on the task error, which calls
the loop solver at each step [arxiv:2412.13638 alg. 1]. A compound variant
performs one loop step per outer iteration. The card reports about the same
total cost as the nested form, and justifies the compound variant only for
regular loop constraints [arxiv:2412.13638 alg. 3, §6.4.1]. The limb equations are projected with the
same kind of H matrix, and a task-space model with actuator torques follows
[arxiv:2412.13638 eq. 36–45]. The worked example is a two-degree-of-freedom
IRSBot-2 limb. Its outer loop takes 1 to 3 iterations per step at a 1 ms
time step, and 3 almost always at 10 ms [arxiv:2412.13638 §6.4.1 fig. 11].
Card: [Numerical constraint-embedding model for hybrid-limb robots](/papers/2412.13638).

### Replacing a loop by an equivalent joint (not recommended)

A common shortcut replaces a loop with an equivalent joint, for example a
one-degree-of-freedom Π-joint for a parallelogram. The numerical card says
this is kinematically equivalent but hides internal singularities, and drops
the dynamics of the loop's members, so non-symmetric mass distributions and
joint reactions cannot be represented [arxiv:2412.13638 §1]. It is listed
here as the approach to avoid.

## When to use which

| Situation | Use | Why |
|---|---|---|
| Identical limbs, and per-limb evaluation on several processors | Screw and Lie-group model | Representative-limb reuse and separable limb terms [arxiv:2412.13681 §7, §8.2]. Timings are one PC, indicative only [arxiv:2412.13681 §9.4] |
| Long runs where positions must stay consistent | Numerical loop solver | The card warns that integrating velocity constraints lets position error grow, and prefers the position-level solve for feedforward torques [arxiv:2412.13638 §4.1.2 remark] |
| A loop with a known closed form, and a planar 4-bar | Hand-solved loop, numerical solver for the rest | The IRSBot-2 proximal loop is solved by hand, and only the distal loop uses the numerical solver [arxiv:2412.13638 §6.2] |
| Loop Jacobian near a singularity | Numerical loop solver, full Newton | Both cards need the loop Jacobian to be invertible. The compound scheme is not justified for irregular loops [arxiv:2412.13638 §4.1.2, §6.4.1] [arxiv:2412.13681 §3.3.2] |
| Platform that rotates | Floating-platform Newton-Euler model | The numerical-solver card treats the platform as a general floating body [arxiv:2412.13638 eq. 38]. The Delta example only translates, so its platform inertia is the mass alone [arxiv:2412.13681 §9.3] |
| Redundant loop constraints | Neither, as a recipe | Redundant constraints are claimed to be handled, without a rule for choosing rows [arxiv:2412.13638 §7] [arxiv:2412.13638 §3.3, alg. 2]. The screw model assumes edge-disjoint hybrid limbs [arxiv:2412.13681 §2] |
| Need a number for the speed of the method | Screw and Lie-group model | It is the only card with a timing. The numerical card reports iteration counts and no timings [arxiv:2412.13638 §6.4.1] |

## Implementation sketch

Language-agnostic core of one limb and the task-space model. The loop solver
is the variant-specific part: use the Newton loop from the numerical card, or
the linear H map from the screw card.

```pseudocode
# Common core of one closed-loop limb  [arxiv:2412.13681 §3.1–3.3]
# Shapes: n joints, delta independent coordinates per limb.

def limb_task_model(limb, theta, theta_dot):
    # Remove one cut-joint per fundamental cycle; the rest is a tree
    # [arxiv:2412.13638 §2]
    tree = spanning_tree(limb)
    # Loop constraints g(theta) = 0, one set per cut-joint
    # [arxiv:2412.13638 eq. 12]
    g = loop_constraints(limb, theta)
    # Split the loop Jacobian into dependent (square G_y) and independent G_q
    # [arxiv:2412.13638 eq. 16]
    G_y, G_q = split_jacobian(loop_jacobian(limb, theta))
    # Joint rates from independent rates: theta_dot = H q_dot
    # [arxiv:2412.13638 eq. 18]
    H = stack(-solve(G_y, G_q), identity(delta))
    # Forward-kinematics Jacobian of the limb, L_p = J_p H
    # [arxiv:2412.13638 eq. 22]
    L_p = J_p(limb, theta) @ H
    # Task-space IK map F = L_t^{-1}, square for non-redundant limbs
    # [arxiv:2412.13681 §4.1]
    F = inverse(L_t(limb, theta))
    # Task-space mass and Coriolis terms, summed over limbs and platform
    # [arxiv:2412.13638 eq. 40–41]
    M_t, C_t = assemble_task_space(limbs, platform, H, F)
    # Feedforward actuator forces; J_IK must be square and invertible
    # [arxiv:2412.13638 eq. 45]
    u = solve(J_IK.T, M_t @ V_dot + C_t @ V_t + W_grav + W - W_ee)
    return u
```

Notes for implementers:

- The loop residual correction is not in this sketch. The numerical card uses
  Newton steps until the residual is below ε [arxiv:2412.13638 alg. 2]. The
  screw card has none, and relies on the linear map [arxiv:2412.13681 §3.3.2].
- Choice of independent coordinates sets the conditioning of G_y and H, and
  the numerical card says it is not unique [arxiv:2412.13638 §3.4 remark].
- Cut-joint numbering in the screw card conflicts between its text and its
  figure captions, so check the graph before choosing the tree [arxiv:2412.13681 §3.1].
- The screw card states no tolerance or initial guess for its geometric
  inverse kinematics [arxiv:2412.13681 §4.4]. The numerical card's examples
  use ε = 1e-10 [arxiv:2412.13638 §6.4.1].
- Neither card releases code. The screw card's Mathematica model is no longer
  published, and the numerical card's MATLAB model is not released
  [arxiv:2412.13681 §9.1] [arxiv:2412.13638 §6.4].

## Contradictions

- Within [arxiv:2412.13681 §9.1], the text says a closed-form inverse
  kinematics is not used and an iterative solution is pursued. The same
  section uses a closed-form loop solution and a closed-form Jacobian.
- Validation against the same commercial multibody tool gives no comparable
  error figure. The screw card says the trajectories match "up to the
  prescribed accuracy" [arxiv:2412.13681 §9.4]. The numerical card says the
  results are validated, with no error metric [arxiv:2412.13638 §6.4].
- The two cards use different robots, a Delta-type robot with three limbs and
  a two-degree-of-freedom IRSBot-2 limb. Their timings and iteration counts
  cannot be compared.

## Papers

- [Numerical constraint-embedding model for hybrid-limb robots](/papers/2412.13638): numerical loop solver with Newton correction, nested and compound inverse kinematics, and a task-space model with feedforward torques.
- [Modular screw-theory model for parallel robots with complex limbs](/papers/2412.13681): modular screw and Lie-group model, linear loop map, representative-limb reuse, and separable limb terms for parallel evaluation.