### Yaw Rate Gain Analysis Setup in Python

Source: https://context7.com/ericcabrol/vehicledynamics/llms.txt

Initializes parameters for yaw rate gain analysis. This snippet sets up vehicle parameters like wheelbase and understeer gradient.

```python
import numpy as np
import matplotlib.pyplot as plt

# Vehicle parameters
L = 2.8       # Wheelbase (m)
K = 0.0035    # Understeer gradient (rad/(m/s^2))


```

--------------------------------

### Initialize Environment

Source: https://github.com/ericcabrol/vehicledynamics/blob/master/Pacejka_part1.ipynb

Imports necessary libraries for plotting and mathematical calculations.

```python
%matplotlib inline
import matplotlib.pyplot as plt
from math import sin, atan
import numpy as np
```

--------------------------------

### Bicycle Model Implementation in Python

Source: https://context7.com/ericcabrol/vehicledynamics/llms.txt

Calculates steady-state cornering parameters using the bicycle model. Requires vehicle parameters like wheelbase, mass, and cornering stiffness.

```python
import math
import numpy as np
import matplotlib.pyplot as plt

# Vehicle parameters
a = 1.2   # Distance from CoG to front axle (m)
b = 1.6   # Distance from CoG to rear axle (m)
m = 1500  # Vehicle mass (kg)
osr = 15  # Overall steering ratio
L = a + b # Wheelbase (m)

# Cornering stiffness values (N/rad)
Cf = 120000  # Front axle cornering stiffness
Cr = 180000  # Rear axle cornering stiffness

# Maneuver data
R = 80   # Turn radius (m)
V = 20   # Vehicle speed (m/s)

# Constants
rad2deg = 180 / math.pi
g = 9.81  # m/s^2

# Calculate mass distribution from static balance
mf = m * b / L  # Mass on front axle
mr = m * a / L  # Mass on rear axle

# Calculate lateral acceleration
ay = V**2 / R

# Calculate Ackermann angle (kinematic steering angle)
delta_ack = math.atan(L / R)

# Calculate slip angles
Fyf = mf * ay  # Lateral force on front axle (N)
Fyr = mr * ay  # Lateral force on rear axle (N)
alpha_f = Fyf / Cf  # Front slip angle (rad)
alpha_r = Fyr / Cr  # Rear slip angle (rad)

# Calculate understeer gradient
K = mf / Cf - mr / Cr  # rad/(m/s^2)

# Calculate characteristic speed (for understeering vehicle)
V_ch = math.sqrt(L / K) if K > 0 else None

# Calculate static margin
e = (a * Cf - b * Cr) / (Cf + Cr)
static_margin = e / L

print(f"Lateral acceleration: {ay:.2f} m/s^2 ({ay/g:.2f} g)")
print(f"Ackermann angle: {delta_ack * rad2deg:.2f}°")
print(f"Front slip angle: {alpha_f * rad2deg:.3f}°")
print(f"Rear slip angle: {alpha_r * rad2deg:.3f}°")
print(f"Understeer gradient: {K * rad2deg:.2f} °/(m/s^2) = {K * rad2deg * g:.2f} °/g")
print(f"Characteristic speed: {V_ch:.1f} m/s ({V_ch * 3.6:.1f} km/h)")
print(f"Static margin: {static_margin * 100:.2f}%")

# Output:
# Lateral acceleration: 5.00 m/s^2 (0.51 g)
# Ackermann angle: 2.00°
# Front slip angle: 2.045°
# Rear slip angle: 1.024°
# Understeer gradient: 0.20 °/(m/s^2) = 2.01 °/g
# Characteristic speed: 28.0 m/s (100.8 km/h)
# Static margin: -17.14%

```

--------------------------------

### Analyze Pacejka parameter sensitivity

Source: https://context7.com/ericcabrol/vehicledynamics/llms.txt

Visualizes how variations in parameters B, C, D, and E affect the tire force curve.

