Relaxation length

Steer a wheel and its side force does not arrive at once. The tread in the contact patch has to be pulled sideways first, and the tyre pulls it by rolling: fresh tread enters the patch at the leading edge already displaced, and the old tread leaves at the back. So the force builds over a length of road, the relaxation length $\sigma$. On a race tyre it is about the tyre's radius. The quasi-steady models leave it out; the transient car runs with it.

Lag over distance

The slip angle the tyre runs at, ${\alpha }^{\prime }$, the one its force is read at, follows the slip angle the geometry gives it, $\alpha$, as a first-order lag in the distance rolled:

After a step the tyre has made up 63 % of the new slip angle in one relaxation length and 95 % in three: about two-thirds of a metre of road on this car, whatever its speed. In time the lag shrinks as the car goes faster. Written as a time constant, the front tyres' 0.22 m at rest is 21.8 ms at 10 m/s but 8.7 ms at 25 m/s.

Where it matters

Because the lag is a length of road, what decides whether it matters is how fast the steer changes along the road. On a sweeper the steer changes over tens of metres and a fifth of a metre is nothing. Steered to and fro over a wavelength $\lambda$, as through a slalom, the tyre's slip angle lags the geometry's by a fixed share of the wavelength, at any speed:

Through cones every 15 m, half a wavelength apart, the front tyres keep almost all their force but deliver it 5° late. Late force is what the car's yaw responds to. The driver feels it as the car following the wheel a little behind, and steers further ahead to make up for it.

The template through a steer

Fig. 2 is the app's transient car running straight and given 2° of road-wheel steer at once, at two speeds. The front tyre's geometric slip angle jumps with the steer and then falls back as the car takes up its yaw. The slip angle the tyre runs at rises after it and catches it about a relaxation length later. Plotted against distance, the two speeds' lags start almost together, as equation (1) says. The faster one builds a little more slowly: the downforce at 25 m/s has stretched the front-left's length to 0.271 m, against 0.229 m at 10 m/s. Later they part, because the car's own yaw response is a matter of time, not distance.

The app steps equation (2) exactly over each integration step, with the geometric slip angle, the speed and the length held for the step. The length is each wheel's own: its axle's tyre's, read at the load the wheel carries that step.

The worked line is the front-left's first step. Its length is longer than at rest because the downforce at 10 m/s adds to its load. Over the next 2 m it shortens to 0.188 m as the wheel, on the inside of the turn, unloads. The rear-left's runs from 0.248 m to 0.209 m in the same way.

An explicit Euler step would need $\mathrm{\Delta }t$ well under $\sigma /v$ to stay stable, which at 25 m/s is 8.7 ms. The exact step is stable at any speed.

How long it is

The length comes from the tyre's carcass. A lateral carcass stiffness $K_y$ in series with the tread makes the force build as the carcass deflects, and the length is the ratio of the two stiffnesses:

Step-steer tests measure $K_y$: the rig steers the tyre standing, rolls it forward at walking pace, and the force arrives over the length. Without them the app takes $K_y$ at 0.87 of the tyre's vertical rate, the median of the tyres in its library that measured both, and says the length is derived, not measured. The template's tyre states no length but a vertical rate of 110 N/mm, so the car derives each axle's length from its own tyre. The worked line reads them at the static loads, 692 N on a front wheel and 780 N on a rear. The rear is longer because it carries more of the weight.

The length grows with load as the cornering stiffness does, because the carcass under it does not. A wheel that lifts has next to no cornering stiffness and so next to no length: its tyre follows its slip almost at once. Only a tyre that states neither a length nor a vertical rate runs a flat 0.30 m, an ordinary figure for a Formula Student tyre and nothing more.

What the model assumes

• One lag on the slip angle, the same at every slip. Pacejka's fuller models lag the carcass deflection itself and shorten the length as the tyre nears its peak; the app does not.
• The slip ratio is not lagged. The transient car sets each wheel's drive or brake force rather than spinning the wheel up.
• Each wheel's length is its axle's tyre's at that wheel's load. The app reads it from a table of the tyre's law, within 3e-5 of the law itself, and holds it over the step.
• Where nothing measured the carcass, its lateral stiffness is 0.87 of the vertical rate: the median over many tyres, not this tyre's own.
• The quasi-steady lap and the grip envelope are steady states and take no lag at all.

