Simulation
physique.

• Simuler n’importe quel mouvement dont on connaît l’accélération.
• Choisir un pas de temps et comprendre son effet sur la précision.
• Comparer une simulation à la formule exacte quand elle existe.
• Simuler un robot avec inertie, ce qui explique pourquoi il dépasse sa cible.

Physique de collège suffisante : vitesse = distance / temps. Le reste est construit ici.

L’accélération est le taux de variation de la vitesse, comme la vitesse est celui de la position. Deux lignes, dans cet ordre : mettre à jour v avec a, puis x avec v. C’est la méthode d’Euler (1768), la plus simple des méthodes d’intégration numérique. Elle est approchée : entre deux pas, on suppose la vitesse constante alors qu’elle change. L’erreur diminue avec dt. En prépa, vous apprendrez que cette méthode résout des équations différentielles, et que cette version « v d’abord, puis x » (Euler semi-implicite) est bien meilleure que « x d’abord » pour la physique.

Diviser dt par 10 divise l’erreur par 10 environ : Euler est d’ordre 1. Mais cela multiplie le nombre de pas par 10. Pour un jeu vidéo à 60 images/s, dt = 1/60 suffit. Pour une trajectoire de sonde spatiale, on utilise des méthodes d’ordre 4 (Runge-Kutta) qui divisent l’erreur par 10 000 quand dt est divisé par 10. Un robot réel a un pas de temps imposé : celui de sa boucle de contrôle (souvent 10 à 100 ms).

a = F / m : l’accélération est la somme des forces divisée par la masse. Le simulateur n’a pas besoin de connaître la trajectoire, seulement les forces à chaque instant. Ajoutez une force, la trajectoire change toute seule. La vitesse limite est atteinte quand le frottement compense le poids : un parachutiste tombe à 200 km/h sans parachute, 20 km/h avec. Le v * abs(v) donne un signe correct dans les deux sens (frottement quadratique).

Sans frottement, 45° est optimal et 30° donne la même portée que 60° (symétrie, formule v₀² sin(2α)/g). Avec frottement, l’angle optimal descend vers 35–40°, et il n’existe aucune formule fermée : la simulation est le seul moyen d’obtenir ce résultat. C’est le cas de presque tous les problèmes réels. On a utilisé max(range, key=...) pour chercher le meilleur angle par force brute : 40 simulations, instantané.

Chaque rebond multiplie la vitesse par e, donc la hauteur par e² et la durée du vol par e. Les intervalles forment une suite géométrique de raison e = 0,8 : la simulation le retrouve à 1 % près. Somme des intervalles = durée totale avant l’arrêt = finie, bien qu’il y ait une infinité de rebonds (série géométrique, prépa). Le test if y < 0 détecte un événement : un robot qui touche un mur, un bouton pressé. La gestion d’événements dans une boucle à pas fixe est une compétence centrale.

Couper les moteurs à la cible ne suffit pas : le robot a une vitesse, et le frottement met du temps à l’arrêter. Il dépasse. Un vrai robot doit anticiper : freiner avant. Le contrôleur est la fonction commande : elle lit l’état (x, v) et décide de la force. Toute la partie E consiste à écrire de bonnes fonctions commande.

kp faible : pas de dépassement mais lent. kp fort : rapide mais oscille autour de la cible. Ajouter un terme en −kd·v (freiner d’autant plus qu’on va vite) supprime l’oscillation : c’est un contrôleur PD. Il manque un « I » pour compenser une erreur qui persiste (une pente, par exemple) : ce sera le PID complet de la séance 29. Vous venez de simuler en 30 lignes ce que fait un drone pour tenir sa position.

Un ressort sans frottement oscille éternellement : l’énergie passe de la forme « ressort tendu » à « masse en mouvement » et retour. Avec Euler « x d’abord », l’énergie augmenterait à chaque tour et la simulation exploserait. Avec « v d’abord » (ce qu’on fait ici), elle reste bornée : c’est une méthode symplectique, découverte bien après Euler, et c’est celle des simulateurs de systèmes solaires. Un accéléromètre ou une suspension de voiture sont des masses-ressorts ; les vibrations d’un robot aussi.

