Laboratoire 6¶

Dans ce laboratoire, nous allons étudier des phénomènes ondulatoires, en simulant le comportement d’une corde élastique soumise à des perturbations.

Modélisation¶

On souhaite simuler le mouvement d’une corde élastique tendue entre deux points, dans un espace à deux dimensions. Pour modéliser ce système, nous allons considérer que cette corde est constituée d’un certain nombre \(N + 1\) de petites masses ponctuelles reliées par des ressorts. (Plus la valeur de \(N\) sera grande, plus la simulation sera précise.) La figure suivante illustre cette modélisation:

Modélisation de la corde.

Principes:

Notons \(p_i = (x_i, y_i)\) la position dans le plan de chaque point, pour \(i = 0, 1, \ldots, N\). Entre deux points successifs, la distance horizontale \(\Delta\) est identique; on a donc \(x_i = i \Delta\).
Pour \(i = 1, 2, \ldots, N-1\) (le cas des extrémités de la corde est particulier et sera traité plus tard), les forces agissant sur le point \(i\) sont:
- l’attraction \(\vec{f_{i,G}} = k\, \overrightarrow{p_i p_{i-1}}\) du ressort situé à sa gauche, et
- l’attraction \(\vec{f_{i,D}} = k\, \overrightarrow{p_i p_{i+1}}\) du ressort situé à sa droite,
où \(k\) est la raideur de chaque ressort.

Notes:
- On ne représente pas l’effet exercé par la gravité sur la corde.
- On ajoutera plus tard à ce modèle un mécanisme d’amortissement afin de le rendre plus réaliste.
La résultante des forces agissant sur le point \(p_i = (x_i, y_i)\), pour \(i = 1, 2, \ldots, N-1\), vaut donc:
- \(f_{i,X} = -k \Delta + k \Delta = 0\) selon l’axe horizontal.
- \(f_{i,Y} = k(y_{i-1} - y_i) + k(y_{i+1} - y_i) = k(y_{i-1} + y_{i+1} -2y_i)\) selon l’axe vertical.
La conséquence du premier résultat est que la position horizontale \(x_i\) de \(p_i\) reste constante. Pour déterminer comment sa position verticale \(y_i\) évolue avec le temps, on peut appliquer la deuxième loi de Newton:

\(f_{i, Y} = m \ddot{y}_i\),

où
- \(m\) est la masse de \(p_i\),
- \(\ddot{y}_i\) est l’accélération subie par \(p_i\) selon l’axe vertical, en d’autres termes \(\displaystyle\ddot{y}_i = \frac{\partial^2y_i}{\partial t^2}\).
  
  Note: Dans l’expression précédente, on utilise le symbole de dérivée partielle \(\partial\) car \(y_i\) peut être vue comme une fonction des deux variables suivantes:
  - La position horizontale \(x\) sur la corde. (La dérivée de \(y_i\) par rapport à cette variable correspond à la pente de la corde au point \(p_i\).)
  - Le temps \(t\). (La derivée de \(y_i\) par rapport à cette variable correspond à la vitesse verticale du point \(p_i\).)
On obtient donc:

\(\displaystyle\ddot{y}_i = \frac{k}{m}(y_{i-1} + y_{i+1} -2y_i)~~~(1)\)
En pratique, les valeurs de \(k\) et de \(m\) ne sont pas directement connues, car elles dépendent du nombre \(N\) choisi pour discrétiser la corde, qui n’a pas d’existence physique. Il est plus commode d’exprimer la valeur de ces deux variables en fonction de:
- la force de tension \(T\) appliquée à la corde. Etant donné que, lorsque la corde est à l’équilibre, cette force est exercée par chaque ressort lorsqu’il est étiré à la longueur \(\Delta\), on a par la loi de Hooke \(T = k\Delta\), qui donne:
  
  \(\displaystyle k = \frac{T}{\Delta}~~~~~(2)\)