```python
from math import sin, atan
import numpy as np
import matplotlib.pyplot as plt

def pacejka(slip, B, C, D, E):
    return D * sin(C * atan(B * slip - E * (B * slip - atan(B * slip))))

# Base parameters
B_base, C_base, D_base, E_base = 0.171, 1.69, 4236, 0.619
slip = np.linspace(0, 100, 200)

fig, axes = plt.subplots(2, 2, figsize=(14, 10))

# Effect of D (peak factor) - controls maximum force
ax = axes[0, 0]
for D_val in [3500, 4000, 4500, 5000]:
    Fx = [pacejka(s, B_base, C_base, D_val, E_base) for s in slip]
    ax.plot(slip, Fx, label=f'D = {D_val}')
ax.set_xlabel('Slip (%)')
ax.set_ylabel('Force (N)')
ax.set_title('Effect of Peak Factor D\n(Higher D = Higher maximum force)')
ax.legend()
ax.grid(True)

# Effect of C (shape factor) - controls peak sharpness
ax = axes[0, 1]
for C_val in [1.3, 1.5, 1.7, 2.0]:
    Fx = [pacejka(s, B_base, C_val, D_base, E_base) for s in slip]
    ax.plot(slip, Fx, label=f'C = {C_val}')
ax.set_xlabel('Slip (%)')
ax.set_ylabel('Force (N)')
ax.set_title('Effect of Shape Factor C\n(Higher C = Sharper peak, faster force decay)')
ax.legend()
ax.grid(True)

# Effect of E (curvature factor) - controls post-peak behavior
ax = axes[1, 0]
for E_val in [-1.0, 0.0, 0.5, 0.9]:
    Fx = [pacejka(s, B_base, C_base, D_base, E_val) for s in slip]
    ax.plot(slip, Fx, label=f'E = {E_val}')
ax.set_xlabel('Slip (%)')
ax.set_ylabel('Force (N)')
ax.set_title('Effect of Curvature Factor E\n(Higher E = Flatter curve, E must be < 1)')
ax.legend()
ax.grid(True)
```

--------------------------------

### Visualize Pacejka Stiffness Factor B

Source: https://context7.com/ericcabrol/vehicledynamics/llms.txt

Plots the effect of the stiffness factor B on tire force generation using the Pacejka model.

```python
ax = axes[1, 1]
for B_val in [0.12, 0.17, 0.22, 0.30]:
    Fx = [pacejka(s, B_base, C_base, D_base, E_base) for s in slip]
    ax.plot(slip[:30], [pacejka(s, B_val, C_base, D_base, E_base) for s in slip[:30]],
            label=f'B = {B_val}')
ax.set_xlabel('Slip (%)')
ax.set_ylabel('Force (N)')
ax.set_title('Effect of Stiffness Factor B\n(Higher B = Steeper initial slope)')
ax.legend()
ax.grid(True)

plt.tight_layout()
plt.show()
```

--------------------------------

### Configure Plotting Data

Source: https://github.com/ericcabrol/vehicledynamics/blob/master/Pacejka_part1.ipynb

Sets up the slip ratio range and matplotlib figure dimensions.

```python
num_points=100
X = np.linspace(0,100,100)

plt.rcParams["figure.figsize"] = (8,6) # set fig size for matplotlib
```

--------------------------------

### Implement Pacejka Magic Formula

Source: https://context7.com/ericcabrol/vehicledynamics/llms.txt

Calculates longitudinal tire force using the 1987 Pacejka model and visualizes the force-slip curve.

```python
from math import sin, atan
import numpy as np
import matplotlib.pyplot as plt

def pacejka_tire_force(slip, B, C, D, E):
    """
    Calculate tire force using Pacejka Magic Formula.

    Parameters:
    - slip: Slip ratio (%) for longitudinal, or slip angle (deg) for lateral
    - B: Stiffness factor (controls initial slope)
    - C: Shape factor (controls peak sharpness)
    - D: Peak factor (maximum force value)
    - E: Curvature factor (controls post-peak behavior, must be < 1)

    Returns:
    - Force in Newtons
    """
    return D * sin(C * atan(B * slip - E * (B * slip - atan(B * slip))))

# Tire parameters for Fz = 4 kN (from Pacejka 1987 paper)
B = 0.171   # Stiffness factor
C = 1.69    # Shape factor
D = 4236    # Peak factor (N) - equals Fz * mu_max
E = 0.619   # Curvature factor

# Calculate longitudinal force vs slip ratio
slip_ratio = np.linspace(0, 100, 200)  # Slip ratio in %
Fx = np.array([pacejka_tire_force(s, B, C, D, E) for s in slip_ratio])

# Find peak force and corresponding slip
peak_idx = np.argmax(Fx)
peak_slip = slip_ratio[peak_idx]
peak_force = Fx[peak_idx]

print(f"Peak longitudinal force: {peak_force:.0f} N at {peak_slip:.1f}% slip")
print(f"Friction coefficient at peak: {peak_force / 4000:.3f}")

plt.figure(figsize=(10, 6))
plt.plot(slip_ratio, Fx, 'b-', linewidth=2)
plt.axhline(y=D, color='orange', linestyle='--', label=f'Peak factor D = {D} N')
plt.scatter([peak_slip], [peak_force], color='red', s=100, zorder=5, label=f'Peak at {peak_slip:.1f}%')
plt.xlabel('Slip Ratio (%)')
plt.ylabel('Longitudinal Force Fx (N)')
plt.title('Pacejka Magic Formula - Longitudinal Tire Force')
plt.legend()
plt.grid(True)
plt.show()
```

