Axes, signs and units

A number about a car means little until you know which way is positive. PaceDynamics uses one convention throughout its models. This page states it, shows where the load goes in two simple manoeuvres, and lists the few readouts that still use another sense.

The car's axes

The car's axes are those of ISO 8855. The origin is at the centre of gravity (CG), and the axes turn with the car:

• x points forward,
• y points to the driver's left,
• z points up.

A rotation is positive by the right-hand rule: point your right thumb along the axis, and your fingers curl the positive way.

• Yaw $r$ about z is positive turning left.
• Pitch $\theta$ about y is positive nose down.
• Roll $\phi$ about x is positive right side down.

Accelerations follow the axes. The longitudinal acceleration $a_x$ is positive when the car speeds up and negative under braking. The lateral acceleration $a_y$ is positive towards the left, so a left turn has $a_y>0$. In a steady left turn the body rolls towards the outside, right side down, so the roll is positive too.

Where the load goes

The wheels are named from the driver's seat: FL, FR, RL, RR for front left, front right, rear left and rear right.

Standing still, the template carries 692 N on each front wheel and 780 N on each rear one. Turning left at 1 g moves 360 N from FL to FR and 359 N from RL to RR. Braking at 1 g moves load from the rear axle to the front.

Equation (2) carries the sign: a positive $a_y$, a left turn, adds load to the right wheels. The rear axle is the same with $c_r$.

The wheels' own angles

Each wheel's angles are measured in its own frame, so the same number means the same thing on the left and on the right.

• Camber is positive with the top of the wheel leaning outboard. Negative camber, top in, is what a race car runs.
• Toe is positive toe-in: the front of the wheel turned towards the car's centre-line.
• Bump steer is the toe change per millimetre of bump, positive when the wheel toes in as it rises.
• Wheel travel is positive in bump, the wheel moving up towards the body.
• Steer of a road wheel is positive to the left, the same sense as yaw.

The tyre's slip

The slip angle $\alpha$ is the angle between where a wheel points and where it goes. The app takes it positive when the wheel travels to the right of where it points. The tyre then pushes to the left, so positive slip gives positive side force: in a left turn every slip angle is positive.

This is the opposite sense to the slip angle of ISO 8855, and the same as the "adapted SAE" convention in Pacejka's book. A tyre file may state its forces the other way round. The app reads the file as it is and turns it round once for the vehicle models (see Slip and the Magic Formula).

The slip ratio $\kappa$ is positive when the tread turns faster than the road passes under it, which is driving. Braking slip is negative.

Units

Every readout uses one fixed unit. The unit preferences in Settings change only how coordinates are typed.

A rate at the wheel is what the wheel feels: a spring's own rate times the square of its motion ratio. The motion ratio is the damper's travel per unit of wheel travel, worked out by the Kinematics tool from the hardpoints.

Readouts that use another sense

A few views use a different sense from this page. Read them as follows:

What this page assumes

• The car is the same left and right, so a right turn is a left turn mirrored.
• The loads in Fig. 2 are steady: no transient, no aerodynamic load (the car is standing or slow), and all four wheels on the road.

In the app

Check it yourself

The script computes the template's wheel loads standing and in a left turn at 1 g, and compares them, sign included, with the app's. Edit the car in example_car.m to check yours.

>> axes_and_signs

  Quantity                                This script   PaceDynamics       Diff
  -----------------------------------------------------------------------------
  Standing, FL [N]                            691.605        691.605         0% 
  Standing, FR [N]                            691.605        691.605         0% 
  Standing, RL [N]                            779.895        779.895         0% 
  Standing, RR [N]                            779.895        779.895         0% 
  Left turn at 1 g, FL [N]                    332.079        332.079         0% 
  Left turn at 1 g, FR [N]                    1051.13        1051.13         0% 
  Left turn at 1 g, RL [N]                    420.453        420.453   2.7e-14% 
  Left turn at 1 g, RR [N]                    1139.34        1139.34         0% 
  Front roll stiffness [N*m/deg]               460.37         460.37   1.2e-14% 
  Roll per g [deg/g]                         0.852918       0.852918         0% 

  All 10 quantities agree with PaceDynamics (largest difference 2.7e-14 %).

