Dimensional Reduction — When 2D Captures 3D Mechanics

Top-level map: Field Guide

Companion chapters: The Physics of 2D Multibody Systems · The Computational Machinery · Concepts Primer

The simulator at the centre of this series is strictly 2D: every body has three coordinates $(x, y, \theta)$ in a fixed world plane, every force is a 2D vector, every constraint relates planar quantities. A V8 engine is geometrically 3D — banks fan out at an angle, cylinders distribute along the crankshaft. Yet the V-Engines chapter computed bearing forces and rocking moments for both flat-plane and cross-plane V8s and recovered the textbook NVH signatures.

That is not lucky coincidence. It is a dimensional-reduction lemma that is exact under four explicit hypotheses. This chapter states the lemma, lists the hypotheses, identifies which 6-DOF block reactions get computed in 2D and which are intentionally absent, and explains where the reduction would break down.

Pure mechanics, no code.

1. The puzzle

A multi-cylinder engine has

N cylinders, each a slider-crank linkage,
one crankshaft that all the connecting rods share,
cylinders distributed along the crankshaft axis (different axial stations along the engine block),
in V-engines, banks tilted at an angle $\beta$ to one another.

In 3D, that is $N$ slider-crank linkages × 3 bodies each × 6 DOF, plus constraint equations gluing them all to one crankshaft. A direct 3D MBSD would solve the whole thing at every time step.

Our framework solves one slider-crank in 2D, then computes the multi-cylinder response by complex-phasor superposition over a per-cylinder list (phases, bank_angles, positions). Why is that allowed?

2. Coordinate convention

Let the crankshaft axis be the world z direction (perpendicular to the page if you imagine the engine drawn in side view).

The simulator’s working plane is the (x, y) cross-section: x = lateral (across the engine block), y = vertical (up the engine block). Every body in the MBSD lives here.
The per-cylinder list positions[i] in the V-engine preset is cylinder $i$ ‘s z-coordinate along the crankshaft axis. Despite the variable name, this is not in the simulator’s plane — it is the orthogonal direction.

                        y  (vertical)
                        │
                        │   ┌── one cylinder's slider-crank
                        │   │   lives in this (x, y) plane,
                        │   │   at z = positions[i]
                        │   ▼
                   ─────┼──────────  x  (lateral)
                      ╱
                     ╱
                    ╱
                   z   (crankshaft axis,
                        perpendicular to MBSD plane)

Cylinders at different $z$ positions all live in parallel (x, y) planes, related to one another only by their crank phase. The MBSD itself never knows about z — the third dimension enters only at post-processing time, in moment summation.

3. The dimensional-reduction lemma

Claim. Under the four hypotheses in §4, the rigid-body reaction forces and moments on the engine block from any N-cylinder multi- cylinder engine can be computed exactly by:

Running a single 2D inverse-dynamics simulation of one representative cylinder (gravity off), in one (x, y) cross-section. This produces the per-cylinder force harmonics $F_\text{single}[n]$ .
Combining N copies via the complex-phasor formulas

$\hat{F}_x[n] = F_\text{single}[n] \cdot \sum_i \cos(\beta_i) \cdot \exp(j \cdot n \cdot \phi_i)$

$\hat{F}_y[n] = F_\text{single}[n] \cdot \sum_i \sin(\beta_i) \cdot \exp(j \cdot n \cdot \phi_i)$

$\hat{M}_\text{pitch}[n] = F_\text{single}[n] \cdot \sum_i z_i \cdot \cos(\beta_i) \cdot \exp(j \cdot n \cdot \phi_i)$

$\hat{M}_\text{yaw}[n] = F_\text{single}[n] \cdot \sum_i z_i \cdot \sin(\beta_i) \cdot \exp(j \cdot n \cdot \phi_i)$

where $\phi_i$ is cylinder i’s crank phase, $\beta_i$ its bank angle in the (x, y) plane, and $z_i$ its position along the crankshaft axis.

The result is exact, not an approximation, given the hypotheses. There is no “2D error” being paid against a “true 3D answer” — the 3D answer reduces algebraically to this form.

Why the reduction works

Each cylinder produces a force on the crankshaft bearing that lies entirely in the (x, y) plane:

Piston motion is along its bore axis, which is itself in (x, y).
The connecting rod pivots in (x, y).
The crank throw rotates in (x, y) about the crankshaft (z) axis.

There is no z-component of any reaction force from any cylinder under the hypotheses. The “3D-ness” of the engine block enters only as a lever-arm weighting in moments: a force at $z = z_i$ produces a moment of magnitude $z_i \cdot F$ about the y- or x-axis. That weighting is one multiplication, applied at post-processing time after the 2D sim has already given you $F_\text{single}[n]$ . No new physics, no separate simulation.