--------------------------------

### Calculate Basic Vehicle Kinematics

Source: https://github.com/ericcabrol/vehicledynamics/blob/master/bicycle_model.ipynb

Calculates and prints the lateral acceleration and steering angles based on vehicle dimensions and maneuver data. Requires Python 3.6+ for f-string formatting.

```python
%matplotlib inline
import matplotlib.pyplot as plt
import math
import numpy as np

# Vehicle data
a = 1.2  # m
b = 1.6  # m
m = 1500 # kg
osr = 15
L = a + b  # m

# Manoeuver data
R = 80   # m
V = 5    # m/s

rad2deg = 180/math.pi
g = 9.81 # m/s^2

ay = V**2 / R
δ_ack = math.atan(L/R)

# Caution : f-string  used here (only with Python 3.6+ - Switch to the older format function if required)

print()
print(f"{'Lateral acceleration':40} = {ay:.2f} m/s^2")
print(f"{'Ackermann angle at the wheel':40} = {δ_ack:.3f} rad.")
print(f"{'Angle at the steering wheel':40} = {δ_ack*osr*rad2deg:.1f} deg.")

```

--------------------------------

### Visualize Stiffness Factor B Variation

Source: https://github.com/ericcabrol/vehicledynamics/blob/master/Pacejka_part1.ipynb

Plots the longitudinal force Fx for varying values of B to observe changes in curve stiffness at low slip ratios.

```python
E=0.619 # reset
plt.figure()
i=0
for B in np.arange(0.12,0.33,0.03):
    i+=0.1
    plt.plot(X,np.vectorize(F)(X),color=(0.,0.,0.,i));
plt.gca().annotate('increasing B', xy=(5,3000), xytext=(7,2000),arrowprops=dict(facecolor='black'));
plt.xlim(0,15)
plt.title('Variation of Fx with stiffness factor B');
B=0.171 # reset
```

--------------------------------

### Visualize Peak Factor D Variation

Source: https://github.com/ericcabrol/vehicledynamics/blob/master/Pacejka_part1.ipynb

Demonstrates how varying the peak factor D affects the maximum force without changing the curve shape.

```python
plt.figure()
i=0
for D in np.arange(3500,5300,300):
    i+=0.1
    plt.plot(X,np.vectorize(F)(X),color=(0.,0.,1.,i));

plt.gca().annotate('increasing D', xy=(60,5000), xytext=(60,4000),arrowprops=dict(facecolor='black'));
plt.title('Variation of Fx with peak factor D');
D = 4236 # reset
```

--------------------------------

### Define Pacejka Formula

Source: https://github.com/ericcabrol/vehicledynamics/blob/master/Pacejka_part1.ipynb

Sets the tire parameters and defines the function F(x) based on the original Pacejka paper.

```python
# Definition of Pacejka parameters
# X : longitudinal slip
# B : stiffness factor
# C : shape factor
# D : peak factor
# E : curvature factor

B = 0.171
C = 1.69
D = 4236
E = 0.619

def F(x):
    return(D * sin(C * atan(B*x - E*(B*x - atan(B*x)))))
```

--------------------------------

### Demonstrate Invalid Curvature Factor

Source: https://github.com/ericcabrol/vehicledynamics/blob/master/Pacejka_part1.ipynb

Shows the physical impossibility of E > 1, resulting in negative tire forces at high slip.