In the app

Check it yourself

example_step.m records the app's transient car through the step at 10 m/s: before each integration step, the geometric slip angle at the front-left and rear-left tyres, the length each lags by at its load that step, and the forward speed. The script rebuilds the lagged slip angles from those alone with equation (4), and compares them with the app's at eight steps along the run. It also derives each axle's length at rest from the tyre in example_tyre.m with equation (5), and compares it with the app's.

>> relaxation_length

Lateral carcass 0.87 x 110 N/mm = 95.7 N/mm. At rest the relaxation length is
0.218 m front (692 N a wheel) and 0.239 m rear (780 N): at 10 m/s the front's
is a time constant of 21.8 ms.

      step    s [m] FL sigma [m]   FL alpha [deg]  FL alpha' [deg]
         1    0.010        0.229            2.017            0.086
         5    0.050        0.228            1.987            0.395
        10    0.100        0.227            1.893            0.702
        20    0.200        0.224            1.588            1.078
        40    0.400        0.208            0.870            1.141
        80    0.799        0.189            0.216            0.443
       120    1.198        0.213            0.362            0.312
       200    1.994        0.206            0.407            0.422

  The geometric slip angle jumps with the steer and then falls as the car yaws; the
  one the tyre runs at trails it by about a relaxation length of road. The inside
  front unloads as the car turns, and its length shortens with its load.

  Quantity                                This script   PaceDynamics       Diff
  -----------------------------------------------------------------------------
  Relaxation length at rest, front [m]        0.21827        0.21827         0% 
  Relaxation length at rest, rear [m]        0.238556       0.238556         0% 
  FL lagged slip after   1 steps [rad]      0.0015054      0.0015054         0% 
  FL lagged slip after   5 steps [rad]     0.00689573     0.00689573         0% 
  FL lagged slip after  10 steps [rad]      0.0122528      0.0122528         0% 
  FL lagged slip after  20 steps [rad]      0.0188221      0.0188221         0% 
  FL lagged slip after  40 steps [rad]      0.0199181      0.0199181         0% 
  FL lagged slip after  80 steps [rad]     0.00773142     0.00773142         0% 
  FL lagged slip after 120 steps [rad]     0.00543878     0.00543878         0% 
  FL lagged slip after 200 steps [rad]     0.00736428     0.00736428         0% 
  RL lagged slip after   1 steps [rad]   -1.68594e-07   -1.68594e-07         0% 
  RL lagged slip after   5 steps [rad]    2.24722e-06    2.24722e-06         0% 
  RL lagged slip after  10 steps [rad]    3.34854e-05    3.34854e-05         0% 
  RL lagged slip after  20 steps [rad]    0.000295823    0.000295823         0% 
  RL lagged slip after  40 steps [rad]     0.00197941     0.00197941         0% 
  RL lagged slip after  80 steps [rad]     0.00779057     0.00779057         0% 
  RL lagged slip after 120 steps [rad]     0.00991981     0.00991981         0% 
  RL lagged slip after 200 steps [rad]     0.00730255     0.00730255         0% 

  All 18 quantities agree with PaceDynamics (largest difference 0 %).

%% Relaxation length: a tyre builds its force over distance, not time
%
% Companion to the documentation page "Relaxation length". Runs unchanged in GNU Octave
% (7 or later) and MATLAB. Run:
%
%   >> relaxation_length
%
% A tyre steered to a new slip angle alpha does not make the new force at once: its
% carcass has to deflect first, and it does so as it rolls. The slip angle it runs at,
% alpha', follows the one the geometry gives it as a first-order lag in the distance
% rolled, s:
%
%   sigma d(alpha')/ds = alpha - alpha'
%
% sigma is the relaxation length. Per unit time, ds = v dt, so the time constant is
% sigma / v: the same lag takes a third of the time at three times the speed.
%
% Over one step dt with alpha and v held, the lag is solved exactly:
%
%   alpha'(t + dt) = alpha + (alpha'(t) - alpha) exp(-v dt / sigma)
%
% which is how the app's transient car steps it. sigma is each wheel's own: its axle's
% tyre's length at the load the wheel carries that step, held over the step.
%
% How long it is: the cornering stiffness over the carcass's lateral stiffness,
%
%   sigma = C_alpha(F_z) / K_y
%
% Where no step-steer test measured K_y, the app takes it at 0.87 of the tyre's vertical
% rate, the median of the tyres in its library that measured both, and says the length is
% derived. The length grows with load as the cornering stiffness does.
%
% This script derives each axle's length at rest from the tyre, and rebuilds the lagged
% slip angles from the geometric ones and the lengths the app recorded on its own car,
% through a steer step.
%
% Reference: H. B. Pacejka, Tyre and Vehicle Dynamics, 3rd ed. (Butterworth-Heinemann,
% 2012), ch. 7.1.
%
% Part of the PaceDynamics documentation, https://pacedyn.dev/docs
% SPDX-License-Identifier: MIT