4. The four hypotheses

The reduction is exact iff all four hold. Each is reasonable for a production internal-combustion engine; each has a known failure mode worth being aware of.

H1 — Rigid crankshaft

Every cylinder shares one crankshaft angle $\theta_\text{crank}(t)$ . Cylinder $i$ ‘s individual phase is $\theta_\text{crank}(t) + \phi_i$ for a fixed offset $\phi_i$ .

Breaks when: the crankshaft is treated as a flexible beam in z and develops torsional vibration modes. At resonance the front cylinders see a different $\theta$ than the rear cylinders at the same instant, so $\phi_i$ is no longer a fixed offset. Required for high-RPM crank-train analysis but irrelevant for rigid-body NVH at typical operating points.

H2 — Identical cylinders

Same bore, same stroke, same connecting-rod length, same masses for piston / rod / crank. Every cylinder produces an identical per-cylinder force-time signature $F_\text{single}(t)$ , just shifted in phase.

Breaks when: banks have different bore/stroke (some V-engines combine large and small cylinders), or one cylinder is fired at a non-uniform pressure (mis-fire diagnostics, cylinder deactivation). The fix is to run multiple per-cylinder simulations — one per “class” of cylinder — and phasor-sum each class separately.

H3 — Bore axes purely transverse

The bore axis of every cylinder lies in the (x, y) plane: no z-tilt of the cylinders, no axial offset of the connecting rod. Piston motion has zero z-component.

Breaks when: unusual engine architectures put the bore at an angle to the crank-perpendicular plane. Axial-piston pumps, swash- plate engines, and some W-engine geometries fall here. For mainstream V, inline, and boxer engines the assumption holds exactly.

H4 — Gravity in the working plane

If gravity is non-zero, it lies in (x, y). The engine is mounted with its crankshaft horizontal (or vertical with no horizontal gravity component along z); standard for transverse and longitudinal production layouts.

Breaks when: the engine is tilted such that gravity has a z- component. The z-gravity component drops out of the inertial analysis (it doesn’t drive piston motion) but would offset the static $F_z$ bearing reaction from zero. For this series we run gravity-off everywhere precisely to bypass this whole question and keep the cancellation arguments clean.

5. The 6-DOF engine block — what we compute, what we omit

The engine block has six rigid-body DOF: three translations and three rotations. The cylinders’ reaction forces excite each one differently:

Block DOF	Excited by inertia?	Excited by combustion?	Computed in this framework?
$F_x$ (lateral)	yes (V-engine bank component)	yes	✔ `phasor_sum_2d`
$F_y$ (vertical)	yes (V-engine bank component)	yes	✔ `phasor_sum_2d`
$F_z$ (along crankshaft)	NO — H3	NO — H3	n/a, identically zero
$M_\text{pitch}$ (about y)	yes	yes	✔ `phasor_moment_sum_2d` (z-weighted)
$M_\text{yaw}$ (about x)	yes	yes	✔ `phasor_moment_sum_2d` (z-weighted)
$M_\text{roll}$ (about z = engine torque output)	small ripple	yes (firing torque)	analysed separately, see below

Four of six DOF come straight out of the V-engine and combustion chapters. The remaining two:

$F_z$ is identically zero by H3. There is no z-excitation in any rigid-body slider-crank — confirmed at the time-domain level by every per-cylinder simulation we have run. So nothing is omitted; the answer just happens to be zero.
$M_\text{roll}$ is the engine’s output torque about the crankshaft axis. It has a dual nature: its DC component is the useful work output that drives the transmission, while its harmonic ripple (1× crank, 2× crank, firing-frequency, …) is a vibration source — this is what makes the engine “roll” on its mounts during a throttle blip, and the rolling rumble of an idling Diesel. Both come from the same time-domain torque signal $\tau(t)$ ; the separation is interpretive, not physical. Our framework analyses the harmonic ripple via the single-cylinder vibration spectrum: vibration_slider_crank.py extracts the 1× and 2× torque-ripple amplitudes from the inverse-dynamics signal. For multi-cylinder engines the same phasor sum applies, with $\sum_i \exp(j \cdot n \cdot \phi_i)$ (no bank or position weighting — torque about z is a scalar that all cylinders contribute to identically per crank degree of rotation). We have not written that out as a separate chapter because the algebra is literally the inertial 1D phasor sum from the I4 chapter, just applied to torque instead of force.

So 4 + (1 trivially zero) + (1 reused-from-earlier) = all six DOF covered, none missing.

6. Why the 2D framework, used this way, is not “approximate”

A common reflex is to assume that any 2D simulation of a 3D system is making an approximation. That is wrong here, and worth being explicit about. Under H1–H4, the 3D rigid-body equations of motion for an N-cylinder engine factor exactly into:

$\underbrace{\text{one 2D rigid-body problem}}_{\text{the per-cylinder slider-crank}} \times \underbrace{\text{one phasor sum over cylinder index } i}_{\text{for forces in } x, y} \times \underbrace{\text{one } z\text{-weighted phasor sum}}_{\text{for moments about } x, y}$

Each factor is a closed-form algebraic operation, not a numerical approximation. The 2D simulator solves the first factor exactly; the phasor sums are arithmetic on complex numbers. The output is the same as a fully 3D MBSD simulation would produce — it is just much cheaper to compute, and the cancellation algebra (which harmonics cancel, which add up) is far easier to read off the phasor sums than from time-domain 3D output.

This is the same kind of dimensional reduction that lets you compute the bending stress in a long beam from a 1D Euler-Bernoulli equation instead of solving the full 3D elasticity problem: under stated hypotheses (slender, prismatic, small deflection) the dimension drops out exactly.

7. Generalisation to other 2D analyses in this codebase

The same dimensional-reduction logic supports several other 2D examples in the multi-body simulator:

Example	What’s in 2D	What’s in the perpendicular dim	Hypotheses on the perpendicular dim
Multi-cylinder inline engines	Slider-crank cross-section	Cylinder positions along crank	H1–H4 ( $\beta = 0$ for all i)
V-engines	Slider-crank + bank angle $\beta$	Cylinder positions along crank	H1–H4
Cam-follower	Cam profile and follower contact	Camshaft axis	uniform cam profile along z, no z-translation
Terrain-wheel-suspended-mass	Wheel side-view + suspension	Wheel axle (z = perpendicular to direction of travel)	no camber, no longitudinal terrain variation
Slider-crank (single)	Crank + rod + slider	Piston axial wobble	piston doesn’t tilt
Four-bar / Geneva / pantograph	Linkage in (x, y)	Out-of-plane linkage offset	links sit in parallel planes; pin joints have no out-of-plane play

In every case the working principle is the same: pick a working plane that captures all the active DOF, list the assumptions that make the out-of-plane dimensions decouple, and run the simulator in the plane. Out-of-plane geometry enters only as scalar weights at post- processing time (lever arms, position offsets) — not as live simulation DOFs.

8. When you actually need full 3D

The dimensional reduction stops working when one of the assumptions fails or when a genuinely 3D effect dominates. Common cases:

Crankshaft torsional vibration — H1 fails. The shaft bends in torsion at specific RPMs, and front-vs-rear cylinders see different phases. Standard remedy: model the crank as a beam in z and couple the per-cylinder forces to a beam mode shape. The 2D phasor sums still apply per beam mode, weighted by the mode shape evaluated at each cylinder’s z position.
Crankshaft bending and whirl — at high RPM, rotating crankshafts can develop bending modes in the (x, z) and (y, z) planes. These are 3D rotor-dynamics phenomena; they couple cylinder forces to crank-axis bending DOFs that don’t exist in the 2D framework.
Gyroscopic coupling — a vehicle that pitches or rolls applies a cross-axis moment to the spinning crankshaft (the spinning crank resists tilt). For most automotive applications this is small and ignored; for aircraft engines it’s a primary handling concern.
Engine-mount transmissibility in 3D — once the cylinders’ $(F_x, F_y, M_\text{pitch}, M_\text{yaw})$ reach the engine block, the block itself is mounted to the chassis on N (typically 3–5) mount points that have 3D stiffness. Computing how the (4-DOF) source excites the (6-DOF) block on (3D-stiff) mounts producing chassis- side reactions is a genuinely 6-DOF problem. The 2D version (block on N planar springs, only 3 of 6 DOF in play) is a useful first approximation; the next chapter in this series tackles it. Full 3D comes after.
Misalignment — if the engine block is mounted at an angle that rotates the (F, M) source vector relative to the chassis frame, the in-plane / out-of-plane partition no longer aligns with the chassis coordinates and a coordinate transform is needed.

In each case the 2D framework is not “wrong” — it just stops being sufficient. The inertial / combustion / balance-shaft analyses already done remain exactly valid as the source terms; the 3D extension only matters when you propagate those sources through genuinely 3D structural elements.

9. FAQ

Q1. If the 2D reduction is exact, why does industry still run full 3D MBSD on engines?

Because three classes of engine question are not rigid-body NVH, and 3D MBSD is the right tool for them:

Interference checking. Does the connecting rod clear the block at TDC? Does a counter-weight clear the oil-pump pickup? Does a balance shaft clear the cylinder skirt? Geometric questions about parts-in-space, not dynamics questions about how forces sum. The 2D framework doesn’t even see the parts; it sees masses, lengths, and joints.
Lubrication. Oil-film thickness in journal bearings under peak load, oil sloshing in the sump, scavenging in dry-sump systems. Genuinely 3D fluid problems on top of 3D rigid bodies.
High-frequency structural resonance. Does the crankshaft “ring” like a bell at a particular RPM? Do block-skirt panels resonate with combustion harmonics? These are 3D flexible bodies — H1 (rigid crankshaft) explicitly fails. They couple to acoustic radiation, which is its own discipline.

