Anti-dive and anti-squat

Braking moves load onto the front wheels and the nose dives; drive moves it onto the rear and the tail squats. Both are load transfer, and without help the springs carry all of it. The links can carry a share instead, if the force each tyre makes along the road pushes on the body through them. How large a share depends on one slope per wheel, seen from the side.

The side-view force line

Seen from the side, the upright moves for a small travel as if it turned about one point, its side-view instant centre, on an arm from the contact patch, the side-view swing arm (SVSA). As the wheel rises, the patch moves square to that arm. A force at the patch along the arm does no work as the wheel moves, so it loads no spring: it is the wheel's side-view force line, the twin of the front-view one on Roll and pitch centres.

The angle that matters is the force line's slope against the road, $\theta$, positive where the line rises towards the middle of the car. A braking or drive force along the road at the patch can be split in two: a part along the force line, which the links take, and an upright part at the patch, $F_x\tan \theta$, which pushes the wheel down or up against its spring. On a front wheel braking, a force line rising rearwards turns some of the braking force into lift at the front corner.

The percentages

Under a deceleration $a_x$ the pitch transfer onto the front axle is $m{a}_{x}h/L$. The front tyres brake with ${\beta }_{f}m{a}_x$ of the force, and their force lines lift the front by $\tan {\theta }_f$ times that. The share of the transfer the links hold up is the anti percentage:

At 100 % the links hold the whole transfer and the body does not pitch; at 0 % the springs take it all; below zero the geometry adds to the pitch. More is not simply better: a car with a lot of anti-dive feeds braking harshness into the chassis, and its driver loses the pitch they brake by.

The same rear force line serves braking and drive, with opposite forces and an opposite transfer, so anti-lift and anti-squat share a sign. On the front axle, anti-lift under drive is the same construction for a car driving its front wheels; the template does not, so it has none.

Inboard brakes and motors

An outboard brake grips the disc on the upright: the brake's torque stays inside the upright and the tyre's force acts at the patch, so the patch's path counts. A brake on the chassis, or a motor there driving through a shaft, takes its torque to the body, and the upright sees only the force at the wheel centre. The app then reads the slope of the wheel centre's path instead of the patch's. On the template that slope is steeper:

This car

The template's wishbones are close to parallel in side view, so its instant centres are far away, 572 362 mm from the front patches and 50 009 mm from the rear ones, both ahead of their wheels and a little below the road. Its force lines are nearly flat, 0.11° at the front and −0.51° at the rear, and its anti features close to zero. A distant instant centre is a poor number to quote, since a small change in the arms moves it a long way; the slope at the patch is not, and the percentages are built from that.

How the app finds them

The app solves the upright's position with the wheel centre half a millimetre above and below the static ride, as on Wishbones and struts, and differences the patch's position and the wheel centre's. That gives each path per millimetre of rise, $𝐯$. The road, in side view, is the line through the front and rear patches; with $\widehat{𝐚}$ along it, from rear to front, and $\widehat{𝐧}$ square to it, upwards:

What the model assumes

• The anti percentages are those of the static ride. The swing arm turns as the car pitches, so they move with dive and squat; the Analysis tab draws them through the travel.
• The links are rigid; the front and rear force lines of one side are read on the left side, and the car is the same on the right.
• The braking split is the brake balance, fixed; the drive split is the car's drive layout.
• The Kinematics load case and the Forces tool use the percentages: the longitudinal transfer less the anti share goes through the springs.

In the app

Check it yourself

The script solves the front-left and rear-left uprights half a millimetre either side of the static ride, differences the patch and the wheel centre, and builds the slopes and all six percentages from them.

>> anti_features

  Quantity                                This script   PaceDynamics       Diff
  -----------------------------------------------------------------------------
  tan(theta), front patch [-]             -0.00187065    -0.00187065   3.3e-08% 
  tan(theta), front hub [-]                -0.0031561     -0.0031561   2.2e-08% 
  tan(theta), rear patch [-]              -0.00898289    -0.00898289   9.8e-09% 
  tan(theta), rear hub [-]                 -0.0134057     -0.0134057   4.2e-09% 
  Anti-dive [%]                              0.618563       0.618563   3.3e-08% 
  Anti-lift, rear brakes [%]                 -1.82053       -1.82053   9.8e-09% 
  Anti-squat [%]                             -4.79087       -4.79087   9.8e-09% 
  Anti-dive, inboard [%]                      1.04362        1.04362   2.2e-08% 
  Anti-lift, inboard [%]                      -2.7169        -2.7169   4.2e-09% 
  Anti-squat, inboard [%]                    -7.14972       -7.14972   4.2e-09% 

  All 10 quantities agree with PaceDynamics (largest difference 3.3e-08 %).

