RopeComb

A reeved tension member over a translating pin array — a continuously rising transmission ratio that accelerates a payload at near-constant force.

Why force uniformity is the figure of merit

A launcher is limited by the peak force its payload can survive, but it is paid in mean force. Every unit of peak-to-mean ratio is capability thrown away. The RopeComb exists to make that ratio small with passive hardware.

Peak / mean force, launch systems compared

System Layout & Operating Principle

Single-array RopeComb launcher, annotated
Dual-array RopeComb launcher, annotated

Single array. A falling source mass drives a carriage whose pins deflect a reeved rope into a row of fixed spans, accelerating the payload along the ramp at near-constant force. The whole carriage reaction is carried on one side of the guide.

Dual array. The same principle split about a central guide: the source mass in two halves, two banks, each with its own tension member dead-ended on the guide and driving its own moving block at the fixed-ratio stage. The overturning moment cancels, and each rope touches fewer elements on its way to the payload.

The target ratio profile

Impose uniform payload force F, conserve power, and the ratio the transmission must follow falls out as G*(d) = dy/dd:

G*(d) = √2Fy/m √v02 + 2gd − 2Fy/M
d
the source deceleration (breaking) distance.
y
the payload acceleration (launch) distance.
F
the force on the payload, uniform by design
M, m
source and payload mass
v0
speed of the source at the entry of the breaking phase.
g
gravity, so 2gd is the work it keeps adding as the source falls

The denominator is the source's remaining speed and the numerator is the payload's: as the source is braked and the payload gains, the required ratio climbs, steeply at the end.

The mechanism

A tension member is reeved alternately over engagement members on a translating carriage and fixed supports, so carriage motion folds it into successive spans. One member of half-width R at depth D contributes

dY dD = 2D √R2 + D2 = 2 √(R/D)2 + 1  →  2

So the ratio rises through the stroke, asymptoting to 2 per member. For an array with offsets si and a fixed second stage k:

G(d) = k · Σi=1N 2Di √Ri2 + Di2 ,   Di = max(0, d − si)

Closed form, no integration. Two independent freedoms per member — span width sets how fast a member contributes, offset sets when — and that pair is what lets an arbitrary rising profile be synthesised. Ceiling 2Nk.

Every member is concave; the target is convex

f ''(D) = − 6R2D (R2 + D2)5/2 < 0   for all   D > 0

Every member bends the wrong way. The array reaches a convex target only as a chain of concave arcs staggered by their onsets — which is why offsets matter as much as widths, and where the force ripple comes from.

One member, and the staggered sum of several.

Specify the deceleration, not the force

State how hard the source is to be braked, and solve for the force that produces it. Ask for more than the array can reach and the machine gets worse, not merely shorter.

The worked convention is 10 m/s to 4 m/s in 0.100 s, leaving the source 16% of its entry energy over a 0.854 m braking distance, independent of mass ratio. Design force then scales as F ∝ √Mm , and the ideal exit velocity is v0 · √Mm to within a per cent — energy transfer is near total.

4 m/s is a knee, not a derived optimum. Above it the tension member stays loaded throughout; below it traction is lost. Braking to 3.0 m/s buys about 3.3% of exit velocity but carries peak force past the 1.3× bound in every case.

Design by fitting, not by search

Both the array ratio and the target are functions of source displacement, so finding the geometry is a curve fit over 2N parameters:

min {Ri, si} ∫ dmax 0 ∣ k Garray(d) − G*(d) ∣2 dd

Plain squared residual — no weighting, no penalties, and no dynamic simulation inside the fit, which is what makes thousands of candidates affordable.

This matters because search does not work. Least squares beats 300,000 random samples by a factor of 7.7 on 150× fewer evaluations, and a structured grid over four intuitive parameters does worse than random sampling: the families a designer would naturally write down do not contain the optimum.

Compliance is required, not a refinement

That sawtooth runs at about twice the mean in every canonical design. A compliant, pre-tensioned output member absorbs the transients:

rigid compliant
100:1 2.05× 1.12×
1,000:1 2.07× 1.09×
10,000:1 2.10× 1.19×

Pre-tension does the work, not compliance alone: started slack, the same apparatus rings at roughly 2.3×. And compliance cannot be engineered away — working strain is of order 1% whatever the fibre.

Severity follows the discreteness of engagement — not the fit residual, and not the mass ratio.

Where the energy goes

Measured against the work needed to raise the source again — through the braking distance as well as the height that set its entry speed — the transmission delivers 86.3% to the payload.

η = ½(v02 − vf2) + g dmax ½v02 + g dmax = 86.3%

The source mass cancels: efficiency is fixed by entry speed, final speed and braking distance alone, and mass ratio cannot appear. The three simulated designs realise the analytic figure to within 0.4%.

Reality check

The largest omission is the rotational inertia of sheaves in the fast path, which acts exactly as added payload mass and costs a further 9 to 12% of exit velocity — more than any difference between the candidate geometries. Peak-to-mean force is a ratio and survives it; read the velocities as upper bounds.

The models are lossless and no apparatus has been built or measured. Every result here is theoretical or numerical, compared against steam and electromagnetic figures measured on fielded hardware.

The lateral load problem

Cards 09–12 build on doi.org/10.31224/8171 and a forthcoming paper on count-balanced arrays.

Everything above hangs off one side of the guide. The carriage reaction is about 23× the source weight — 228 kN at 1,000:1 — and every fold pushes along the guide, so what the bearings feel is its moment about the guide axis.

That moment cannot be trimmed away by placing the driving mass. Members engage in sequence along the array, so the centre of pressure sweeps outward from 0.25 m to 1.58 m through the stroke of the 2.42 m reference array, peaking at 360 kN m; any fixed offset leaves a moment that reverses sign mid-stroke.

Two bearings at spacing h react it as a couple, sliding at up to 10 m/s. With friction coefficient μ and reaction offset e, the guide loses a fraction

guide loss = 2μe / h

of the energy transferred, independent of mass ratio: at e/h = 0.5 a single array hands a fraction μ of its whole output to guide friction.

Two arrays, and why symmetry is not enough

Put an array on each side of a central guide. Each has its own tension member, dead-ended on the guide and driving its own counter-moving block at the stage, with the k output falls split between them. The net ratio is an exact weighted sum:

Gnet = n1G1 + n2G2,   n1 + n2 = k

Two lines already pay: each carries njF rather than kF, and ⌊k/2⌋ elements leave the busiest rope path. Making the arrays mirror images then puts the reaction on both sides of the guide.

But a counter-moving stage is naturally odd, k = 2p + 1, so the falls cannot split evenly, and identical arrays pull unequally by |n1−n2|/k — 20% at k = 5, 14% at 7, 11% at 9. That is a property of the reeving, not a tolerance.

And identical arrays sum to kG, the single array’s ratio, so the payload sees the same force. Mirror symmetry changes where the load goes, never what the payload feels.

Balance by ratio, and by count

Each array pushes on the carriage with its falls × line tension × own ratio, so the guide balances when those products meet:

G1 : G2 = n2T2 : n1T1

The array doing more work at the stage is the one made weaker. A fit can hold that through the middle of the stroke — but not at the end. Deep in the stroke every member saturates at 2, so Gj → 2Nj whatever the spans: the counts set the terminal balance, and equal counts drift straight back to the mirror residual. Hence the discrete condition:

n1N1 = n2N2   →   8 : 6 at k = 7

Two ordering rules go with it: the array serving fewer falls engages first, and its excess members engage last. The geometry comes from one fit with a balance weight:

min ‖ n1G1 + n2G2 − G* ‖2 + λ ‖ n1G1 − n2G2 ‖2

seeded from a single-array fit dealt alternately to the two sides, which already reproduces the net ratio. The counts carry the end of the stroke; the fit carries the middle.

What count balance delivers

At 1,000:1 and k = 7, the same fourteen members arranged four ways:

singlemirror7 : 78 : 6
peak/mean, compliant1.40×1.40×1.12×1.13×
peak/mean, rigid2.44×2.44×1.93×1.90×
reaction imbalanceone-sided14.3%8.1%2.3%
exit (m/s)321.0321.0318.7318.8

Moving one 10 cm member from the trailing array to the leading one cuts the imbalance from 19.1 to 5.4 kN on a 235 kN reaction — 97.7% of the one-sided load cancelled — with the force profile untouched. On the moment the bearings actually react, it removes 95% of the single array’s 360 kN m.

At k = 9 the floor counts 5 : 4 buy minimalism instead: nine members in arrays under 1.2 m, 93% cancelled, 1.45× compliant. Past the counts, further balance is bought with width — 3.3 m arrays reach 0.5% at 1.29×.

Per-contact friction is the large term the lossless figures leave out: at 2% per contact every design keeps only 72–87% of its payload energy, the count-balanced pair 77% against a matched single array’s 72%.

Simulated; no dual-array machine has been built.

Simulated Dynamics — the 1,000:1 design

Rigid-body dynamics, single array, 1,000:1
Rigid-body dynamics, both dual-array designs, 1,000:1

Single array, rigid. The canonical 1,000:1 design — 9 members in a 2.42 m array on an inextensible member. Dashed curves are the ideal uniform-force profile; solid curves are what the array actually does. Panel (f) is the sawtooth of discrete engagement, 2.07× the mean. No rigid configuration examined meets the 1.3× criterion at any member count.

Dual array, rigid. Both configured designs against the same ideal — ⟨7, 7⟩ at k = 7 and ⟨5, 9⟩ at k = 9. Panels (a) to (d) are nearly indistinguishable from the ideal and from each other. Panel (f) still shows one bounded tooth per engagement, peaking at 1.94× and 2.12× the design force — the ⟨5, 9⟩ teeth larger because five members must cover what seven cover at ⟨7, 7⟩.

Compliant pre-tensioned dynamics, single array, 1,000:1
Compliant pre-tensioned dynamics, both dual-array designs, 1,000:1

Single array, compliant. The same array with a compliant output member, pre-tensioned to the working load. The sawtooth becomes a smooth ripple between about 2.8 and 3.5 kN about the 3,170 N design force — 1.09× the mean — and because the member starts loaded, the payload sees the design force from the first instant rather than ramping up from zero.

Dual array, compliant. The same two designs on a compliant, pre-tensioned member at 16,471 N/m. Ripple about the design force holds to 1.12× at ⟨7, 7⟩ and 1.48× at ⟨5, 9⟩. That gap is the whole story of the comparison: the ⟨5, 9⟩ ripple runs nearly four times the amplitude of the ⟨7, 7⟩ one on the same stroke.

The Two Machines, Running

Single array. One bank, one carriage. The whole reaction is taken on one side of the guide.
Dual array. The source mass in two halves, a bank either side of the guide, each rope driving its own block at the stage.

Both loop continuously. Geometry is illustrative and not to scale.

Set your own specification and let the solver search for a comb.

Algorithmic description of the rigid (inextensible-rope) RopeComb simulation. The carriage motion drives the payload through a rigid unilateral constraint: when the rope is taut, carriage deceleration directly accelerates the payload; if the rope goes slack, the payload enters free flight.

Rigid (inextensible-rope) simulation PSEUDOCODE 
─────────────────────────────────────────────────────────────────────────────
 Algorithm: simulateRigid(M, m, h₀, G(d), dt)
─────────────────────────────────────────────────────────────────────────────
  Inputs
    M       ── source mass  (kg)
    m       ── payload mass (kg)
    h₀      ── source drop height (m); v₀ = √(2·g·h₀)
    G(d)    ── gear-ratio function of source displacement d (m)
    dt      ── time step (s);              default 2×10⁻⁵ s

  Outputs
    time-series of:  t, gear, v_source, v_payload, d_source,
                     d_payload, rope_end, F_source, F_payload, slack