For the low-frequency rigid-body NVH that defines engine balance — the I4 secondary, the V8 cross-plane rocking couple, firing- frequency thunder, balance-shaft cancellation — the 2D-with-phasor framework is the faster, more insightful tool. 3D MBSD is the wrong hammer for these nails: too expensive, too noisy, and the cancellation algebra (which harmonic exactly cancels and which exactly reinforces) is far easier to read off a complex phasor sum than from a 3D time-domain trace.

Q2. How does the framework handle a desaxé (offset) crank, where the cylinder bore doesn’t pass through the crankshaft centerline?

Naturally and exactly — within H3.

H3 says the bore axis lies in the (x, y) plane; it does not require the bore to pass through the crank centre. A desaxé layout shifts the bore laterally by some offset $e$ . Geometrically the piston-pin-to-crank-centre line passes the crank at perpendicular distance $e$ , not zero. Slider-crank kinematics with this offset produces an asymmetric $F_\text{single}(t)$ : the force-versus-crank-angle curve is no longer symmetric about TDC/BDC, and one stroke (typically the power side) shows slightly larger peak forces than the other (exhaust return).

In the framework: build the slider-crank with the prismatic axis offset by $e$ from the world origin, run inverse dynamics, take the FFT of the bearing reaction. You get a $F_\text{single}[n]$ whose harmonic content differs from the symmetric case — in particular, the odd harmonics ≥ 3 stop being identically zero (the symmetry argument that killed them in §4 of the I4 chapter no longer holds). The phasor sum across cylinders works exactly the same way; it sees only $F_\text{single}[n]$ and doesn’t care how the per-cylinder physics produced it. So a desaxé engine’s multi-cylinder spectrum follows with no new code — just a different geometry input to the single-cylinder simulation.

VR6, W12, and any modest “pinion offset” for piston-side-load mitigation fall in this category. The 2D framework accommodates them with one parameter.

Q3. Doesn’t the 2D framework miss out on the engine’s “roll” feel — the way a V8 lurches when you blip the throttle?

No — that is $M_\text{roll}$ , the time-varying part of the engine’s output torque, and it is fully captured. The DC of $\tau(t)$ is the useful work; the harmonic ripple at 1×, 2×, firing-freq is exactly what makes the engine roll on its mounts during a transient. The §5 row labelled $M_\text{roll}$ covers it: same phasor logic as forces, applied to the torque signal, and reusing the vibration_slider_crank.py single-cylinder analysis verbatim.

The framework therefore covers all three “felt” engine motions: shake ( $F_x, F_y$ ), rock ( $M_\text{pitch}, M_\text{yaw}$ ), roll ( $M_\text{roll}$ ). Plus $F_z$ , which is identically zero. Six DOF, all accounted for.

Q4. What about gyroscopic effects — a spinning crankshaft in a vehicle that pitches and rolls?

That is genuinely outside the 2D framework. A spinning crankshaft has angular momentum $L = I_\text{crank} \cdot \omega$ along the z-axis. When the vehicle pitches or rolls, that angular momentum vector tries to precess, generating a gyroscopic moment about a third axis perpendicular to both the crank-spin axis and the pitch/roll axis. That moment doesn’t appear in any of the per-cylinder phasor sums — it’s a property of the rotating-shaft assembly as a whole, coupled to the chassis dynamics.

For mainstream automotive use this effect is small (the crank’s angular momentum is modest, and chassis pitch/roll rates are slow). For aircraft engines mounted in airframes that pitch and roll aggressively, it’s a primary handling concern — the P-factor and gyroscopic precession of a piston engine is a real flight-control issue. Either way, it’s a 6-DOF chassis problem, not a 2D source problem, and the right place to add it is in the future engine-mount transmissibility chapter.

10. Summary

The 2D simulator captures multi-cylinder engine NVH exactly because the engine’s geometry decomposes cleanly into (a) a planar slider- crank cross-section solved by the simulator, and (b) an axial distribution of cylinders that enters only as scalar lever arms in phasor moment sums. Under the four hypotheses (rigid crank, identical cylinders, transverse bores, in-plane gravity), the reduction is algebraic and exact — not an approximation.

That is why the V-engine and combustion chapters compute “3D-looking” quantities like flat-plane vs cross-plane V8 rocking couples directly in the 2D framework, and why their numerical results match analytical textbook predictions to floating-point precision rather than to some “close-enough” tolerance.