```python
E=1.15 # impossible value 
plt.figure()
plt.plot(X,np.vectorize(F)(X));
plt.plot(X,np.linspace(0,0,num_points),linestyle='--',color='red');
plt.gca().annotate('Nobody wants this 
to happen on a car :)', xy=(65,-1000), xytext=(30,-2000),arrowprops=dict(facecolor='black'));
plt.title('Why E > 1 is impossible');
```

--------------------------------

### Lateral Acceleration Gain Calculation in Python

Source: https://context7.com/ericcabrol/vehicledynamics/llms.txt

Calculates and plots the vehicle's lateral acceleration gain per steering angle. Useful for tuning ESC systems. Requires vehicle parameters and speed.

```python
import numpy as np
import matplotlib.pyplot as plt

# Vehicle parameters (from bicycle model)
L = 2.8       # Wheelbase (m)
K = 0.0035    # Understeer gradient (rad/(m/s^2))
osr = 15      # Overall steering ratio
g = 9.81      # m/s^2
rad2deg = 180 / 3.14159

# Calculate lateral acceleration gain at specific speed
V = 20  # m/s

lateral_accel_gain = (V**2 / L) / (1 + K * V**2 / L)

print(f"At V = {V} m/s ({V * 3.6:.0f} km/h):")
print(f"Lateral acceleration gain: {lateral_accel_gain / rad2deg:.3f} (m/s^2)/°")
print(f"Lateral acceleration for 100° at steering wheel: {lateral_accel_gain / rad2deg / g * 100 / osr:.3f} g")

# Plot gain variation with speed
V_range = np.linspace(5, 50, 100)
ay_gain = (V_range**2 / L) / (1 + K * V_range**2 / L)
ay_per_100deg = ay_gain / rad2deg / g * 100 / osr

plt.figure(figsize=(10, 5))
plt.plot(V_range * 3.6, ay_per_100deg)
plt.xlabel('Speed (km/h)')
plt.ylabel('Lateral acceleration (g) for 100° steering')
plt.title('Lateral Acceleration Gain vs Speed')
plt.grid(True)
plt.show()

```

--------------------------------

### Visualize Curvature Factor E Variation

Source: https://github.com/ericcabrol/vehicledynamics/blob/master/Pacejka_part1.ipynb

Illustrates the effect of the curvature factor E on the flatness of the force curve.

```python
plt.figure()
i=0
for E in np.arange(-2.0,1.5,0.5):
    i+=0.1
    plt.plot(X,np.vectorize(F)(X),color=(1.,0.,1.,i));
plt.gca().annotate('increasing E', xy=(80,4000), xytext=(80,3000),arrowprops=dict(facecolor='black'));
plt.title('Variation of Fx with curvature factor E');
E=0.619 # reset
```

--------------------------------

### Calculate static margin

Source: https://github.com/ericcabrol/vehicledynamics/blob/master/bicycle_model.ipynb

Computes the static margin based on the distance from the center of gravity to the neutral steer point.

```python
distance_CoG_to_neutral_steer_point = (a*Cf-b*Cr)/(Cf+Cr)
print()
print(f"{'Static margin':40} = {distance_CoG_to_neutral_steer_point/L*100 :.2f} %")
```

--------------------------------

### Calculate Understeer Gradient

Source: https://github.com/ericcabrol/vehicledynamics/blob/master/bicycle_model.ipynb

Calculates the understeer gradient in degrees per (m/s^2) and degrees per g, both at the wheel and at the steering wheel. This metric indicates the vehicle's tendency to understeer or oversteer.

```python
K = mf/Cf - mr/Cr

print()
print(f"{'Understeer gradient at the wheel':40} = {K * rad2deg :.2f} °/(m/s^2)")
print(f"{'':40} = {K * rad2deg * g :.2f} °/g")
print()
print(f"{'Understeer gradient at the steering wheel':45} = {K * rad2deg * osr :.2f} °/(m/s^2)")
print(f"{'':45} = {K * rad2deg * g * osr :.2f} °/g")

```

--------------------------------

### Analyze Vehicle Handling Characteristics

Source: https://context7.com/ericcabrol/vehicledynamics/llms.txt

Calculates understeer gradient, critical speed, and static margin to classify vehicle behavior as understeer, oversteer, or neutral.