def percute(distance, v0=1.5, f=3.0, m=2.0, reaction=0.1):
    x, v, t = 0.0, v0, 0.0
    while v > 0:
        a = -f / m if t >= reaction else 0.0
        v = max(0.0, v + a * dt)
        x += v * dt
        t += dt
        if x >= distance:
            return v
    return 0.0

print("Obstacle à 1 m   :", round(percute(1.0), 2), "m/s à l'impact (0 = arrêt avant)")
print("Obstacle à 0.8 m :", round(percute(0.8), 2), "m/s à l'impact")
bas, haut = 0.0, 5.0
while haut - bas > 0.001:
    mil = (bas + haut) / 2
    if percute(mil) > 0: bas = mil
    else: haut = mil
print("Distance de détection minimale :", round(haut, 3), "m")
print("Formule : v0*réaction + v0²/(2a) =", round(1.5 * 0.1 + 1.5 ** 2 / (2 * 1.5), 3))

À 1 m, le robot s’arrête juste avant l’obstacle (à 10 cm) ; à 0,8 m il le percute à ≈ 0,55 m/s. Distance minimale ≈ 0,9 m. La dichotomie sur une simulation est un outil puissant : on ne sait pas inverser la simulation, mais on sait chercher. Ici une formule existe (distance de réaction + distance de freinage) et confirme.

def orbite(v0, duree=7200):
    x, y = r0, 0.0
    vx, vy = 0.0, v0
    r_min = r_max = r0
    for _ in range(int(duree / dt)):
        r = math.hypot(x, y)
        a = -GM / r ** 3                  # a_x = -GM x / r³ : vecteur vers le centre
        vx += a * x * dt; vy += a * y * dt
        x += vx * dt; y += vy * dt
        r_min, r_max = min(r_min, r), max(r_max, r)
    return r_min / 1000, r_max / 1000

for facteur in (1.0, 1.2, 1.5):
    print(facteur, [round(r) for r in orbite(v_circ * facteur)])

À v circulaire, r reste à 7000 km (± quelques km : l’erreur d’Euler). À 1,2 v, l’apogée monte à 18 000 km. À 1,5 v > √2 v, le satellite ne revient pas. Vous venez de reproduire les lois de Kepler et l’orbite de l’ISS avec 15 lignes. Remarquez -GM / r³ multiplié par x et y : c’est la façon élégante d’écrire un vecteur de norme GM/r² pointant vers le centre.

def periode(theta0_deg):
    theta = math.radians(theta0_deg)
    omega = 0.0
    t = 0.0
    passages = []
    while len(passages) < 3 and t < 60:
        alpha = -(g / L) * math.sin(theta)
        omega += alpha * dt
        theta_avant = theta
        theta += omega * dt
        t += dt
        if theta_avant > 0 >= theta:        # passage descendant par 0
            passages.append(t)
    return passages[2] - passages[1]

T0 = 2 * math.pi * math.sqrt(L / g)
print("T0 =", round(T0, 4))
for a in (5, 30, 60, 90, 120, 150, 170):
    T = periode(a)
    print(f"{a:4}° : T = {T:.4f}  T/T0 = {T / T0:.4f}  " + "#" * int(40 * (T / T0 - 1)))

T/T₀ vaut 1,0005 à 5°, 1,017 à 30°, 1,18 à 90°, 2,4 à 170°. L’approximation dépasse 1 % d’erreur vers 23°. À 179,9°, la période devient énorme : le pendule reste longtemps quasi immobile en haut (équilibre instable). Avec assez de vitesse, il tourne : le mouvement n’est plus périodique au même sens. La période exacte fait intervenir une intégrale elliptique sans formule fermée : la simulation est ici plus puissante que le calcul. Ce problème est un classique d’oral de l’X.