Forces in the links

Everything the tyre does reaches the body through the links. A wishbone corner has six: the two legs of each wishbone, the tie rod and the pushrod. The Forces tool works out what each one carries in a load case, and over a set of cases the most each must carry, which is what the links are sized for. This page follows that calculation.

Two-force members

A link with a ball joint or rod end at each end can carry no moment at either. Loaded only at its ends, it can only push or pull along the line between them: it is a two-force member, and one number says what it carries. The Forces tool gives that number in newtons, positive in tension.

A wishbone leg is two-force only in part. The two legs meet at the ball joint and are welded there, so a wishbone is one rigid arm, and an arm can bend. The app reads its load as two leg forces all the same, the share the legs can carry along their lengths, and reports what is left over, which the arm carries in bending.

The upright's balance

Six unknowns hold the upright: the two legs of the upper wishbone and the tie rod, each along its own line, and the lower ball joint, which can push any way and so counts for three. The pushrod stands on the lower wishbone, not on the upright. Force and moment balance about the wheel centre give six equations, and they settle the six:

The lower wishbone turns on its two chassis pivots. Its hinge can take a force in any direction but no moment about its own axis, so the pushrod has to balance $𝐋$ about that axis:

What the hinge takes, $𝐑$, is what is left: the ball joint's force and the pushrod's together. The app splits it into the two legs' forces by least squares, the nearest two forces along the legs can come:

A pushrod may stand on the upper wishbone instead, or on the upright itself; the tool balances whichever part carries it the same way. On a strut the strut carries a side load as well, and the tool reports it.

What reaches the upright

The tyre's force at the contact patch is not all the links carry. Two things change it on its way to the upright.

The tyre makes its side force behind the middle of its patch, by its pneumatic trail; that is its aligning torque. The app moves the side force that far back along the wheel's heading. And the wheel itself has a weight and, in a corner or under braking, an inertia: the tyre's force pushes the whole car, the wheel included, and the links carry what is left once the wheel has had its share. That share acts at the wheel centre, so it brings back the moment a force at the patch would add:

The second line is the front-left wheel in the Forces tool's live case, 1 g to the left at 60 km/h. The script reads its points and forces as the Forces tool holds them, in the frame the hardpoints are drawn in: $x$ forward, $y$ to the right, $z$ up. It is the inside wheel, lightly loaded, and its side force points into the turn, which for a left wheel is outboard.

A brake on the upright keeps its torque inside the upright. A brake or a motor on the chassis works the wheel through a shaft, and the shaft takes the moment the tyre's force makes about the spin axis to the body; the tool takes that part out of $𝐌$. Neither case here has one.

Two cases

The front-left wheel in the live case, and in the built-in "3 g bump, front", in which the road pushes that wheel up with three times its static load:

The pushrod takes the vertical load, in compression, and the lower legs hold its foot in tension. The upper wishbone is short of work in both: the lower ball joint is near the road, so it takes most of what the tyre does. The bump puts 2075 N on the patch, more than the template's springs can hold with that wheel pushed alone: they give out at 48.0 mm of travel (Kinematics and compliance). The tool stands the car there and lets a packer in the damper unit take the rest, so the links carry the whole case at that pose.

On a decoupled axle the pushrod turns a rocker, and the two rockers of the axle work the heave and the roll element between them (Ride and roll rates). Each rocker balances its pushrod against the elements, so the two pushrods together say what each element carries. In the live case the front heave element carries −1208 N and the roll element −649 N. The check below leaves the rockers out.

Loaded geometry

A link's force depends on its direction, and a load case moves every link. The car rolls, pitches and sinks under it, and in a corner it steers. The tool solves each case where the case puts the car, as the Kinematics load case does, with the tyre on its spring and the steer the corner needs: 4.73 mm of rack in the live case. The points the script reads are the ones it stood at.

Design loads

A link is sized for the most it ever carries, in tension and in compression. The tool runs a set of load cases and keeps, for each member and each sign, the largest force any of them puts on it, times the case's factor. The built-in set is the car's grip envelope, every limit it has: at each speed from 20 km/h to near its top speed, its g-g diagram walked to the edge in every direction, cornering, braking, driving and each mix of them. Wheel events such as the bump join it. Each case is solved as stated and mirrored, which on the template makes 200 states.

Most peaks are set at the edge of the envelope, where the tyres are working hardest. The front's largest come from the hardest stop at speed, where downforce and the pitch transfer stack: the lower front leg's tension, the upper front leg's compression and the heave element's. The rear's largest, its lower rear leg's tension and its pushrod's compression, come from cornering under drive. A peak set on a stop is marked so: the bump's is one.

What the model assumes