- la densité linéaire \(\mu\) de la corde, c’est-à-dire sa masse par unité de longueur (exprimée en kilogrammes par mètre). La masse \(m\) d’un segment de corde de longueur \(\Delta\) vaut alors:
  
  \(m = \mu \Delta~~~(3)\)
En introduisant \((2)\) et \((3)\) dans \((1)\), on obtient:

\(\displaystyle\ddot{y}_i = \frac{T}{\mu\Delta^2}(y_{i-1} + y_{i+1} -2y_i)~~~(4)\)
Dans l’expression précédente, le terme

\(\displaystyle\frac{y_{i-1} + y_{i+1} -2y_i}{\Delta^2}\)

approxime la dérivée seconde \(\displaystyle\frac{\partial^2 y}{\partial x^2}\) de \(y\) par rapport à \(x\). En effet, la derivée de \(y\) par rapport à \(x\) est approximée par
- \(\displaystyle\frac{y_i - y_{i-1}}{\Delta}\) en \(x = x_i\),
- \(\displaystyle\frac{y_{i+1} - y_{i}}{\Delta}\) en \(x = x_{i+1}\).
La dérivée de cette dérivée vaut alors:

\(\displaystyle \frac{\partial^2 y}{\partial x^2} \approx \frac{(y_{i+1} - y_{i}) - (y_i - y_{i-1})}{\Delta^2} = \frac{y_{i-1} + y_{i+1} -2y_i}{\Delta^2}~~~(5)\).

En remplaçant \((5)\) dans \((4)\), on obtient:

\(\displaystyle\frac{\partial^2y_i}{\partial t^2} = \frac{T}{\mu} \frac{\partial^2 y}{\partial x^2}~~~(6)\)
L’équation différentielle \((6)\) est un cas particulier de l’équation

\(\displaystyle\frac{\partial^2y_i}{\partial t^2} = v^2 \frac{\partial^2 y}{\partial x^2}\)

appelée équation d’onde. On peut montrer que la solution générale de cette équation prend la forme de deux signaux quelconques se propageant respectivement vers la gauche et vers la droite, tous deux à la vitesse \(v\). (Pour plus d’informations, voir par exemple cette référence ou celle-ci.)

Dans notre cas, nous nous attendons donc à observer des signaux se propageant sur la corde à la vitesse \(\displaystyle v = \sqrt{\frac{T}{\mu}}\). Dans la section suivante, vous allez développer un outil de simulation permettant de réaliser cette expérience.

Outil de simulation¶

L’objectif consiste à construire un programme qui simule en temps réel le mouvement de la corde. Pour ce faire, vous allez fixer la valeur de \(N\), par exemple à \(N = 100\), et appliquer répétitivement l’équation \((4)\) pour calculer le mouvement de chaque point.

Avant de commencer, il reste un détail à préciser. Dans la section précédente, nous n’avons pas abordé le calcul du mouvement des points situés aux extrémités de la corde, c’est-à-dire \(p_0 = (0, y_0)\) et \(p_N = (N \Delta, y_N)\). Plusieurs choix sont possibles; par exemple, forcer \(y_0 = y_N = 0\) revient à modéliser une corde tendue entre deux points fixes. Dans un premier temps, afin de pouvoir facilement observer des comportements intéressants, notre choix sera légèrement différent:

La position verticale \(y_0\) de l’extrémité gauche de la corde sera déterminée sur base des mouvements de la souris, afin de disposer d’un mécanisme simple pour exciter la corde.
A l’extrémité droite de la corde, on aura \(y_N = 0\), représentant une corde fixée à un objet immobile.

Procédure à suivre:

Ecrire un programme Python basé sur Pygame qui ouvre une fenêtre et la peint dans une couleur de fond de votre choix. Vous pouvez par exemple utiliser comme point de départ le programme donné à la fin du guide rapide de Python et Pygame, que vous pouvez recopier dans un nouveau fichier prog-15.py.
La boucle principale de ce programme n’est pas adaptée à une simulation en temps réel. En effet, cette boucle contient l’instruction pygame.event.wait() qui attend qu’un évènement soit produit par l’utilisateur avant d’y réagir. Dans notre cas, nous souhaitons que le simulateur continue à calculer les mouvements de la corde même si l’utilisateur reste inactif et ne déclenche aucun évènement.

Nous allons donc utiliser un autre mécanisme, qui permet d’effectuer un nombre donné d’itérations de la boucle principale par seconde, même en l’absence d’évènements produits par l’utilisateur. Ce mécanisme est illustré dans le fragment de code suivant:
```
images_par_seconde = 25
horloge = pygame.time.Clock()

while True:
    for evenement in pygame.event.get():
        if evenement.type == pygame.QUIT:
            pygame.quit()
            sys.exit();

    # Autres opérations de la boucle principale ...
    # ...

    pygame.display.flip()
    horloge.tick(images_par_seconde)
```
Dans ce code, l’expression pygame.event.get() retourne la liste des évènements survenus depuis le dernier appel à cette fonction. Dans le cas d’une absence d’évènement, l’évaluation de cette expression n’est pas bloquante comme l’était celle de pygame.event.wait(), mais retourne une liste vide. Dans la suite du code, une boucle for traite séparément tous les évènements recueillis à chaque itération de la boucle principale.

La dernière instruction horloge.tick(images_par_seconde) de la boucle principale met le programme en attente pendant un délai calculé de façon à ce que le nombre d’itérations par seconde ne dépasse pas la valeur fournie en argument (25 dans le cas présent).
Ajouter au programme un mécanisme permettant de retenir et d’afficher la configuration de la corde. Le plus simple consiste à gérer des tableaux hauteur_corde et vitesse_corde retenant pour chaque indice \(i\) dans l’intervalle \([0, N]\) la coordonnée verticale \(y_i\) et la vitesse verticale \(\dot{y}_i\) du point correspondant. Initialement, on peut fixer \(y_i = \dot{y}_i = 0\) pour tout \(i\). Il est conseillé d’attribuer la valeur 100 à \(N\).

Pour afficher la corde, le plus simple consiste à appeler une fonction dédiée afficher_corde() à chaque itération de la boucle principale. Cette fonction peut simplement visualiser chaque point sous la forme d’un petit disque, et relier les points voisins par des segments de droite. L’idée est d’arriver à un affichage similaire à celui-ci:

Affichage de la corde.

Notes:
- Dans cet exemple, la corde a été mise en mouvement afin que les segments reliant les points soient bien visibles. A ce stade, votre programme doit afficher une corde entièrement horizontale.
- Pour pouvoir effectuer les calculs avec des unités conventionnelles (longueurs en mètres, masses en kilogrammes, temps en secondes et forces en Newton), les hauteurs \(y_i\) seront exprimées en mètres. Pour convertir ces hauteurs en pixels en vue de les afficher, on se basera sur les consignes suivantes:
  - Les pixels sont carrés. En d’autres termes, un déplacement horizontal ou vertical du même nombre de pixels représente la même longueur.
  - La largeur de la fenêtre corrrespond à une distance totale de 1 mètre.
  - Une hauteur de corde égale à zéro correspond à la moitié de la hauteur de la fenêtre (comme l’extrémité droite de la corde dans la figure précédente).
  - Les hauteurs positives représentent un déplacement vers le haut. (Rappel: Dans le système de coordonnées de la fenêtre, l’axe vertical est orienté de haut en bas.)
Modifier le programme de façon à ce que les mouvements de la souris déterminent la position \(y_0\) de l’extrémité gauche de la corde.