[step, lag] = example_step();
t = example_tyre();
n = numel(step.vx);
deg = pi / 180;

%% How long: each axle's length at rest, sigma = C_alpha / K_y
% The cornering stiffness as the app reads it, from a difference across +-0.1 deg.
axles = {'front', 'rear'};
Ky = step.lateralOverVertical * step.verticalRate * 1000;   % N/m
sigma0 = zeros(1, numel(axles));
for k = 1:numel(axles)
  Fz = step.load.(axles{k});
  Fy = @(a) getfield(pd_mf(t, Fz, a, 0), 'Fy0');
  e = 0.1 * deg;
  sigma0(k) = abs((Fy(e) - Fy(-e)) / (2 * e)) / Ky;
end
fprintf('\nLateral carcass %g x %g N/mm = %.1f N/mm. At rest the relaxation length is\n', step.lateralOverVertical, step.verticalRate, Ky / 1000);
fprintf('%.3f m front (%.0f N a wheel) and %.3f m rear (%.0f N): at %g m/s the front''s\n', sigma0(1), step.load.front, sigma0(2), step.load.rear, step.speed);
fprintf('is a time constant of %.1f ms.\n', 1000 * sigma0(1) / step.speed);

%% The lag, step by step, each wheel at its own length
fl = zeros(1, n + 1);                       % straight running: nothing to lag
rl = zeros(1, n + 1);
for i = 1:n
  v = abs(step.vx(i));
  fl(i + 1) = step.slipFL(i) + (fl(i) - step.slipFL(i)) * exp(-(v / step.sigmaFL(i)) * step.dt);
  rl(i + 1) = step.slipRL(i) + (rl(i) - step.slipRL(i)) * exp(-(v / step.sigmaRL(i)) * step.dt);
end

s = [0, cumsum(step.vx * step.dt)];          % distance rolled [m]
fprintf('\n  %8s %8s %12s %16s %16s\n', 'step', 's [m]', 'FL sigma [m]', 'FL alpha [deg]', 'FL alpha'' [deg]');
for i = lag.at
  j = min(i + 1, n);
  fprintf('  %8d %8.3f %12.3f %16.3f %16.3f\n', i, s(i + 1), step.sigmaFL(j), step.slipFL(j) * 180 / pi, fl(i + 1) * 180 / pi);
end
fprintf('\n  The geometric slip angle jumps with the steer and then falls as the car yaws; the\n');
fprintf('  one the tyre runs at trails it by about a relaxation length of road. The inside\n');
fprintf('  front unloads as the car turns, and its length shortens with its load.\n');

%% Against the app
pd_compare('Relaxation length at rest, front [m]', sigma0(1), lag.sigma.front);
pd_compare('Relaxation length at rest, rear [m]', sigma0(2), lag.sigma.rear);
for k = 1:numel(lag.at)
  pd_compare(sprintf('FL lagged slip after %3d steps [rad]', lag.at(k)), fl(lag.at(k) + 1), lag.FL(k));
end
for k = 1:numel(lag.at)
  pd_compare(sprintf('RL lagged slip after %3d steps [rad]', lag.at(k)), rl(lag.at(k) + 1), lag.RL(k));
end
pd_compare();

Further reading

• H. B. Pacejka, Tyre and Vehicle Dynamics, 3rd ed. (Butterworth-Heinemann, 2012), ch. 5 and 7, on the string model and the relaxation length.
• W. F. Milliken and D. L. Milliken, Race Car Vehicle Dynamics (SAE, 1995), ch. 2, on tyre lag.