```python
import math
import numpy as np
import matplotlib.pyplot as plt

def analyze_vehicle_handling(name, m, a, b, Cf, Cr):
    """
    Analyze handling characteristics of a vehicle configuration.

    Parameters:
    - name: Vehicle configuration name
    - m: Total mass (kg)
    - a: Distance from CoG to front axle (m)
    - b: Distance from CoG to rear axle (m)
    - Cf: Front axle cornering stiffness (N/rad)
    - Cr: Rear axle cornering stiffness (N/rad)

    Returns:
    - Dictionary with handling parameters
    """
    L = a + b
    mf = m * b / L
    mr = m * a / L
    K = mf / Cf - mr / Cr  # Understeer gradient

    if K > 0:
        behavior = "Understeer"
        critical_speed = math.sqrt(L / K)
    elif K < 0:
        behavior = "Oversteer"
        critical_speed = math.sqrt(L / abs(K))
    else:
        behavior = "Neutral"
        critical_speed = float('inf')

    static_margin = (a * Cf - b * Cr) / ((Cf + Cr) * L)

    return {
        'name': name,
        'behavior': behavior,
        'K': K,
        'K_deg_per_g': K * 180 / math.pi * 9.81,
        'critical_speed_kmh': critical_speed * 3.6,
        'static_margin_pct': static_margin * 100
    }

# Define different vehicle configurations
vehicles = [
    # Understeer: front-heavy, soft front tires
    analyze_vehicle_handling("Front-heavy understeer", 1500, 1.2, 1.6, 120000, 180000),
    # Neutral steer
    analyze_vehicle_handling("Neutral steer", 1500, 1.4, 1.4, 150000, 150000),
    # Oversteer: rear-heavy, soft rear tires
    analyze_vehicle_handling("Rear-heavy oversteer", 1500, 1.6, 1.2, 180000, 120000),
]

print("Vehicle Handling Comparison")
print("=" * 70)
for v in vehicles:
    print(f"\n{v['name']}:")
    print(f"  Behavior: {v['behavior']}")
    print(f"  Understeer gradient: {v['K_deg_per_g']:.2f} °/g")
    print(f"  {'Characteristic' if v['behavior'] == 'Understeer' else 'Critical'} speed: {v['critical_speed_kmh']:.1f} km/h")
    print(f"  Static margin: {v['static_margin_pct']:.2f}%")
```

--------------------------------

### Visualize Shape Factor C Variation

Source: https://github.com/ericcabrol/vehicledynamics/blob/master/Pacejka_part1.ipynb

Shows how the shape factor C influences the peakiness of the tire force curve.

```python
plt.figure()
i=0
for C in np.arange(1.5,2.1,0.1):
    i+=0.1
    plt.plot(X,np.vectorize(F)(X),color=(1.,0.,0.,i));
plt.gca().annotate('increasing C', xy=(30,500), xytext=(40,1500),arrowprops=dict(facecolor='black'));
plt.title('Variation of Fx with shape factor C');
C=1.69 # reset
```

--------------------------------

### Plot lateral acceleration gain

Source: https://github.com/ericcabrol/vehicledynamics/blob/master/bicycle_model.ipynb

Visualizes the variation of lateral acceleration gain with respect to vehicle speed.

```python
V1 = np.linspace(10, 40, 100)
plt.plot(V1, (V1**2/L) / (1 + K*V1**2/L) / rad2deg / g * 100 / osr, label='ay for 100° SW');
plt.legend();
plt.xlabel('V (m/s)');
plt.ylabel('ay (g)');
```

--------------------------------

### Calculate yaw rate gain

Source: https://context7.com/ericcabrol/vehicledynamics/llms.txt

Computes and plots the yaw rate gain as a function of vehicle speed, identifying the characteristic speed.

```python
V_range = np.linspace(5, 50, 100)
yaw_rate_gain = (V_range / L) / (1 + K * V_range**2 / L)

# Find characteristic speed (where gain is maximum)
V_ch = np.sqrt(L / K)
max_gain = (V_ch / L) / (1 + K * V_ch**2 / L)

print(f"Characteristic speed: {V_ch:.1f} m/s ({V_ch * 3.6:.1f} km/h)")
print(f"Maximum yaw rate gain: {max_gain:.2f} s^-1")

plt.figure(figsize=(10, 5))
plt.plot(V_range * 3.6, yaw_rate_gain, label='Yaw rate gain')
plt.axvline(x=V_ch * 3.6, color='r', linestyle='--', label=f'Characteristic speed = {V_ch * 3.6:.0f} km/h')
plt.xlabel('Speed (km/h)')
plt.ylabel('Yaw rate gain (r/δ) [1/s]')
plt.title('Yaw Rate Gain vs Speed')
plt.legend()
plt.grid(True)
plt.show()
```