Principes:
- Les évènements de type pygame.MOUSEMOTION renseignent chaque mouvement de la souris. Ces évènements possèdent un champ pos qui fournit les coordonnées (x, y) de la souris dans le repère de la fenêtre.
- Dans la boucle principale de votre programme, lorsqu’un tel évènement est détecté, il faut modifier la valeur courante de \(y_0\) de telle façon que:
  - Une position au milieu de la hauteur de la fenêtre corresponde à \(y_0 = 0\).
  - Une position dans la première ligne de la fenêtre (en haut) corresponde à \(y_0 = 1/4\).
  - Une position dans la dernière ligne de la fenêtre (en bas) corresponde approximativement à \(y_0 = -1/4\).
Nous allons maintenant simuler le mouvement des points de la corde. Afin d’arriver à une simulation suffisamment précise, l’idée consiste à effectuer plusieurs pas de simulation et non un seul à chaque rafraîchissement de l’image:
1. Définir une constante PAS_SIMULATION représentant le pas de temps, exprimé en millisecondes, séparant deux calculs. On peut par exemple définir PAS_SIMULATION = 10, qui signifie que 4 étapes de simulation seront effectuées pour chaque rafraîchissement (étant donné que ce dernier suit un rythme de 25 images par seconde).
2. Dans la boucle principale du programme, avant d’appeler la fonction chargée d’afficher la corde, évaluer pygame.time.get_ticks() qui retourne l’instant courant, exprimé en millisecondes. Placer cette valeur dans une variable appelée temps_maintenant. Ajouter également à votre boucle principale un mécanisme permettant de connaître la précédente valeur temps_precedent de temps_maintenant (c’est-à-dire, la valeur qu’avait temps_maintenant lors de l’itération précédente).
3. Toujours dans la boucle principale, effectuer une boucle qui énumère toutes les valeurs du temps depuis temps_precedent + PAS_SIMULATION jusqu’à temps_maintenant, avec un pas égal à PAS_SIMULATION. Pour chaque valeur t du temps, appeler une fonction mettre_a_jour() chargée de mettre à jour la corde. Cette fonction doit recevoir comme argument la valeur de t convertie en secondes.
4. Implémenter la fonction mettre_a_jour(). Celle-ci doit appliquer l’équation \((4)\) à l’ensemble des points de la corde d’indice compris entre \(0\) et \(N - 1\).
  
  Notes:
  - L’équation \((4)\) fournit l’accélération verticale instantanée \(\ddot{y}_i\) du point \(p_i\) à l’instant \(t\). Cette accélération permet de mettre à jour la vitesse verticale \(\dot{y}_i\) de ce point en effectuant
    
    \(\dot{y}_i \leftarrow \dot{y}_i + \ddot{y}_i \delta_t\),
    
    où \(\delta_t\) est l’incrément de temps (en secondes) depuis l’invocation précédente de mettre_a_jour(). Cette vitesse verticale permet ensuite de mettre à jour la position verticale \({y}_i\) du point en effectuant
    
    \({y}_i \leftarrow {y}_i + \dot{y}_i \delta_t\).
  - Attention, il est important d’appliquer l’équation \((4)\) en considérant la position \(y_i\) des points de la corde avant la mise à jour. (Il est facile de se tromper: Si l’on balaie les points de \(y_1\) à \(y_{N-1}\), on pourrait être tenté d’utiliser pour mettre à jour \(y_i\) la valeur de \(y_{i-1}\) déjà mise à jour à l’étape précédente.)
    
    Pour résoudre ce problème, une solution simple consiste à d’abord recopier l’entièreté du tableau contenant la position verticale des points dans un autre tableau, et de consulter ce dernier lorsque l’on applique l’équation \((4)\).
  - La densité de la corde peut etre fixée à 0.2 kg/m, et sa tension à 0.01 Newton. Pour rappel, la longueur de la corde (correspondant à \(N \Delta\)) a été fixée à 1 m.
