Motion study of an assembly

How the precision is kept

The joint value, the placements and the tracked positions are 64-bit numbers. Velocity and acceleration are finite differences of the recorded positions, so they depend on the number of steps; the study's own notes say so. Clearances are measured by manifold-3d on solids rebuilt from each part's mesh as a Float32Array, so the reported gaps start from 32-bit vertex coordinates and are distances between facets. The CSV export rounds every number to 5 decimals.

Open item. Build the clearance solids from 64-bit vertex coordinates and write the CSV with full precision.

6 calculations in 1 source file. The code is read from the released app when this page loads. It is the calculation people run, not a copy kept for this page.

export const LAWS = {
  linear: (s) => s,
  ease: (s) => s * s * (3 - 2 * s),                       // smoothstep: speed 0 at both ends, 1.5 × the average in the middle
  sine: (s) => 0.5 - 0.5 * Math.cos(Math.PI * s),          // speed 0 at both ends, π/2 × the average in the middle
  'round-trip': (s) => (s < 0.5 ? 2 * s : 2 - 2 * s),      // from → to → from at constant speed
};

/** The middle of a part's mesh box, in the part's own coordinates. */
function boxCentre(build) {
  const p = build?.mesh?.positions;
  if (!p || !p.length) return [0, 0, 0];
  const lo = [Infinity, Infinity, Infinity], hi = [-Infinity, -Infinity, -Infinity];
  for (let i = 0; i < p.length; i += 3) for (let k = 0; k < 3; k++) { const v = p[i + k]; if (v < lo[k]) lo[k] = v; if (v > hi[k]) hi[k] = v; }
  return [(lo[0] + hi[0]) / 2, (lo[1] + hi[1]) / 2, (lo[2] + hi[2]) / 2];
}

const mesh = new M.Mesh({ numProp: 3, vertProperties: new Float32Array(b.mesh.positions), triVerts: new Uint32Array(b.mesh.indices) });
mesh.merge();
base.set(i.id, T(new M.Manifold(mesh)));

const dt = duration / steps;
for (let k = 0; k <= steps; k++) {
  const r = rows[k], p = rows[Math.max(0, k - 1)], n = rows[Math.min(steps, k + 1)];
  const span = (n.time - p.time) || 1;
  r.rate = (n.value - p.value) / span;
  r.tracks.forEach((tr, i) => {
    const a = p.tracks[i].pos, b = n.tracks[i].pos;
    tr.vel = [0, 1, 2].map((q) => (b[q] - a[q]) / span);
    tr.speed = Math.hypot(...tr.vel);
    if (k > 0 && k < steps) tr.acc = [0, 1, 2].map((q) => (p.tracks[i].pos[q] - 2 * tr.pos[q] + n.tracks[i].pos[q]) / (dt * dt));
  });
}

const peaks = tracks.map((tr, i) => {
  let sp = 0, spAt = 0, ac = 0, acAt = 0, travel = 0;
  rows.forEach((r, k) => {
    const q = r.tracks[i];
    if (q.speed > sp) { sp = q.speed; spAt = r.time; }
    const am = Math.hypot(...q.acc);
    if (am > ac) { ac = am; acAt = r.time; }
    if (k > 0) travel += Math.hypot(...[0, 1, 2].map((c) => q.pos[c] - rows[k - 1].tracks[i].pos[c]));
  });
  return { id: tr.id, name: tr.name, speed: sp, speedAt: spAt, acc: ac, accAt: acAt, travel };
});

const f4 = (v) => (Number.isFinite(v) ? String(+v.toFixed(5)) : '');

In detail

Method

Joint value from a motion law of the step fraction; placement by assembly.js; central differences inside the range and one-sided at the ends; path length as the sum of chords; minimum gap by manifold-3d's minGap.

Number types

64-bit numbers for values, positions and derivatives; Float32Array for the vertices of the solids used for clearance.

Tolerances

A pair is listed when its gap is under the search length minus 1e-9. Steps limited to 400, pairs to 60, tracks to 12.

Limits

Peak speed and acceleration are the largest sampled values. The acceleration of the first and last step is left at zero, although a comment in the code says it copies the neighbor's. The path length under-reads a curved path between steps.

Approach: 32-bit step, flagged

One step stores or exchanges 32-bit values that reach a number a person reads. It is listed here with its open item, and the step is either moved to 64-bit or the app will warn where the number is read.

Every policy that takes this approach