─────────────────────────────────────────────────────────────────────────────

INITIALISE
  v_s    ← √(2·g·h₀)        ── source speed  (m/s)
  v_p    ← 0                 ── payload speed (m/s)
  d_s    ← 0                 ── source displacement (m)
  d_p    ── 0                 ── payload displacement (m)
  G_prev ← 0                 ── gear ratio at previous step
  G_avg  ← 0                 ── average gear over current step
  F_react_prev ← 0          ── reaction force at previous step (N)
  rope_end     ← 0          ── initial rope-end position (m)
  a_p_prev     ← 0          ── payload acceleration at previous step
  a_p    ← 0                 ── payload acceleration (m/s²)
  t      ← 0

LOOP  while  t < t_max  and  a_p < a_max
  t ← t + dt

  ── 1. Update source (heavy) body ─────────────────────────────────────────
  F_net_s    ← M·g  −  G_avg·F_react_prev   ── uses previous-step reaction
  a_s        ← F_net_s / M
  v_s_new    ← v_s + a_s·dt
  d_s_step   ← dt·(v_s_new + v_s) / 2       ── trapezoidal displacement
  d_s        ← d_s + d_s_step
  v_s        ← v_s_new

  ── 2. Update gear ratio ──────────────────────────────────────────────────
  G_new  ← G(d_s)                           ── evaluate comb geometry
  G_avg  ← (G_prev + G_new) / 2
  G_prev ← G_new

  ── 3. Advance rope end (kinematic) ──────────────────────────────────────
  rope_end ← rope_end + d_s_step · G_avg

  ── 4. Update payload body (unilateral rigid constraint) ──────────────────
  free_flight ← (v_p − 0.5·g·dt) · dt       ── free-flight displacement
  taut        ← rope_end − d_p              ── rope-limited displacement
  
  if free_flight > taut then
    d_p_step ← free_flight                  ── slack: payload is in free flight
    slack    ← true
  else
    d_p_step ← taut                         ── taut: payload constrained by rope
    slack    ← false
  end if
  
  d_p      ← d_p + d_p_step
  v_p_new  ← 2·(d_p_step / dt) − v_p
  a_p_new  ← (v_p_new − v_p) / dt
  v_p      ← v_p_new
  a_p      ← a_p_new

  ── 5. Compute reaction force ────────────────────────────────────────────
  a1 ← (g + a_p_prev) if a_p_prev > 0 else 0
  a2 ← (g + a_p_new)  if a_p_new > 0 else 0
  F_react_prev ← m · (a1 + a2) / 2

  a_p_prev     ← a_p_new

  ── 6. Record history ─────────────────────────────────────────────────────
  RECORD(t, G_new, v_s, v_p, d_s, d_p, rope_end,
         |F_net_s|, F_react_prev, slack)

END LOOP

RETURN history, peak_force, mean_force, exit_speed, elapsed_time
Gear-ratio function G(d) — comb geometry PSEUDOCODE 
─────────────────────────────────────────────────────────────────────────────
 Algorithm: G(d)  ─  instantaneous gear ratio of the comb at displacement d
─────────────────────────────────────────────────────────────────────────────
  Inputs
    R[1..N]  ── half-widths of the N sheaves / buckets  (m)
    s[1..N]  ── axial offsets of the N pins              (m)
    k        ── number of rope wraps (stage count)
    d        ── current source displacement              (m)

  Output:  total gear ratio G  (dimensionless)
─────────────────────────────────────────────────────────────────────────────

FUNCTION G(d):
  total ← 0
  for i ← 1 to N do
    D ← d − s[i]                 depth into sheave i
    if D > 0 then
      total ← total + 2·D / √(R[i]² + D²)
  end for
  return  k · total

The full Python reference implementation for the RopeComb simulation, fitting solver, and canonical cases has been packaged and published as an open-source library.

Python Reference Implementation

View the full repository, solvers, and simulation code on GitHub.

github.com/ramimahdi/ropecomb →