--------------------------------

### Determine Characteristic or Critical Speed

Source: https://github.com/ericcabrol/vehicledynamics/blob/master/bicycle_model.ipynb

Calculates and prints the characteristic speed (for understeer) or critical speed (for oversteer) in m/s and km/h. This speed is a stability indicator for the vehicle.

```python
print()
if K>=0:
    print(f"{'Characteristic speed':40} = {math.sqrt(L/K):.1f} m/s")
    print(f"{'':40} = {math.sqrt(L/K) * 3.6:.1f} km/h")
else:
    print(f"{'Critical speed':40} = {math.sqrt(L/abs(K)):.1f} m/s")
    print(f"{'':40} = {math.sqrt(L/abs(K)) * 3.6:.1f} km/h")

```

--------------------------------

### Calculate and plot yaw rate gain

Source: https://github.com/ericcabrol/vehicledynamics/blob/master/bicycle_model.ipynb

Computes the yaw rate gain and plots its variation against speed to identify the characteristic speed.

```python
yaw_rate_gain = (V/L) / (1 + K*V**2/L)
print()
print(f"{'Yaw rate gain':40} = {yaw_rate_gain :.2f} s^-1")
print()

# Let's plot this gain variation with speed
V1 = np.linspace(10, 40, 100)
plt.plot(V1, (V1/L) / (1 + K*V1**2/L), label='yaw rate gain');
plt.legend();
plt.xlabel('V (m/s)');
plt.ylabel(r'$r\ /\ \delta$');
```

--------------------------------

### Plot Base Pacejka Curve

Source: https://github.com/ericcabrol/vehicledynamics/blob/master/Pacejka_part1.ipynb

Visualizes the longitudinal force curve with a reference line for the peak factor D.

```python
plt.plot(X,np.vectorize(F)(X));

# horizontal line at the max value for visualization purpose only
plt.plot(X,np.linspace(D,D,num_points),linestyle='--',color='orange');
```

--------------------------------

### Calculate Lateral Acceleration Gain

Source: https://github.com/ericcabrol/vehicledynamics/blob/master/bicycle_model.ipynb

Calculates the lateral acceleration gain, which represents the ratio of lateral acceleration to steering wheel angle. It's expressed in (m/s^2)/° and g/°. Also calculates the lateral acceleration for a 100° steering wheel input.

```python
lateral_accel_gain = (V**2/L) / (1 + K*V**2/L)
print()
print(f"{'Lateral acceleration gain':40} = {lateral_accel_gain / rad2deg :.2f} (m/s^2)/°")
print(f"{'':40} = {lateral_accel_gain / rad2deg / g :.3f} g/°")
print()
print(f"{'Lateral acceleration for 100° at the SW':40} = {lateral_accel_gain / rad2deg / g * 100 / osr :.3f} g")

```

--------------------------------

### Calculate Slip Angles and Forces at Higher Speed

Source: https://github.com/ericcabrol/vehicledynamics/blob/master/bicycle_model.ipynb

Calculates lateral forces and slip angles at front and rear axles for a vehicle at a higher speed, considering cornering stiffness. Assumes axle properties are aggregated at the axle center.

```python
Cf = 120000 # N/rad
Cr = 180000 # N/rad

# From the static balance we have 
mf = m * b / L
mr = m * a / L

# Let's increase the speed to reach a non-negligible lateral acceleration
V = 20 # m/s
# Recompute
ay = V**2 / R
# So
Fyf = mf * ay
Fyr = mr * ay

# The slip angles at the front and rear axle are 
αf = Fyf / Cf
αr = Fyr / Cr

print()
print(f"{'Lateral acceleration':40} = {ay:.2f} m/s^2")
print(f"{'Mass on the front axle':40} = {mf:.1f} kg")
print(f"{'Mass on the rear axle':40} = {mr:.1f} kg")
print(f"{'Lateral force on the front axle':40} = {Fyf:.0f} N")
print(f"{'Lateral force on the rear axle':40} = {Fyr:.0f} N")
print(f"{'Slip angle at the front axle':40} = {αf:.3f} rad")
print(f"{'Slip angle at the rear axle':40} = {αr:.3f} rad")

```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.