Tester votre programme. En bougeant la souris, êtes-vous capable de créer des perturbations qui se propagent le long de la corde? Ces perturbations se réfléchissent-elles bien lorsqu’elles atteignent les points d’attache de la corde?
Vous pouvez à présent effectuer l’expérience suivante. En observant la propagation d’une perturbation, il est possible d’estimer le temps nécessaire pour qu’elle parcoure la longueur de la corde, et d’en déduire la vitesse de l’onde. (Pour effectuer cette mesure du temps de propagation, vous pouvez utiliser un chronomètre externe, ou bien en programmer un dans votre programme.)

Qu’observez-vous? La valeur mesurée correspond-t-elle à la vitesse \(\displaystyle\sqrt{\frac{T}{\mu}}\) obtenue à la section précédente? N’hésitez pas à expérimenter avec d’autres valeurs de la tension et de la densité de la corde, afin de déterminer si la simulation permet de reproduire les prédictions de la théorie.

Amortissement et mécanismes annexes¶

A ce stade, la simulation des mouvements de la corde effectuée par l’outil manque de réalisme, car elle néglige les effets dissipatifs présents dans tout dispositif physique. Par exemple, une corde de guitare ou de violon mise en vibration transfère une partie de son énergie au reste de l’instrument et à l’onde sonore produite par celui-ci, ce qui conduit à ce que cette vibration s’atténue avec le temps.

Pour modéliser cela, une solution simple consiste à ajouter un terme d”amortissement à notre équation du mouvement. On peut ainsi considérer que chaque point \(p_i = (x_i, y_i)\) de la corde, pour \(i = 1, 2, \ldots, N - 1\), est soumis à une force additionnelle d’amortissement

\(f_a = -c \dot{y}_i\)

orientée verticalement, proportionnelle à la vitesse verticale \(\dot{y}_i\) du point, et s’opposant à celle-ci.

Marche à suivre:

Mettre à jour l’équation \((4)\) de façon à tenir compte de cette nouvelle force d’amortissement.
Modifier la fonction mettre_a_jour() de votre programme en conséquence. Pour la constante d’amortissement \(c\) intervenant dans l’expression de la force d’amortissement, vous pouvez utiliser la valeur de 0.0001 kg/s.
Vérifier le bon fonctionnement du programme.

Remise à zéro¶

Cette étape consiste à ajouter au programme un mécanisme permettant de retendre la corde, c’est-à-dire de remettre à zéro la position verticale de tous ses points. Pour ce faire, le plus simple est de détecter les frappes au clavier, en gérant les évènements de type pygame.KEYDOWN. Chaque évènement de ce type possède un champ key renseignant la touche qui vient d’être pressée, par exemple pygame.K_r pour la touche “R” (comme Reset). Vous pouvez donc:

Modifier le code responsable de la gestion des évènements de façon à appeler une nouvelle fonction gerer_touche() chaque fois qu’une touche du clavier est pressée.
Passer à cette fonction un argument correspondant à la touche pressée.
Dans la fonction gerer_touche(), si la touche est un “R”, alors remettre à zéro la hauteur et la vitesse de tous les points de la corde.
Tester soigneusement votre programme.

Modes de fonctionnement supplémentaires¶

En détectant d’autres touches, il est facile d’implémenter plusieurs modes de fonctionnement du programme:

Un mode « souris » (touche “S”), que vous avez déjà implémenté, dans lequel les mouvements de la souris sont transmis à l’extrémité gauche de la corde.
Un mode « impulsion » (touche “I”), dans lequel chaque clic de la souris produit une impulsion de durée déterminée à l’extrémité gauche de la corde.
Un mode « harmonique » (touche “H”), dans lequel un mouvement harmonique est automatiquement imprimé à l’extrémité gauche de la corde. La fréquence de ce mouvement peut être modifiée en pressant les touches « flèche gauche » (ralentir) et « flèche droite » (accélérer).

La procédure à suivre est la suivante:

Définir une nouvelle variable mode dont la valeur détermine le mode courant de fonctionnement. Une bonne idée est de définir également trois constantes correspondant aux trois modes précités (peu importe leur valeur). Initialement, le simulateur est en mode « souris ».
Implémenter la détection des touches “S”, “I” et “H” (en addition à la touche “R” déjà traitée), de façon à changer le mode courant de fonctionnement lorsqu’elles sont pressées.

Afficher à l’écran le mode courant de fonctionnement, par exemple en vous basant sur le fragment de code suivant:

# A n'exécuter qu'une fois avant de rentrer dans la boucle principale:

police  = pygame.font.SysFont("monospace", 16)
couleur = (0, 0, 0)  # Noir

# ...

# A effectuer à chaque affichage:

image = police.render("mon texte", True, couleur)
fenetre.blit(image, (x, y))

Note: Pour éviter que votre code ne devienne redondant, une bonne idée est de placer les dernières instructions dans une fonction dédiée à l’affichage de texte.

Ne pas oublier de modifier la gestion de l’évènement pygame.MOUSEMOTION de façon à ce que les mouvements de la souris ne soient pris en compte que dans le mode « souris ».
Tester que le mécanisme de changement de mode fonctionne.
Implémenter le mode « impulsion ». Lorsque ce mode est actif, le programme doit détecter les évènements de type pygame.MOUSEBUTTONDOWN pour lesquels le champ button vaut 1 (correspondant au bouton de gauche de la souris). Lorsqu’un tel clic est repéré, le simulateur doit lever l’extrémité gauche de la corde (c’est-à-dire attribuer une valeur donnée à \(y_0\)) pendant un temps donné.

Cette opération dépend donc de deux paramètres:
- L’amplitude de l’impulsion, correspondant à la hauteur à laquelle la corde est levée. Vous pouvez attribuer la valeur de 0.2 m à ce paramètre.
- La largeur de l’impulsion, correspondant au délai pendant lequel la corde est levée à chaque impulsion. Une suggestion est d’employer une valeur de 0.050 s.
Vérifier que le mode « impulsion » fonctionne comme attendu.
Implémenter le mode « harmonique ». Lorsque celui-ci est actif, l’extrémité gauche de la corde doit suivre un mouvement sinusoïdal d’amplitude et de fréquence données. Une manière simple d’implémenter ce mécanisme est la suivante:
1. Définir une variable globale frequence donnant la fréquence courante de l’oscillateur harmonique. Dans un premier temps, une fréquence de 0.5 Hz peut être utilisée. (Nous implémenterons plus tard le mécanisme permettant de faire varier cette fréquence.)
2. Définir une variable gobale alpha retenant la phase courante de l’oscillateur harmonique (c’est-à-dire l’angle en radians qui sera utilisé pour calculer le mouvement sinusoïdal de l’oscillateur).
3. Dans mise_a_jour(), si le mode harmonique est actif, mettre à jour alpha en fonction de l’incrément de temps depuis l’invocation précédente et de la valeur courante de frequence. Mettre ensuite à jour \(y_0\) en multipliant le sinus de alpha par l’amplitude de l’oscillateur. Cette amplitude peut être fixée à 0.1 m.
4. Dans le mode harmonique, afficher la valeur courante de la fréquence à l’écran. Vous pouvez utiliser la construction suivante, produisant une chaîne de caractères dans laquelle frequence est formaté avec quatre chiffres après la virgule:
```
"Frequence : {0:.4f} Hz".format(frequence)
```
5. Détecter les frappes des touches « flèche gauche » (pygame.KEY_LEFT) et « flèche droite » (pygame.KEY_RIGHT), et modifier la fréquence courante de façon appropriée (par exemple en la divisant ou multipliant par 1.001).
  
  Pour que ce mécanisme soit pratique à utiliser, une bonne idée est d’exécuter:
```
pygame.key.set_repeat(10, 10)
```
  avant de rentrer dans la boucle principale du programme. Cette instruction modifie le délai après lequel un appui prolongé sur une touche du clavier genère des évènements répétés.