%% Anti-dive and anti-squat: how much of the pitch the links hold up
%
% Companion to the documentation page "Anti-dive and anti-squat". Runs unchanged in GNU
% Octave (7 or later) and MATLAB. Edit the car in example_suspension.m, or type your own
% hardpoints from the Kinematics tool, and run:
%
%   >> anti_features
%
% What this computes, on the car's left side:
%
% 1. How the contact patch and the wheel centre move as each wheel rises: the upright's
%    pose 0.5 mm above and below the static ride (pd_upright), differenced, as the app
%    takes it. The patch is carried with the upright, a standing radius below the centre.
% 2. The slope of each path against the road, tan(theta) = -(v . along) / (v . up), with
%    `along` the road in side view, from the rear patch to the front one. A brake or a
%    motor at the wheel pushes the car through the patch, so the patch's path counts; one
%    on the chassis pushes through the wheel centre, and the centre's path counts.
% 3. The percentages. Braking moves (h / L) of the car's weight per g onto the front axle;
%    the links take the share tan(theta) / (h / L) of what each axle's force asks of them:
%        anti-dive   = -tan(theta_f) * L / h * (front share of the braking)
%        anti-lift   =  tan(theta_r) * L / h * (rear share of the braking)
%        anti-squat  =  tan(theta_r) * L / h * (rear share of the drive)
%    The front sign is the other way round because the front wheel is ahead of the
%    centre of gravity: its force line has to rise toward the rear to hold the nose up.
%
% Part of the PaceDynamics documentation, https://pacedyn.dev/docs
% SPDX-License-Identifier: MIT

[car, app] = example_suspension();
g = 9.81;
Fz = car.massTotal * g * [car.frontMassFrac, 1 - car.frontMassFrac] / 2;   % N, per wheel
R0 = car.tyreFreeRadius - Fz / car.tyreRate;                  % mm, the radius each axle stands on
step = 0.5;                                                   % mm, the app's half-step

axles = {pd_corner(car.front), pd_corner(car.rear)};
for ax = 1:2
  a = axles{ax};
  m = pd_metrics(a.ubj, a.lbj, a.C, a.n, a.tieOuter, R0(ax));
  K = m.patch;                                                % the patch at rest, corner frame
  lo = pd_upright(a, 'travel', -step);  hi = pd_upright(a, 'travel', step);
  vK = (hi.at(K) - lo.at(K)) / (2 * step);                    % per mm the wheel centre rises
  vC = (hi.at(a.C) - lo.at(a.C)) / (2 * step);
  side(ax).K  = [a.axleX + K(1), K(3)];                       % side view (x, z), vehicle frame
  side(ax).vK = vK([1, 3]);
  side(ax).vC = vC([1, 3]);
end

% The road in side view: through the rear patch and the front one.
along = (side(1).K - side(2).K) / norm(side(1).K - side(2).K);
up = [-along(2), along(1)];
slope = @(v) -(v * along') / (v * up');
tanF = slope(side(1).vK);  tanFhub = slope(side(1).vC);
tanR = slope(side(2).vK);  tanRhub = slope(side(2).vC);

geom = car.wheelbase / car.cgHeight;
bf = car.brakeFront;  df = car.driveFront;
pick = @(inboard, patch, hub) patch * ~inboard + hub * inboard;
antiDive  = -100 * pick(car.brakeInboard(1), tanF, tanFhub) * geom * bf;
antiLift  =  100 * pick(car.brakeInboard(2), tanR, tanRhub) * geom * (1 - bf);
antiSquat =  100 * pick(car.motorInboard(2), tanR, tanRhub) * geom * (1 - df);
% The same car with its brakes and its motor on the chassis.
inDive  = -100 * tanFhub * geom * bf;
inLift  =  100 * tanRhub * geom * (1 - bf);
inSquat =  100 * tanRhub * geom * (1 - df);

%% Against the app
pd_compare('tan(theta), front patch [-]',  tanF,      app.anti.front.tanPatch);
pd_compare('tan(theta), front hub [-]',    tanFhub,   app.anti.front.tanHub);
pd_compare('tan(theta), rear patch [-]',   tanR,      app.anti.rear.tanPatch);
pd_compare('tan(theta), rear hub [-]',     tanRhub,   app.anti.rear.tanHub);
pd_compare('Anti-dive [%]',                antiDive,  app.anti.front.antiDive);
pd_compare('Anti-lift, rear brakes [%]',   antiLift,  app.anti.rear.antiLift);
pd_compare('Anti-squat [%]',               antiSquat, app.anti.rear.antiSquat);
pd_compare('Anti-dive, inboard [%]',       inDive,    app.anti.inboard.antiDive);
pd_compare('Anti-lift, inboard [%]',       inLift,    app.anti.inboard.antiLift);
pd_compare('Anti-squat, inboard [%]',      inSquat,   app.anti.inboard.antiSquat);
pd_compare();

Further reading

• W. F. Milliken and D. L. Milliken, Race Car Vehicle Dynamics (SAE, 1995), ch. 17, on anti-dive and anti-squat.
• T. D. Gillespie, Fundamentals of Vehicle Dynamics (SAE, 1992), ch. 7.
• J. C. Dixon, Suspension Geometry and Computation (Wiley, 2009), on side-view geometry.