%% Axes, signs and units: which wheel the app loads, and by how much
%
% Companion to the documentation page "Axes, signs and units". Runs unchanged in GNU
% Octave (7 or later) and MATLAB. Edit the car in example_car.m and run:
%
%   >> axes_and_signs
%
% The car's axes are ISO 8855: x forward, y to the left, z up, and rotations positive by
% the right-hand rule about each. In a left turn the lateral acceleration a_y is
% positive, the body rolls right side down (positive roll), and load goes to the right
% wheels. Under braking a_x is negative, the nose goes down (positive pitch), and load
% goes to the front.
%
% Wheels are named FL, FR, RL, RR: front or rear, then left or right as the driver sits.
%
% The app states lengths in mm, rates at the wheel in N/mm, roll stiffness in N*m/deg,
% and accelerations in g, where g = 9.81 m/s^2. This script works in SI and converts
% where the app's readouts are.
%
% Part of the PaceDynamics documentation, https://pacedyn.dev/docs
% SPDX-License-Identifier: MIT

[car, app] = example_car();
app = app.axes;

g  = 9.81;                                    % m/s^2, the app's g
mm = 1e-3;                                    % m per mm

%% Standing still: the weight, split by the front share, half to each wheel
W  = car.massTotal * g;                       % N
Wf = W * car.frontMassFrac;                   % N on the front axle
Wr = W * (1 - car.frontMassFrac);             % N on the rear axle
standing = [Wf, Wf, Wr, Wr] / 2;              % FL FR RL RR

%% A steady left turn at a_y = +1 g
% The load each axle moves from its left wheel to its right one. The page "Load
% transfer" derives this; here it is only summed, to see where it goes.
series = @(a, b) a .* b ./ (a + b);
m_u  = 4 * car.unsprungPerCorner;             % kg, unsprung
m_s  = car.massTotal - m_u;                   % kg, sprung
k_f  = series(car.wheelRateFront + car.arbFront, car.tireRateFront);   % N/mm, roll, at the wheel
k_r  = series(car.wheelRateRear  + car.arbRear,  car.tireRateRear);
K_f  = (k_f / mm) * (car.trackFront * mm)^2 / 2;                       % N*m/rad
K_r  = (k_r / mm) * (car.trackRear  * mm)^2 / 2;
K    = K_f + K_r;
h_rc = car.rcHeightFront + (car.rcHeightRear - car.rcHeightFront) * (1 - car.frontMassFrac);
h_ra = (car.cgHeight - h_rc) * mm;            % m, CG above the roll axis
G    = 1 / (1 - m_s * g * h_ra / K);          % the CG swinging outboard
h_u  = car.unsprungCgHeight * mm;

a_y = 1 * g;                                  % m/s^2, positive: the turn is to the left
dF  = a_y * (m_s * h_ra * G * K_f / K + m_s * car.frontMassFrac * car.rcHeightFront * mm ...
             + 2 * car.unsprungPerCorner * h_u) / (car.trackFront * mm);
dR  = a_y * (m_s * h_ra * G * K_r / K + m_s * (1 - car.frontMassFrac) * car.rcHeightRear * mm ...
             + 2 * car.unsprungPerCorner * h_u) / (car.trackRear * mm);
% Positive a_y puts the inertia force to the right (-y), so the right wheels gain.
left_turn = standing + [-dF, dF, -dR, dR];

% The body rolls towards the outside of the turn: right side down, positive roll.
roll_per_g = m_s * g * h_ra / K * G * 180 / pi;   % deg per g of a_y

%% Against the app
names = {'FL', 'FR', 'RL', 'RR'};
for i = 1:4
  pd_compare(sprintf('Standing, %s [N]', names{i}),       standing(i),  app.static.(names{i}));
end
for i = 1:4
  pd_compare(sprintf('Left turn at 1 g, %s [N]', names{i}), left_turn(i), app.leftTurn.(names{i}));
end
pd_compare('Front roll stiffness [N*m/deg]', K_f * pi / 180, app.rollRateFront);   % per radian -> per degree
pd_compare('Roll per g [deg/g]',             roll_per_g,      app.rollGradient);
pd_compare();

Further reading

• ISO 8855:2011, Road vehicles — Vehicle dynamics and road-holding ability — Vocabulary. The axes and angles used here.
• SAE J670 (2008), Vehicle Dynamics Terminology. The older SAE axes, with z down and y to the right.
• H. B. Pacejka, Tyre and Vehicle Dynamics, 3rd ed. (Butterworth-Heinemann, 2012), ch. 1. The tyre axis systems and the adapted SAE convention.
• W. F. Milliken and D. L. Milliken, Race Car Vehicle Dynamics (SAE, 1995), ch. 4, on vehicle axis systems.