• Every link is a two-force member, with joints at its ends that carry no moment; a wishbone's bending shows only as the residual.
• The forces are static: the members have no mass, and the wheel's own inertia is taken at its centre.
• The tyre's aligning torque is its side force acting behind the patch, by the pneumatic trail the tyre model gives at the slip angle the case needs. A wheel event has no slip, so no trail.
• Each case is solved at its own pose, steady state. Dampers carry nothing in a steady case; a packer takes what the springs cannot hold.

In the app

Check it yourself

The script takes the live case and the bump at the front-left wheel as the tool stood them, adds the trail and the wheel's share, and solves the corner with pd_members.m, the same solve in the same order.

>> link_forces

  Live case, 1 g left at 60 km/h

  Quantity                                This script   PaceDynamics       Diff
  -----------------------------------------------------------------------------
  upper front leg [N]                         -182.19        -182.19   4.7e-14% 
  upper rear leg [N]                         -164.873       -164.873   3.4e-14% 
  lower front leg [N]                         561.357        561.357   8.1e-14% 
  lower rear leg [N]                          460.802        460.802   1.4e-13% 
  tie rod [N]                                 114.295        114.295   7.5e-14% 
  pushrod [N]                                -560.843       -560.843     2e-14% 
  lower arm, residual [N]                     32.6404        32.6404         0% 

  3 g bump, front
  upper front leg [N]                        -245.502       -245.502   2.3e-14% 
  upper rear leg [N]                         -151.556       -151.556   1.9e-14% 
  lower front leg [N]                         1398.02        1398.02   1.5e-13% 
  lower rear leg [N]                          1118.78        1118.78     1e-13% 
  tie rod [N]                                 53.5063        53.5063   1.3e-14% 
  pushrod [N]                                -2700.78       -2700.78         0% 
  lower arm, residual [N]                      176.76         176.76   1.6e-14% 

  All 14 quantities agree with PaceDynamics (largest difference 1.5e-13 %).

%% Forces in the links: what each link of a corner carries under a load case
%
% Companion to the documentation page "Forces in the links". Runs unchanged in GNU
% Octave (7 or later) and MATLAB. Edit the cases in example_suspension.m, or type your
% own from the Forces tool, and run:
%
%   >> link_forces
%
% Two of the Forces tool's cases, at the front-left wheel: the live case it opens on
% (1 g of cornering at 60 km/h) and the 3 g bump. Each gives the corner's points where
% the car stood under that case, the tyre's force at the contact patch, and the rest of
% what acts on the upright. The statics are in pd_members.
%
% Before the links see it, the tyre's force is joined by two more things:
%
% 1. The aligning torque. A tyre making side force makes it behind the middle of its
%    patch, by the pneumatic trail. The script moves the force's sideways part that far
%    back along the wheel's heading, which is the same moment.
% 2. The wheel's own weight and inertia, at the wheel centre: the patch force pushes the
%    whole car, the wheel included, and the links carry what is left once the wheel has
%    had its share. Added to the patch force it would bring a moment about the wheel
%    centre that a force AT the centre does not have, so that moment is taken back off.
%
% The script agrees with the app to its last digits: it is the same solve, in the
% same order.
%
% Part of the PaceDynamics documentation, https://pacedyn.dev/docs
% SPDX-License-Identifier: MIT

[car, app] = example_suspension();
cases = {'live', 'bump'};
titles = {'Live case, 1 g left at 60 km/h', '3 g bump, front'};
members = {'ucaFront', 'ucaRear', 'lcaFront', 'lcaRear', 'tieRod', 'pushRod', 'armResidual'};
labels  = {'upper front leg', 'upper rear leg', 'lower front leg', 'lower rear leg', 'tie rod', 'pushrod', 'lower arm, residual'};

for c = 1:numel(cases)
  k = app.forces.(cases{c});
  g = k.geometry;
  F = k.force;

  % The wheel's heading on the road: square to its spin axis, level, forward.
  s = g.spinAxis;
  h = [-s(2), s(1), 0] / hypot(s(1), s(2));
  if h(1) < 0, h = -h; end
  % 1. The trail: the force's sideways part, moved `trail` behind the patch.
  flat = [F(1), F(2), 0];
  sideways = flat - h * (flat * h');
  M = cross(-k.trail * h, sideways);
  % 2. The wheel's weight and inertia at its centre, moved to the patch.
  M = M - cross(g.contactPatch - g.wheelCenter, k.hub);
  F = F + k.hub;
  if k.shaft
    error('This script does not model a drive or brake shaft; the cases here have none.');
  end

  f = pd_members(g, F, M);
  fprintf('\n  %s\n', titles{c});
  for i = 1:numel(members)
    pd_compare(sprintf('%s [N]', labels{i}), f.(members{i}), k.members.(members{i}));
  end
end
pd_compare();

Further reading

• J. C. Dixon, Suspension Geometry and Computation (Wiley, 2009), on suspension forces and the free body.
• J. Reimpell, H. Stoll and J. W. Betzler, The Automotive Chassis: Engineering Principles (Butterworth-Heinemann, 2001), on design loads.