Vérifier que le mode « harmonique » est fonctionnel. Vous devrier obtenir un affichage proche de celui-ci:

Mode harmonique.
Déposer votre programme dans le répertoire centralisé, sous le suffixe prog-15.py.

Expériences¶

Cette dernière étape consiste à utiliser le simulateur que vous avez développé pour effectuer quelques expériences.

La propagation d’une impulsion¶

Le mode « impulsion » permet de mettre en évidence la réponse en fréquence limitée du système: L’impulsion générée par votre programme correspond à un signal constant pendant un intervalle, et nul le reste du temps, mais celui qui est propagé le long de la corde n’a pas exactement cette forme. Ce signal contient en effet des composantes à haute fréquence, associés à des changements brusques de hauteur, que le système atténue fortement.

Un autre phénomène facile à observer est le retournement du signal lorsqu’il se réfléchit aux extrémités fixes de la corde. Si vous modifiez le code du simulateur de façon à ce que l’extrémité droite de la corde reste libre de se déplacer verticalement, vous observerez un comportement différent. (Note: Cette modification n’est pas triviale, car elle nécessite d’employer une version adaptée de l’équation \((4)\) pour le point situé à l’extrémité droite de la corde. Vous n’êtes pas obligé de l’implémenter.)

La résonance¶

Lorsque le simulateur est en mode « harmonique », il est intéressant d’observer l’influence du choix de la fréquence de l’oscillateur sur l’amplitude des mouvements de la corde. Pour certaines fréquences, cette amplitude est du même ordre que celle de l’oscillateur harmonique (que nous avions fixée à 0.1 m). Pour d’autres, l’amplitude devient beaucoup plus importante. Note: Pour bien observer cela, il faut attendre, après une modification de la fréquence, un temps suffisant pour que les signaux transitoires aient disparu.

Le phénomène qui permet d’obtenir un signal d’amplitude plus élevée que celle de l’oscillateur utilisé pour exciter la corde est appelé résonance. Il possède de nombreuses applications; c’est notamment grâce à lui que la plupart des instruments de musique produisent leur son. Une façon de le mettre en évidence à l’aide du simulateur consiste à régler l’oscillateur sur la fréquence naturelle de la corde, que l’on peut déterminer soit empiriquement (seriez-vous capable de trouver expérimentalement la fréquence conduisant à l’amplitude la plus grande?), soit par un calcul:

Pour rappel, la vitesse de propagation des ondes sur la corde vaut

\(\displaystyle v = \sqrt{\frac{T}{\mu}}\),

où \(T\) et \(\mu\) désignent respectivement la tension et la densité de la corde.
Notons \(L\) la longueur de la corde (égale à 1 m dans notre simulation). Le délai nécessaire à un aller et retour d’une perturbation sur la corde est égal à:

\(\displaystyle \frac{2L}{\sqrt{\frac{T}{\mu}}}\)
Pour que l’oscillateur harmonique possède une période égale à ce délai, sa fréquence doit être égale à:

\(\displaystyle \frac{\sqrt{\frac{T}{\mu}}}{2L}\).

Vous pouvez donc calculer cette valeur, et essayer de l’introduire dans votre programme. Le phénomène de résonance devient-il visible? Est-ce le cas également lorsque vous utilisez un multiple entier de la fréquence calculée? Comment cela s’explique-t-il? Pouvez-vous aussi calculer une fréquence conduisant à l’amplitude minimale du signal?

Conclusions¶

Si vous avez atteint ce point, félicitations, vous êtes arrivé au terme de ces laboratoires. Nous espérons que ceux-ci vous ont permis de découvrir quelques applications intéressantes des notions que vous avez étudiées dans d’autres cours, et de renforcer votre expérience en programmation. Merci enfin d’avoir participé aussi activement aux séances. Si vous avez des suggestions sur la façon d’améliorer ces laboratoires, n’hésitez pas à les transmettre.